ppc fixes
[dyninst.git] / dyninstAPI / src / inst-power.C
1 /*
2  * See the dyninst/COPYRIGHT file for copyright information.
3  * 
4  * We provide the Paradyn Tools (below described as "Paradyn")
5  * on an AS IS basis, and do not warrant its validity or performance.
6  * We reserve the right to update, modify, or discontinue this
7  * software at any time.  We shall have no obligation to supply such
8  * updates or modifications or any other form of support to you.
9  * 
10  * By your use of Paradyn, you understand and agree that we (or any
11  * other person or entity with proprietary rights in Paradyn) are
12  * under no obligation to provide either maintenance services,
13  * update services, notices of latent defects, or correction of
14  * defects for Paradyn.
15  * 
16  * This library is free software; you can redistribute it and/or
17  * modify it under the terms of the GNU Lesser General Public
18  * License as published by the Free Software Foundation; either
19  * version 2.1 of the License, or (at your option) any later version.
20  * 
21  * This library is distributed in the hope that it will be useful,
22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
24  * Lesser General Public License for more details.
25  * 
26  * You should have received a copy of the GNU Lesser General Public
27  * License along with this library; if not, write to the Free Software
28  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
29  */
30
31 /*
32  * inst-power.C - Identify instrumentation points for a RS6000/PowerPCs
33  * $Id: inst-power.C,v 1.291 2008/06/19 22:13:42 jaw Exp $
34  */
35
36 #include "common/src/headers.h"
37 #include "dyninstAPI/h/BPatch_memoryAccess_NP.h"
38 #include "dyninstAPI/src/image.h"
39 #include "dyninstAPI/src/dynProcess.h"
40 #include "dyninstAPI/src/inst.h"
41 #include "dyninstAPI/src/instP.h"
42 #include "dyninstAPI/src/inst-power.h"
43 #include "common/src/arch.h"
44 #include "dyninstAPI/src/codegen.h"
45 #include "dyninstAPI/src/ast.h"
46 #include "dyninstAPI/src/util.h"
47 #include "common/src/stats.h"
48 #include "dyninstAPI/src/os.h"
49 #include "dyninstAPI/src/instPoint.h" // class instPoint
50 #include "dyninstAPI/src/debug.h"
51 #include "common/src/debugOstream.h"
52 #include "dyninstAPI/src/baseTramp.h"
53 #include "dyninstAPI/h/BPatch.h"
54 #include "dyninstAPI/src/BPatch_collections.h"
55 #include "dyninstAPI/src/registerSpace.h"
56 #include "dyninstAPI/src/binaryEdit.h"
57 #include "dyninstAPI/src/function.h"
58 #include "dyninstAPI/src/mapped_object.h"
59
60 #include "parseAPI/h/CFG.h"
61
62 #include "emitter.h"
63 #include "emit-power.h"
64
65 #include <sstream>
66
67 #include "dyninstAPI/h/BPatch_memoryAccess_NP.h"
68
69 extern bool isPowerOf2(int value, int &result);
70
71 #define DISTANCE(x,y)   ((x<y) ? (y-x) : (x-y))
72
73 Address getMaxBranch() {
74   return MAX_BRANCH;
75 }
76
77 const char *registerNames[] = { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
78                         "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
79                         "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
80                         "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"};
81
82 std::unordered_map<std::string, unsigned> funcFrequencyTable;
83
84 void initDefaultPointFrequencyTable()
85 {
86 #ifdef notdef
87     funcFrequencyTable[EXIT_NAME] = 1;
88
89     FILE *fp;
90     float value;
91     char name[512];
92
93     funcFrequencyTable["main"] = 1;
94     funcFrequencyTable["DYNINSTsampleValues"] = 1;
95     // try to read file.
96     fp = fopen("freq.input", "r");
97     if (!fp) {
98         bperr("no freq.input file\n");
99         return;
100     }
101     while (!feof(fp)) {
102         fscanf(fp, "%s %f\n", name, &value);
103         funcFrequencyTable[name] = (int) value;
104         bperr("adding %s %f\n", name, value);
105     }
106     fclose(fp);
107 #endif
108 }
109
110 Register floatingLiveRegList[] = {13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
111 unsigned int floatingLiveRegListSize = 14;
112
113 // Note that while we have register definitions for r13..r31, we only
114 // use r0..r12 (well, r3..r12). I believe this is to reduce the number
115 // of saves that we execute. 
116
117
118 void registerSpace::initialize32() {
119     static bool done = false;
120     if (done) return;
121     done = true;
122
123     pdvector<registerSlot *> registers;
124
125     // At ABI boundary: R0 and R12 are dead, others are live.
126     // Also, define registers in reverse order - it helps with
127     // function calls
128     
129     registers.push_back(new registerSlot(r12,
130                                          "r12",
131                                          false,
132                                          registerSlot::deadABI,
133                                          registerSlot::GPR));
134     registers.push_back(new registerSlot(r11,
135                                          "r11",
136                                          false,
137                                          registerSlot::liveAlways,
138                                          registerSlot::GPR));
139     registers.push_back(new registerSlot(r10,
140                                          "r10",
141                                          false,
142                                          registerSlot::liveAlways,
143                                          registerSlot::GPR));
144     registers.push_back(new registerSlot(r9,
145                                          "r9",
146                                          false,
147                                          registerSlot::liveAlways,
148                                          registerSlot::GPR));
149     registers.push_back(new registerSlot(r8,
150                                          "r8",
151                                          false,
152                                          registerSlot::liveAlways,
153                                          registerSlot::GPR));
154     registers.push_back(new registerSlot(r7,
155                                          "r7",
156                                          false,
157                                          registerSlot::liveAlways,
158                                          registerSlot::GPR));
159     registers.push_back(new registerSlot(r6,
160                                          "r6",
161                                          false,
162                                          registerSlot::liveAlways,
163                                          registerSlot::GPR));
164     registers.push_back(new registerSlot(r5,
165                                          "r5",
166                                          false,
167                                          registerSlot::liveAlways,
168                                          registerSlot::GPR));
169     registers.push_back(new registerSlot(r4,
170                                          "r4",
171                                          false,
172                                          registerSlot::liveAlways,
173                                          registerSlot::GPR));
174     registers.push_back(new registerSlot(r3,
175                                          "r3",
176                                          false,
177                                          registerSlot::liveAlways,
178                                          registerSlot::GPR));
179
180     // Everyone else
181     for (unsigned i = r13; i <= r31; ++i) {
182       char name[32];
183       sprintf(name, "r%2d", i-r0);
184       registers.push_back(new registerSlot(i, name,
185                                            false, 
186                                            registerSlot::liveAlways,
187                                            registerSlot::GPR));
188     }
189
190     /// Aaaand the off-limits ones.
191
192     registers.push_back(new registerSlot(r0,
193                                          "r0",
194                                          true, // Don't use r0 - it has all sorts
195                                          // of implicit behavior.
196                                          registerSlot::deadABI,
197                                          registerSlot::GPR));
198     registers.push_back(new registerSlot(r1,
199                                          "r1",
200                                          true,
201                                          registerSlot::liveAlways,
202                                          registerSlot::GPR));
203     registers.push_back(new registerSlot(r2,
204                                          "r2",
205                                          true,
206                                          registerSlot::liveAlways,
207                                          registerSlot::GPR));
208
209     for (unsigned i = fpr0; i <= fpr13; i++) {
210         char buf[128];
211         sprintf(buf, "fpr%d", i - fpr0);
212         registers.push_back(new registerSlot(i,
213                                              buf,
214                                              false,
215                                              registerSlot::liveAlways,
216                                              registerSlot::FPR));
217     }
218     registers.push_back(new registerSlot(xer,
219                                          "xer",
220                                          true,
221                                          registerSlot::liveAlways,
222                                          registerSlot::SPR));
223  
224     registers.push_back(new registerSlot(lr,
225                                          "lr",
226                                          true,
227                                          registerSlot::liveAlways,
228                                          registerSlot::SPR));
229     registers.push_back(new registerSlot(cr,
230                                          "cr",
231                                          true,
232                                          registerSlot::liveAlways,
233                                          registerSlot::SPR));
234     registers.push_back(new registerSlot(ctr,
235                                          "ctr",
236                                          true,
237                                          registerSlot::liveAlways,
238                                          registerSlot::SPR));
239     registers.push_back(new registerSlot(mq,
240                                          "mq",
241                                          true,
242                                          registerSlot::liveAlways,
243                                          registerSlot::SPR));
244     registerSpace::createRegisterSpace(registers);
245
246     // Initialize the sets that encode which registers
247     // are used/defined by calls, returns, and syscalls. 
248     // These all assume the ABI, of course. 
249
250     // TODO: Linux/PPC needs these set as well.
251     
252
253 }
254
255 void registerSpace::initialize64() {
256     static bool done = false;
257     if (done) return;
258     done = true;
259
260     pdvector<registerSlot *> registers;
261
262     // At ABI boundary: R0 and R12 are dead, others are live.
263     // Also, define registers in reverse order - it helps with
264     // function calls
265     
266     registers.push_back(new registerSlot(r12,
267                                          "r12",
268                                          false,
269                                          registerSlot::deadABI,
270                                          registerSlot::GPR));
271     registers.push_back(new registerSlot(r11,
272                                          "r11",
273                                          false,
274                                          registerSlot::liveAlways,
275                                          registerSlot::GPR));
276     registers.push_back(new registerSlot(r10,
277                                          "r10",
278                                          false,
279                                          registerSlot::liveAlways,
280                                          registerSlot::GPR));
281     registers.push_back(new registerSlot(r9,
282                                          "r9",
283                                          false,
284                                          registerSlot::liveAlways,
285                                          registerSlot::GPR));
286     registers.push_back(new registerSlot(r8,
287                                          "r8",
288                                          false,
289                                          registerSlot::liveAlways,
290                                          registerSlot::GPR));
291     registers.push_back(new registerSlot(r7,
292                                          "r7",
293                                          false,
294                                          registerSlot::liveAlways,
295                                          registerSlot::GPR));
296     registers.push_back(new registerSlot(r6,
297                                          "r6",
298                                          false,
299                                          registerSlot::liveAlways,
300                                          registerSlot::GPR));
301     registers.push_back(new registerSlot(r5,
302                                          "r5",
303                                          false,
304                                          registerSlot::liveAlways,
305                                          registerSlot::GPR));
306     registers.push_back(new registerSlot(r4,
307                                          "r4",
308                                          false,
309                                          registerSlot::liveAlways,
310                                          registerSlot::GPR));
311     registers.push_back(new registerSlot(r3,
312                                          "r3",
313                                          false,
314                                          registerSlot::liveAlways,
315                                          registerSlot::GPR));
316
317
318     // Everyone else
319     for (unsigned i = r13; i <= r31; ++i) {
320       char name[32];
321       sprintf(name, "r%2d", i-r0);
322       registers.push_back(new registerSlot(i, name,
323                                            false, 
324                                            registerSlot::liveAlways,
325                                            registerSlot::GPR));
326     }
327
328
329     /// Aaaand the off-limits ones.
330
331     registers.push_back(new registerSlot(r0,
332                                          "r0",
333                                          true, // Don't use r0 - it has all sorts
334                                          // of implicit behavior.
335                                          registerSlot::deadABI,
336                                          registerSlot::GPR));
337     registers.push_back(new registerSlot(r1,
338                                          "r1",
339                                          true,
340                                          registerSlot::liveAlways,
341                                          registerSlot::GPR));
342     registers.push_back(new registerSlot(r2,
343                                          "r2",
344                                          true,
345                                          registerSlot::liveAlways,
346                                          registerSlot::GPR));
347
348     for (unsigned i = fpr0; i <= fpr13; i++) {
349         char buf[128];
350         sprintf(buf, "fpr%d", i - fpr0);
351         registers.push_back(new registerSlot(i,
352                                              buf,
353                                              false,
354                                              registerSlot::liveAlways,
355                                              registerSlot::FPR));
356     }
357     registers.push_back(new registerSlot(xer,
358                                          "xer",
359                                          true,
360                                          registerSlot::liveAlways,
361                                          registerSlot::SPR));
362     registers.push_back(new registerSlot(lr,
363                                          "lr",
364                                          true,
365                                          registerSlot::liveAlways,
366                                          registerSlot::SPR));
367     registers.push_back(new registerSlot(cr,
368                                          "cr",
369                                          true,
370                                          registerSlot::liveAlways,
371                                          registerSlot::SPR));
372     registers.push_back(new registerSlot(ctr,
373                                          "ctr",
374                                          true,
375                                          registerSlot::liveAlways,
376                                          registerSlot::SPR));
377     registers.push_back(new registerSlot(mq,
378                                          "mq",
379                                          true,
380                                          registerSlot::liveAlways,
381                                          registerSlot::SPR));
382     registerSpace::createRegisterSpace64(registers);
383
384     // Initialize the sets that encode which registers
385     // are used/defined by calls, returns, and syscalls. 
386     // These all assume the ABI, of course. 
387
388     // TODO: Linux/PPC needs these set as well.
389     
390
391 }
392
393 void registerSpace::initialize() {
394     initialize32();
395     initialize64();
396 }
397
398 unsigned registerSpace::SPR(Register x) {
399     // Encodings from architecture manual
400     switch ((powerRegisters_t) x) {
401     case xer:
402         return SPR_XER;
403         break;
404     case lr:
405         return SPR_LR;
406         break;
407     case ctr:
408         return SPR_CTR;
409         break;
410     case mq:
411         return SPR_MQ;
412         break;
413     case cr:
414         fprintf(stderr, "Error: condition register has no encoding!\n");
415         return REG_NULL;
416         break;
417     default:
418         assert(0);
419         return REG_NULL;
420         break;
421     }
422 }
423             
424
425 /*
426  * Saving and restoring registers
427  * We create a new stack frame in the base tramp and save registers
428  * above it. Currently, the plan is this:
429  *          < 220 bytes as per system spec      > + 4 for 64-bit alignment
430  *          < 14 GPR slots @ 4 bytes each       >
431  *          < 14 FPR slots @ 8 bytes each       >
432  *          < 6 SPR slots @ 4 bytes each        >
433  *          < 1 FP SPR slot @ 8 bytes           >
434  *          < Space to save live regs at func call >
435  *          < Func call overflow area, 32 bytes > 
436  *          < Linkage area, 24 bytes            >
437  *
438  * Of course, change all the 4's to 8's for 64-bit mode.
439  */
440
441     ////////////////////////////////////////////////////////////////////
442     //Generates instructions to save a special purpose register onto
443     //the stack.
444     //  Returns the number of bytes needed to store the generated
445     //    instructions.
446     //  The instruction storage pointer is advanced the number of 
447     //    instructions generated.
448     //
449 // NOTE: the bit layout of the mfspr instruction is as follows:
450 // opcode:6 ; RT: 5 ; SPR: 10 ; const 339:10 ; Rc: 1
451 // However, the two 5-bit halves of the SPR field are reversed
452 // so just using the xfxform will not work
453 void saveSPR(codeGen &gen,     //Instruction storage pointer
454              Register    scratchReg, //Scratch register
455              int         sprnum,     //SPR number
456              int         stkOffset) //Offset from stack pointer
457 {
458     instruction insn;
459
460     // mfspr:  mflr scratchReg
461     insn.clear();
462     XFORM_OP_SET(insn, EXTop);
463     XFORM_RT_SET(insn, scratchReg);
464     XFORM_RA_SET(insn, sprnum & 0x1f);
465     XFORM_RB_SET(insn, (sprnum >> 5) & 0x1f);
466     XFORM_XO_SET(insn, MFSPRxop);
467     insnCodeGen::generate(gen,insn);
468
469     if (gen.width() == 4) {
470         insnCodeGen::generateImm(gen, STop,
471                                  scratchReg, REG_SP, stkOffset);
472     } else /* gen.width() == 8 */ {
473         insnCodeGen::generateMemAccess64(gen, STDop, STDxop,
474                                          scratchReg, REG_SP, stkOffset);
475     }
476 }
477
478     ////////////////////////////////////////////////////////////////////
479     //Generates instructions to restore a special purpose register from
480     //the stack.
481     //  Returns the number of bytes needed to store the generated
482     //    instructions.
483     //  The instruction storage pointer is advanced the number of 
484     //    instructions generated.
485     //
486 void restoreSPR(codeGen &gen,       //Instruction storage pointer
487                 Register      scratchReg, //Scratch register
488                 int           sprnum,     //SPR number
489                 int           stkOffset)  //Offset from stack pointer
490 {
491     if (gen.width() == 4) {
492         insnCodeGen::generateImm(gen, Lop,
493                                  scratchReg, REG_SP, stkOffset);
494     } else /* gen.width() == 8 */ {
495         insnCodeGen::generateMemAccess64(gen, LDop, LDxop,
496                                          scratchReg, REG_SP, stkOffset);
497     }
498
499     instruction insn;
500     insn.clear();
501
502     //mtspr:  mtlr scratchReg
503     XFORM_OP_SET(insn, EXTop);
504     XFORM_RT_SET(insn, scratchReg);
505     XFORM_RA_SET(insn, sprnum & 0x1f);
506     XFORM_RB_SET(insn, (sprnum >> 5) & 0x1f);
507     XFORM_XO_SET(insn, MTSPRxop);
508     insnCodeGen::generate(gen,insn);
509 }
510
511            ////////////////////////////////////////////////////////////////////
512            //Generates instructions to save link register onto stack.
513            //  Returns the number of bytes needed to store the generated
514            //    instructions.
515            //  The instruction storage pointer is advanced the number of 
516            //    instructions generated.
517 void saveLR(codeGen &gen,       //Instruction storage pointer
518             Register      scratchReg, //Scratch register
519             int           stkOffset)  //Offset from stack pointer
520 {
521     saveSPR(gen, scratchReg, SPR_LR, stkOffset);
522     gen.rs()->markSavedRegister(registerSpace::lr, stkOffset);
523 }
524
525            ////////////////////////////////////////////////////////////////////
526            //Generates instructions to restore link register from stack.
527            //  Returns the number of bytes needed to store the generated
528            //    instructions.
529            //  The instruction storage pointer is advanced the number of 
530            //    instructions generated.
531            //
532 void restoreLR(codeGen &gen,       //Instruction storage pointer
533                Register      scratchReg, //Scratch register
534                int           stkOffset)  //Offset from stack pointer
535 {
536     restoreSPR(gen, scratchReg, SPR_LR, stkOffset);
537 }
538
539            ////////////////////////////////////////////////////////////////////
540            //Generates instructions to place a given value into link register.
541            //  The entire instruction sequence consists of the generated
542            //    instructions followed by a given (tail) instruction.
543            //  Returns the number of bytes needed to store the entire
544            //    instruction sequence.
545            //  The instruction storage pointer is advanced the number of 
546            //    instructions in the sequence.
547            //
548 void setBRL(codeGen &gen,        //Instruction storage pointer
549             Register      scratchReg,  //Scratch register
550             long          val,         //Value to set link register to
551             instruction   ti)          //Tail instruction
552 {
553     insnCodeGen::loadImmIntoReg(gen, scratchReg, val);
554
555     instruction insn;
556
557     //mtspr:  mtlr scratchReg
558     insn.clear();
559     XFORM_OP_SET(insn, EXTop);
560     XFORM_RT_SET(insn, scratchReg);
561     XFORM_RA_SET(insn, SPR_LR);
562     XFORM_XO_SET(insn, MTSPRxop);
563     insnCodeGen::generate(gen,insn);
564
565     insn = ti;
566     insnCodeGen::generate(gen,insn);
567 }
568
569      //////////////////////////////////////////////////////////////////////////
570      //Writes out instructions to place a value into the link register.
571      //  If val == 0, then the instruction sequence is followed by a `nop'.
572      //  If val != 0, then the instruction sequence is followed by a `brl'.
573      //
574 void resetBRL(AddressSpace  *p,   //Process to write instructions into
575               Address   loc, //Address in process to write into
576               unsigned  val) //Value to set link register
577 {
578     codeGen gen(10*instruction::size());
579     Register scratch = 10;
580     if (val) {
581         setBRL(gen, scratch, val, instruction(BRLraw));
582     }
583     else {
584         setBRL(gen, scratch, val, instruction(NOOPraw));
585     }
586     p->writeTextSpace((void *)loc, gen.used(), gen.start_ptr());
587 }
588
589     /////////////////////////////////////////////////////////////////////////
590     //Generates instructions to save the condition codes register onto stack.
591     //  Returns the number of bytes needed to store the generated
592     //    instructions.
593     //  The instruction storage pointer is advanced the number of 
594     //    instructions generated.
595     //
596 void saveCR(codeGen &gen,       //Instruction storage pointer
597             Register      scratchReg, //Scratch register
598             int           stkOffset)  //Offset from stack pointer
599 {
600     instruction insn;
601
602     //mfcr:  mflr scratchReg
603     insn.clear();
604     XFXFORM_OP_SET(insn, EXTop);
605     XFXFORM_RT_SET(insn, scratchReg);
606     XFXFORM_XO_SET(insn, MFCRxop);
607     insnCodeGen::generate(gen,insn);
608
609     if (gen.width() == 4) {
610         insnCodeGen::generateImm(gen, STop,
611                                  scratchReg, REG_SP, stkOffset);
612     } else /* gen.width() == 8 */ {
613         insnCodeGen::generateMemAccess64(gen, STDop, STDxop,
614                                          scratchReg, REG_SP, stkOffset);
615     }
616 }
617
618     ///////////////////////////////////////////////////////////////////////////
619     //Generates instructions to restore the condition codes register from stack.
620     //  Returns the number of bytes needed to store the generated
621     //    instructions.
622     //  The instruction storage pointer is advanced the number of 
623     //    instructions generated.
624     //
625 void restoreCR(codeGen &gen,       //Instruction storage pointer
626                Register      scratchReg, //Scratch register
627                int           stkOffset)  //Offset from stack pointer
628 {
629     instruction insn;
630
631     if (gen.width() == 4) {
632         insnCodeGen::generateImm(gen, Lop,
633                                  scratchReg, REG_SP, stkOffset);
634     } else /* gen.width() == 8 */ {
635         insnCodeGen::generateMemAccess64(gen, LDop, LDxop,
636                                          scratchReg, REG_SP, stkOffset);
637     }
638
639     //mtcrf:  scratchReg
640     insn.clear();
641     XFXFORM_OP_SET(insn, EXTop);
642     XFXFORM_RT_SET(insn, scratchReg);
643     XFXFORM_SPR_SET(insn, 0xff << 1);
644     XFXFORM_XO_SET(insn, MTCRFxop);
645     insnCodeGen::generate(gen,insn);
646 }
647
648     /////////////////////////////////////////////////////////////////////////
649     //Generates instructions to save the floating point status and control
650     //register on the stack.
651     //  Returns the number of bytes needed to store the generated
652     //    instructions.
653     //  The instruction storage pointer is advanced the number of 
654     //    instructions generated.
655     //
656 void saveFPSCR(codeGen &gen,       //Instruction storage pointer
657                Register      scratchReg, //Scratch fp register
658                int           stkOffset)  //Offset from stack pointer
659 {
660     instruction mffs;
661
662     //mffs scratchReg
663     mffs.clear();
664     XFORM_OP_SET(mffs, X_FP_EXTENDEDop);
665     XFORM_RT_SET(mffs, scratchReg);
666     XFORM_XO_SET(mffs, MFFSxop);
667     insnCodeGen::generate(gen,mffs);
668
669     //st:     st scratchReg, stkOffset(r1)
670     insnCodeGen::generateImm(gen, STFDop, scratchReg, REG_SP, stkOffset);
671 }
672
673     ///////////////////////////////////////////////////////////////////////////
674     //Generates instructions to restore the floating point status and control
675     //register from the stack.
676     //  Returns the number of bytes needed to store the generated
677     //    instructions.
678     //  The instruction storage pointer is advanced the number of 
679     //    instructions generated.
680     //
681 void restoreFPSCR(codeGen &gen,       //Instruction storage pointer
682                   Register      scratchReg, //Scratch fp register
683                   int           stkOffset)  //Offset from stack pointer
684 {
685     insnCodeGen::generateImm(gen, LFDop, scratchReg, REG_SP, stkOffset);
686
687     instruction mtfsf;
688
689     //mtfsf:  scratchReg
690     mtfsf.clear();
691     XFLFORM_OP_SET(mtfsf, X_FP_EXTENDEDop);
692     XFLFORM_FLM_SET(mtfsf, 0xff);
693     XFLFORM_FRB_SET(mtfsf, scratchReg);
694     XFLFORM_XO_SET(mtfsf, MTFSFxop);
695     insnCodeGen::generate(gen,mtfsf);
696 }
697
698      //////////////////////////////////////////////////////////////////////////
699      //Writes out a `br' instruction
700      //
701 void resetBR(AddressSpace  *p,    //Process to write instruction into
702              Address   loc)  //Address in process to write into
703 {
704     instruction i = BRraw;
705
706     if (!p->writeDataSpace((void *)loc, instruction::size(), i.ptr()))
707         fprintf(stderr, "%s[%d]:  writeDataSpace failed\n", FILE__, __LINE__);
708 }
709
710 void saveRegisterAtOffset(codeGen &gen,
711                           Register reg,
712                           int save_off) {
713     if (gen.width() == 4) {
714         insnCodeGen::generateImm(gen, STop,
715                                  reg, REG_SP, save_off);
716     } else /* gen.width() == 8 */ {
717         insnCodeGen::generateMemAccess64(gen, STDop, STDxop,
718                                          reg, REG_SP, save_off);
719     }
720 }
721
722 // Dest != reg : optimizate away a load/move pair
723 void saveRegister(codeGen &gen,
724                   Register source,
725                   Register dest,
726                   int save_off)
727 {
728     saveRegisterAtOffset(gen, source, save_off + (dest * gen.width()));
729     //  bperr("Saving reg %d at 0x%x off the stack\n", reg, offset + reg*GPRSIZE);
730 }
731
732 void saveRegister(codeGen &gen,
733                   Register reg,
734                   int save_off)
735 {
736     saveRegister(gen, reg, reg, save_off);
737 }
738
739 void restoreRegisterAtOffset(codeGen &gen,
740                              Register dest,
741                              int saved_off) {
742     if (gen.width() == 4) {
743         insnCodeGen::generateImm(gen, Lop, 
744                                  dest, REG_SP, saved_off);
745     } else /* gen.width() == 8 */ {
746         insnCodeGen::generateMemAccess64(gen, LDop, LDxop,
747                                          dest, REG_SP, saved_off);
748     }
749 }
750
751 // Dest != reg : optimizate away a load/move pair
752 void restoreRegister(codeGen &gen,
753                      Register source,
754                      Register dest, 
755                      int saved_off)
756 {
757     return restoreRegisterAtOffset(gen, dest, saved_off + (source * gen.width()));
758     //bperr( "Loading reg %d (into reg %d) at 0x%x off the stack\n", 
759     //  reg, dest, offset + reg*GPRSIZE);
760 }
761
762 void restoreRegister(codeGen &gen,
763                      Register reg,
764                      int save_off)
765 {
766     restoreRegister(gen, reg, reg, save_off);
767 }
768
769 void saveFPRegister(codeGen &gen, 
770                     Register reg,
771                     int save_off)
772 {
773     insnCodeGen::generateImm(gen, STFDop, 
774                              reg, REG_SP, save_off + reg*FPRSIZE);
775     //bperr( "Saving FP reg %d at 0x%x off the stack\n", 
776     //  reg, offset + reg*FPRSIZE);
777 }
778
779 void restoreFPRegister(codeGen &gen,
780                        Register source,
781                        Register dest,
782                        int save_off)
783 {
784     insnCodeGen::generateImm(gen, LFDop, 
785                              dest, REG_SP, save_off + source*FPRSIZE);
786     //  bperr("Loading FP reg %d (into %d) at 0x%x off the stack\n", 
787     //  reg, dest, offset + reg*FPRSIZE);
788 }
789
790 void restoreFPRegister(codeGen &gen,
791                        Register reg,
792                        int save_off)
793 {
794     restoreFPRegister(gen, reg, reg, save_off);
795 }       
796
797 /*
798  * Emit code to push down the stack, AST-generate style
799  */
800 void pushStack(codeGen &gen)
801 {
802     if (gen.width() == 4) {
803         insnCodeGen::generateImm(gen, STUop,
804                                  REG_SP, REG_SP, -TRAMP_FRAME_SIZE_32);
805     } else /* gen.width() == 8 */ {
806         insnCodeGen::generateMemAccess64(gen, STDop, STDUxop,
807                                   REG_SP, REG_SP, -TRAMP_FRAME_SIZE_64);
808     }
809 }
810
811 void popStack(codeGen &gen)
812 {
813     if (gen.width() == 4) {
814         insnCodeGen::generateImm(gen, CALop, 
815                                  REG_SP, REG_SP, TRAMP_FRAME_SIZE_32);
816
817     } else /* gen.width() == 8 */ {
818         insnCodeGen::generateImm(gen, CALop,
819                                  REG_SP, REG_SP, TRAMP_FRAME_SIZE_64);
820     }
821 }
822
823 /*
824  * Save necessary registers on the stack
825  * insn, base: for code generation. Offset: regs saved at offset + reg
826  * Returns: number of registers saved.
827  * Side effects: instruction pointer and base param are shifted to 
828  *   next free slot.
829  */
830 unsigned saveGPRegisters(codeGen &gen,
831                          registerSpace *theRegSpace,
832                          int save_off, int numReqGPRs)
833 {
834     int numRegs = 0;
835     if (numReqGPRs == -1 ) numReqGPRs = theRegSpace->numGPRs();
836     for(int i = 0; i < theRegSpace->numGPRs(); i++) {
837         registerSlot *reg = theRegSpace->GPRs()[i];
838         if (reg->liveState == registerSlot::live) {
839             saveRegister(gen, reg->encoding(), save_off);
840             // saveRegister implicitly adds in (reg * word size)
841             // Do that by hand here.
842             
843             int actual_save_off = save_off;
844
845             actual_save_off += (reg->encoding() * gen.width());
846
847             gen.rs()->markSavedRegister(reg->number, actual_save_off);
848             numRegs++;
849             if (numRegs == numReqGPRs) break;
850         }
851     }
852     return numRegs;
853 }
854
855 /*
856  * Restore necessary registers from the stack
857  * insn, base: for code generation. Offset: regs restored from offset + reg
858  * Returns: number of registers restored.
859  * Side effects: instruction pointer and base param are shifted to 
860  *   next free slot.
861  */
862
863 unsigned restoreGPRegisters(codeGen &gen,
864                             registerSpace *theRegSpace,
865                             int save_off)
866 {
867     unsigned numRegs = 0;
868     for(int i = 0; i < theRegSpace->numGPRs(); i++) {
869         registerSlot *reg = theRegSpace->GPRs()[i];
870         if (reg->liveState == registerSlot::spilled) {
871             restoreRegister(gen, reg->encoding(), save_off);
872             numRegs++;
873         }
874     }
875
876     return numRegs;
877 }
878
879 /*
880  * Save FPR registers on the stack. (0-13)
881  * insn, base: for code generation. Offset: regs saved at offset + reg
882  * Returns: number of regs saved.
883  */
884
885 unsigned saveFPRegisters(codeGen &gen,
886                          registerSpace * theRegSpace,
887                          int save_off)
888 {
889   unsigned numRegs = 0;
890   for(int i = 0; i < theRegSpace->numFPRs(); i++) {
891       registerSlot *reg = theRegSpace->FPRs()[i];
892       if (reg->liveState == registerSlot::live) {
893           saveFPRegister(gen, reg->encoding(), save_off);
894           reg->liveState = registerSlot::spilled;
895           numRegs++;
896       }
897   }  
898   
899   return numRegs;
900 }
901
902 /*
903  * Restore FPR registers from the stack. (0-13)
904  * insn, base: for code generation. Offset: regs restored from offset + reg
905  * Returns: number of regs restored.
906  */
907
908 unsigned restoreFPRegisters(codeGen &gen, 
909                             registerSpace *theRegSpace,
910                             int save_off)
911 {
912   
913   unsigned numRegs = 0;
914   for(int i = 0; i < theRegSpace->numFPRs(); i++) {
915       registerSlot *reg = theRegSpace->FPRs()[i];
916       if (reg->liveState == registerSlot::spilled) {
917           restoreFPRegister(gen, reg->encoding(), save_off);
918           numRegs++;
919       }
920   }
921   
922   return numRegs;
923 }
924
925 /*
926  * Save the special purpose registers (for Dyninst conservative tramp)
927  * CTR, CR, XER, SPR0, FPSCR
928  */
929 unsigned saveSPRegisters(codeGen &gen,
930                          registerSpace *,
931                          int save_off,
932                          int force_save)
933 {
934     unsigned num_saved = 0;
935     int cr_off, ctr_off, xer_off, spr0_off, fpscr_off;
936     
937     if (gen.width() == 4) {
938         cr_off    = STK_CR_32;
939         ctr_off   = STK_CTR_32;
940         xer_off   = STK_XER_32;
941         fpscr_off = STK_FP_CR_32;
942         spr0_off  = STK_SPR0_32;
943     } else /* gen.width() == 8 */ {
944         cr_off    = STK_CR_64;
945         ctr_off   = STK_CTR_64;
946         xer_off   = STK_XER_64;
947         fpscr_off = STK_FP_CR_64;
948         spr0_off  = STK_SPR0_64;
949     }
950
951     registerSlot *regCR = (*(gen.rs()))[registerSpace::cr]; 
952     assert (regCR != NULL); 
953     if (force_save || regCR->liveState == registerSlot::live) 
954     {
955     saveCR(gen, 10, save_off + cr_off); num_saved++;
956     gen.rs()->markSavedRegister(registerSpace::cr, save_off + cr_off);
957     }
958     registerSlot *regCTR = (*(gen.rs()))[registerSpace::ctr]; 
959     assert (regCTR != NULL); 
960     if (force_save || regCTR->liveState == registerSlot::live) 
961     {
962     saveSPR(gen, 10, SPR_CTR, save_off + ctr_off); num_saved++;
963     gen.rs()->markSavedRegister(registerSpace::ctr, save_off + ctr_off);
964     }
965
966     registerSlot *regXER = (*(gen.rs()))[registerSpace::xer]; 
967     assert (regXER != NULL); 
968     if (force_save || regXER->liveState == registerSlot::live) 
969    {
970     saveSPR(gen, 10, SPR_XER, save_off + xer_off); num_saved++;
971     gen.rs()->markSavedRegister(registerSpace::xer, save_off + xer_off);
972     }
973
974     saveFPSCR(gen, 10, save_off + fpscr_off); num_saved++;
975
976     return num_saved;
977 }
978
979 /*
980  * Restore the special purpose registers (for Dyninst conservative tramp)
981  * CTR, CR, XER, SPR0, FPSCR
982  */
983
984 unsigned restoreSPRegisters(codeGen &gen,
985                             registerSpace *,
986                             int save_off,
987                             int force_save)
988 {
989     int cr_off, ctr_off, xer_off, spr0_off, fpscr_off;
990     unsigned num_restored = 0;
991
992     if (gen.width() == 4) {
993         cr_off    = STK_CR_32;
994         ctr_off   = STK_CTR_32;
995         xer_off   = STK_XER_32;
996         fpscr_off = STK_FP_CR_32;
997         spr0_off  = STK_SPR0_32;
998     } else /* gen.width() == 8 */ {
999         cr_off    = STK_CR_64;
1000         ctr_off   = STK_CTR_64;
1001         xer_off   = STK_XER_64;
1002         fpscr_off = STK_FP_CR_64;
1003         spr0_off  = STK_SPR0_64;
1004     }
1005
1006     registerSlot *regCR = (*(gen.rs()))[registerSpace::cr]; 
1007     assert (regCR != NULL); 
1008     if (force_save || regCR->liveState == registerSlot::spilled) 
1009     {
1010     restoreCR(gen, 10, save_off + cr_off); num_restored++;
1011     }
1012     registerSlot *regCTR = (*(gen.rs()))[registerSpace::ctr]; 
1013     assert (regCTR != NULL); 
1014     if (force_save || regCTR->liveState == registerSlot::spilled) 
1015     {
1016     restoreSPR(gen, 10, SPR_CTR, save_off + ctr_off); num_restored++;
1017     }
1018     registerSlot *regXER = (*(gen.rs()))[registerSpace::xer]; 
1019     assert (regXER != NULL); 
1020     if (force_save || regXER->liveState == registerSlot::spilled) 
1021     {
1022     restoreSPR(gen, 10, SPR_XER, save_off + xer_off); num_restored++;
1023     }
1024     restoreFPSCR(gen, 10, save_off + fpscr_off); num_restored++;
1025
1026     return num_restored;
1027 }
1028
1029
1030 bool baseTramp::generateSaves(codeGen &gen,
1031                               registerSpace *)
1032 {
1033     regalloc_printf("========== baseTramp::generateSaves\n");
1034     unsigned int width = gen.width();
1035
1036     int gpr_off, fpr_off;
1037     gpr_off = TRAMP_GPR_OFFSET(width);
1038     fpr_off = TRAMP_FPR_OFFSET(width);
1039
1040     // Make a stack frame.
1041     pushStack(gen);
1042
1043     // Save GPRs
1044     saveGPRegisters(gen, gen.rs(), gpr_off);
1045
1046     if(BPatch::bpatch->isSaveFPROn() ||  // Save FPRs
1047         BPatch::bpatch->isForceSaveFPROn() ) 
1048         saveFPRegisters(gen, gen.rs(), fpr_off);
1049
1050     // Save LR            
1051     saveLR(gen, REG_SCRATCH /* register to use */, TRAMP_SPR_OFFSET(width) + STK_LR);
1052
1053     saveSPRegisters(gen, gen.rs(), TRAMP_SPR_OFFSET(width), true); // FIXME get liveness fixed
1054     return true;
1055 }
1056
1057 bool baseTramp::generateRestores(codeGen &gen,
1058                                  registerSpace *)
1059 {
1060     unsigned int width = gen.width();
1061
1062     regalloc_printf("========== baseTramp::generateRestores\n");
1063
1064     int gpr_off, fpr_off;
1065     gpr_off = TRAMP_GPR_OFFSET(width);
1066     fpr_off = TRAMP_FPR_OFFSET(width);
1067
1068     // Restore possible SPR saves
1069     restoreSPRegisters(gen, gen.rs(), TRAMP_SPR_OFFSET(width), false);
1070
1071     // LR
1072     restoreLR(gen, REG_SCRATCH, TRAMP_SPR_OFFSET(width) + STK_LR);
1073
1074     if (BPatch::bpatch->isSaveFPROn() || // FPRs
1075         BPatch::bpatch->isForceSaveFPROn() ) 
1076         restoreFPRegisters(gen, gen.rs(), fpr_off);
1077
1078     // GPRs
1079     restoreGPRegisters(gen, gen.rs(), gpr_off);
1080
1081     /*
1082     // Multithread GPR -- always save
1083     restoreRegister(gen, REG_MT_POS, TRAMP_GPR_OFFSET);
1084     */
1085
1086     popStack(gen);
1087
1088     return true;
1089 }
1090
1091
1092 void emitImm(opCode op, Register src1, RegValue src2imm, Register dest, 
1093              codeGen &gen, bool noCost, registerSpace * /* rs */)
1094 {
1095         //bperr("emitImm(op=%d,src=%d,src2imm=%d,dest=%d)\n",
1096         //        op, src1, src2imm, dest);
1097     int iop=-1;
1098     int result=-1;
1099     switch (op) {
1100         // integer ops
1101     case plusOp:
1102         iop = CALop;
1103         insnCodeGen::generateImm(gen, iop, dest, src1, src2imm);
1104         return;
1105         break;
1106         
1107     case minusOp:
1108         iop = SIop;
1109         insnCodeGen::generateImm(gen, iop, dest, src1, src2imm);
1110         return;
1111         break;
1112         
1113     case timesOp:
1114        if (isPowerOf2(src2imm,result) && (result < (int) (gen.width() * 8))) {
1115             insnCodeGen::generateLShift(gen, src1, result, dest);
1116             return;
1117         }
1118         else {
1119             Register dest2 = gen.rs()->getScratchRegister(gen, noCost);
1120             emitVload(loadConstOp, src2imm, dest2, dest2, gen, noCost);
1121             emitV(op, src1, dest2, dest, gen, noCost);
1122             return;
1123         }
1124         break;
1125         
1126     case divOp:
1127         if (isPowerOf2(src2imm,result) && (result < (int) (gen.width() * 8))) {
1128             insnCodeGen::generateRShift(gen, src1, result, dest);
1129             return;
1130         }
1131         else {
1132             Register dest2 = gen.rs()->getScratchRegister(gen, noCost);
1133             emitVload(loadConstOp, src2imm, dest2, dest2, gen, noCost);
1134             emitV(op, src1, dest2, dest, gen, noCost);
1135             return;
1136         }
1137         break;
1138         
1139         // Bool ops
1140     case orOp:
1141         iop = ORILop;
1142         // For some reason, the destField is 2nd for ORILop and ANDILop
1143         insnCodeGen::generateImm(gen, iop, src1, dest, src2imm);
1144         return;
1145         break;
1146         
1147     case andOp:
1148         iop = ANDILop;
1149         // For some reason, the destField is 2nd for ORILop and ANDILop
1150         insnCodeGen::generateImm(gen, iop, src1, dest, src2imm);
1151         return;
1152         break;
1153     default:
1154         Register dest2 = gen.rs()->getScratchRegister(gen, noCost);
1155         emitVload(loadConstOp, src2imm, dest2, dest2, gen, noCost);
1156         emitV(op, src1, dest2, dest, gen, noCost);
1157         return;
1158         break;
1159     }
1160 }
1161
1162 void cleanUpAndExit(int status);
1163
1164 /* Recursive function that goes to where our instrumentation is calling
1165 to figure out what registers are clobbered there, and in any function
1166 that it calls, to a certain depth ... at which point we clobber everything
1167
1168 Update-12/06, njr, since we're going to a cached system we are just going to 
1169 look at the first level and not do recursive, since we would have to also
1170 store and reexamine every call out instead of doing it on the fly like before*/
1171 bool EmitterPOWER::clobberAllFuncCall( registerSpace *rs,
1172                                        func_instance * callee)
1173                    
1174 {
1175   unsigned i;
1176   if (!callee) return true;
1177
1178   stats_codegen.startTimer(CODEGEN_LIVENESS_TIMER);
1179     
1180   /* usedRegs does calculations if not done before and returns
1181      whether or not the callee is a leaf function.
1182      if it is, we use the register info we gathered,
1183      otherwise, we punt and save everything */
1184   //     bool isLeafFunc = callee->ifunc()->usedRegs();
1185
1186   if (callee->ifunc()->isLeafFunc()) {
1187       std::set<Register> * gprs = callee->ifunc()->usedGPRs();
1188       std::set<Register>::iterator It = gprs->begin();
1189       for(i = 0; i < gprs->size(); i++) {
1190           //while (It != gprs->end()){
1191           rs->GPRs()[*(It++)]->beenUsed = true;
1192       }
1193       
1194       std::set<Register> * fprs = callee->ifunc()->usedFPRs();
1195       std::set<Register>::iterator It2 = fprs->begin();
1196       for(i = 0; i < fprs->size(); i++)
1197       {
1198           //while (It2 != fprs->end()){
1199           rs->FPRs()[*(It2++)]->beenUsed = true;
1200       }
1201     }
1202   else {
1203       for (int i = 0; i < rs->numGPRs(); i++) {
1204           rs->GPRs()[i]->beenUsed = true;
1205       }
1206       for (int i = 0; i < rs->numFPRs(); i++) {
1207           rs->FPRs()[i]->beenUsed = true;
1208       }
1209   }
1210   stats_codegen.stopTimer(CODEGEN_LIVENESS_TIMER);
1211   return false;
1212 }
1213
1214
1215 //
1216 // Author: Jeff Hollingsworth (3/26/96)
1217 //
1218 // Emit a function call.
1219 //   It saves registers as needed.
1220 //   copy the passed arguments into the canonical argument registers (r3-r10)
1221 //   64-bit ELF Linux ONLY: 
1222 //     Locate the TOC entry of the callee module and copy it into R2
1223 //   generate a branch and link the destination
1224 //   64-bit ELF Linux ONLY:
1225 //     Restore the original TOC into R2
1226 //   restore the saved registers.
1227 //
1228 // Parameters:
1229 //   op - unused parameter (to be compatible with sparc)
1230 //   srcs - vector of ints indicating the registers that contain the parameters
1231 //   dest - the destination address (should be Address not reg). 
1232 //   insn - pointer to the code we are generating
1233 //   based - offset into the code generated.
1234 //
1235
1236 Register emitFuncCall(opCode, codeGen &, pdvector<AstNodePtr> &, bool, Address) {
1237         assert(0);
1238         return 0;
1239 }
1240
1241 Register emitFuncCall(opCode op,
1242                       codeGen &gen,
1243                       pdvector<AstNodePtr> &operands, bool noCost,
1244                       func_instance *callee) {
1245     return gen.emitter()->emitCall(op, gen, operands, noCost, callee);
1246 }
1247
1248 Register EmitterPOWER::emitCallReplacement(opCode ocode,
1249                                            codeGen &gen,
1250                                            bool /* noCost */,
1251                                            func_instance *callee) {
1252     // This takes care of the special case where we are replacing an existing
1253     // linking branch instruction.
1254     //
1255     // This code makes two crucial assumptions:
1256     // 1) LR is free: Linking branch instructions place pre-branch IP in LR.
1257     // 2) TOC (r2) is free: r2 should hold TOC of destination.  So use it
1258     //    as scratch, and set it to destination module's TOC upon return.
1259     //    This works for both the inter and intra module call cases.
1260     // In the 32-bit case where we can't use r2, stomp on r0 and pray...
1261
1262     //  Sanity check for opcode.
1263     assert(ocode == funcJumpOp);
1264
1265     Register freeReg = 0;
1266     instruction mtlr(MTLR0raw);
1267
1268     // 64-bit Mutatees
1269     if (gen.addrSpace()->proc()->getAddressWidth() == 8) {
1270         freeReg = 2;
1271         mtlr = instruction(MTLR2raw);
1272     }
1273
1274     // Load register with address.
1275     emitVload(loadConstOp, callee->addr(), freeReg, freeReg, gen, false);
1276
1277     // Move to link register.
1278     insnCodeGen::generate(gen,mtlr);
1279
1280     Address toc_new = gen.addrSpace()->proc()->getTOCoffsetInfo(callee);
1281     if (toc_new) {
1282         // Set up the new TOC value
1283         emitVload(loadConstOp, toc_new, freeReg, freeReg, gen, false);
1284     }
1285
1286     // blr - branch through the link reg.
1287     instruction blr(BRraw);
1288     insnCodeGen::generate(gen,blr);
1289
1290     func_instance *caller = gen.point()->func();
1291     Address toc_orig = gen.addrSpace()->proc()->getTOCoffsetInfo(caller);
1292     if (toc_new) {
1293         // Restore the original TOC value.
1294         emitVload(loadConstOp, toc_orig, freeReg, freeReg, gen, false);
1295     }
1296
1297     // What to return here?
1298     return REG_NULL;
1299 }
1300
1301 // There are four "axes" going on here:
1302 // 32 bit vs 64 bit  
1303 // Instrumentation vs function call replacement
1304 // Static vs. dynamic 
1305
1306 Register EmitterPOWER::emitCall(opCode ocode,
1307                                 codeGen &gen,
1308                                 const pdvector<AstNodePtr> &operands,
1309                                 bool noCost,
1310                                 func_instance *callee) {
1311     bool inInstrumentation = true;
1312
1313     // If inInstrumentation is true we're in instrumentation;
1314     // if false we're in function call replacement
1315     if (ocode == funcJumpOp)
1316         return emitCallReplacement(ocode, gen, noCost, callee);
1317
1318     //  Sanity check for NULL address argument
1319     if (!callee) {
1320         char msg[256];
1321         sprintf(msg, "%s[%d]:  internal error:  emitFuncCall called w/out"
1322                 "callee argument", __FILE__, __LINE__);
1323         showErrorCallback(80, msg);
1324         assert(0);
1325     }
1326
1327     // Now that we have the destination address (unique, hopefully) 
1328     // get the TOC anchor value for that function
1329     // The TOC offset is stored in the Object. 
1330     // file() -> pdmodule "parent"
1331     // exec() -> image "parent"
1332  
1333     Address toc_anchor = 0;
1334     Address caller_toc = 0;
1335     pdvector <Register> srcs;
1336
1337     // Linux, 64, static/dynamic, inst/repl
1338     // DYN
1339     toc_anchor = gen.addrSpace()->getTOCoffsetInfo(callee);
1340     
1341     // Instead of saving the TOC (if we can't), just reset it afterwards.
1342     if (gen.func()) {
1343       caller_toc = gen.addrSpace()->getTOCoffsetInfo(gen.func());
1344     }
1345     else if (gen.point()) {
1346       caller_toc = gen.addrSpace()->getTOCoffsetInfo(gen.point()->func());
1347     }
1348     else {
1349       // Don't need it, and this might be an iRPC
1350     }
1351     
1352     inst_printf("Caller TOC 0x%lx; callee 0x%lx\n",
1353                 caller_toc, toc_anchor);
1354     // ALL
1355     bool needToSaveLR = false;
1356     registerSlot *regLR = (*(gen.rs()))[registerSpace::lr];
1357     if (regLR && regLR->liveState == registerSlot::live) {
1358         needToSaveLR = true;
1359         inst_printf("... need to save LR\n");
1360     }
1361
1362     // Note: For 32-bit ELF PowerPC Linux (and other SYSV ABI followers)
1363     // r2 is described as "reserved for system use and is not to be 
1364     // changed by application code".
1365     // On these platforms, we return 0 when getTOCoffsetInfo is called.
1366
1367     pdvector<int> savedRegs;
1368
1369     //  Save the link register.
1370     // mflr r0
1371     // Linux, 32/64, stat/dynamic, instrumentation
1372     if (needToSaveLR) {
1373         assert(inInstrumentation);
1374         insnCodeGen::generateMoveFromLR(gen, 0);
1375         saveRegister(gen, 0, FUNC_CALL_SAVE(gen.width()));
1376         savedRegs.push_back(0);
1377         inst_printf("saved LR in 0\n");
1378     }
1379
1380     if (inInstrumentation &&
1381         (toc_anchor != caller_toc)) {
1382         // Save register 2 (TOC)
1383       saveRegister(gen, 2, FUNC_CALL_SAVE(gen.width()));
1384         savedRegs.push_back(2);
1385     }
1386
1387     // see what others we need to save.
1388     for (int i = 0; i < gen.rs()->numGPRs(); i++) {
1389        registerSlot *reg = gen.rs()->GPRs()[i];
1390
1391        // We must save if:
1392        // refCount > 0 (and not a source register)
1393        // keptValue == true (keep over the call)
1394        // liveState == live (technically, only if not saved by the callee) 
1395        
1396        if (inInstrumentation &&
1397            ((reg->refCount > 0) || 
1398             reg->keptValue ||
1399             (reg->liveState == registerSlot::live))) {
1400          saveRegister(gen, reg->number, FUNC_CALL_SAVE(gen.width()));
1401           savedRegs.push_back(reg->number);
1402        }
1403     }
1404
1405     // Generate the code for all function parameters, and keep a list
1406     // of what registers they're in.
1407     for (unsigned u = 0; u < operands.size(); u++) {
1408     // Note: if we're in function replacement, we can assert operands.empty()
1409 /*
1410         if (operands[u]->getSize() == 8) {
1411             // What does this do?
1412             bperr( "in weird code\n");
1413             Register dummyReg = gen.rs()->allocateRegister(gen, noCost);
1414             srcs.push_back(dummyReg);
1415
1416             insnCodeGen::generateImm(gen, CALop, dummyReg, 0, 0);
1417         }
1418 */
1419         //Register src = REG_NULL;
1420         // Try to target the code generation
1421         
1422         Register reg = REG_NULL;
1423         // Try to allocate the correct parameter register
1424         if (gen.rs()->allocateSpecificRegister(gen, registerSpace::r3 + u, true))
1425             reg = registerSpace::r3 + u;
1426
1427         Address unused = ADDR_NULL;
1428         if (!operands[u]->generateCode_phase2( gen, false, unused, reg)) assert(0);
1429         assert(reg != REG_NULL);
1430         srcs.push_back(reg);
1431         //bperr( "Generated operand %d, base %d\n", u, base);
1432     }
1433   
1434     if(srcs.size() > 8) {
1435         // This is not necessarily true; more then 8 arguments could be passed,
1436         // the first 8 need to be in registers while the others need to be on
1437         // the stack, -- sec 3/1/97
1438        std::string msg = "Too many arguments to function call in instrumentation code:"
1439             " only 8 arguments can (currently) be passed on the POWER architecture.\n";
1440         bperr( msg.c_str());
1441         showErrorCallback(94,msg);
1442         cleanUpAndExit(-1);
1443     }
1444
1445     // If we got the wrong register, we may need to do a 3-way swap. 
1446
1447     int scratchRegs[8];
1448     for (int a = 0; a < 8; a++) {
1449         scratchRegs[a] = -1;
1450     }
1451
1452     // Now load the parameters into registers.
1453     for (unsigned u=0; u<srcs.size(); u++){
1454
1455         // Parameters start at register 3 - so we're already done
1456         // in this case
1457         if (srcs[u] == (registerSpace::r3+u)) {
1458             gen.rs()->freeRegister(srcs[u]);
1459             continue;
1460         }
1461
1462         int whichSource = -1;
1463         bool hasSourceBeenCopied = true;
1464         
1465
1466         // If the parameter we want exists in a scratch register...
1467         if (scratchRegs[u] != -1) {
1468             insnCodeGen::generateImm(gen, ORILop, scratchRegs[u], u+3, 0);
1469             gen.rs()->freeRegister(scratchRegs[u]);
1470             // We should check to make sure the one we want isn't occupied?
1471         } else {
1472             for (unsigned v=u; v < srcs.size(); v++) {
1473                 if (srcs[v] == u+3) {
1474                     // Okay, so the source we want is actuall in srcs[v]
1475                     hasSourceBeenCopied = false;
1476                     whichSource = v;
1477                     break;
1478                 }
1479             }
1480             // Ummm... we didn't find it? Ah, so copying us (since we're wrong)
1481             // into scratch.
1482             if (!hasSourceBeenCopied) {
1483                 Register scratch = gen.rs()->getScratchRegister(gen);
1484                 insnCodeGen::generateImm(gen, ORILop, u+3, scratch, 0);
1485                 gen.rs()->freeRegister(u+3);
1486                 scratchRegs[whichSource] = scratch;
1487                 hasSourceBeenCopied = true;
1488
1489                 insnCodeGen::generateImm(gen, ORILop, srcs[u], u+3, 0);
1490                 gen.rs()->freeRegister(srcs[u]);
1491
1492             } else {
1493                 insnCodeGen::generateImm(gen, ORILop, srcs[u], u+3, 0);
1494                 gen.rs()->freeRegister(srcs[u]);
1495                 // Not sure why this was needed
1496                 //gen.rs()->clobberRegister(u+3);
1497             }
1498         } 
1499     }
1500
1501     // Call generation time.
1502     bool setTOC = false;
1503
1504         // Linux, 64, stat/dyn, inst/repl
1505     if (toc_anchor != caller_toc) {
1506         setTOC = true;
1507     }
1508     
1509     emitCallInstruction(gen, callee, setTOC, toc_anchor);
1510     
1511     // ALL instrumentation
1512     Register retReg = REG_NULL;
1513     if (inInstrumentation) {
1514         // get a register to keep the return value in.
1515         retReg = gen.rs()->allocateRegister(gen, noCost);        
1516         // put the return value from register 3 to the newly allocated register.
1517         insnCodeGen::generateImm(gen, ORILop, 3, retReg, 0);
1518     }
1519
1520         
1521     // Otherwise we're replacing a call and so we don't want to move
1522     // anything. 
1523
1524     // restore saved registers.
1525     // If inInstrumentation == false then this vector should be empty...
1526         // ALL instrumentation
1527  
1528     if (!inInstrumentation) assert(savedRegs.size() == 0);
1529     for (u_int ui = 0; ui < savedRegs.size(); ui++) {
1530       restoreRegister(gen, savedRegs[ui], FUNC_CALL_SAVE(gen.width()));
1531     }
1532   
1533     // mtlr     0 (aka mtspr 8, rs) = 0x7c0803a6
1534     // Move to link register
1535     // Reused from above. instruction mtlr0(MTLR0raw);
1536     if (needToSaveLR) {
1537         // We only use register 0 to save LR. 
1538         insnCodeGen::generateMoveToLR(gen, 0);
1539     }
1540     
1541     if (!inInstrumentation && setTOC) {
1542         // Need to reset the TOC
1543         emitVload(loadConstOp, caller_toc, 2, 2, gen, false);
1544
1545         // Also store toc_orig [r2] into the TOC save area [40(r1)].
1546         // Subsequent code will look for it there.
1547         saveRegisterAtOffset(gen, 2, 40);
1548     }        
1549
1550     /*
1551       gen = (instruction *) gen;
1552       for (unsigned foo = initBase/4; foo < base/4; foo++)
1553       bperr( "0x%x,\n", gen[foo].raw);
1554     */ 
1555     // return value is the register with the return value from the called function
1556     return(retReg);
1557 }
1558
1559  
1560 codeBufIndex_t emitA(opCode op, Register src1, Register /*src2*/, long dest,
1561               codeGen &gen, RegControl, bool /*noCost*/)
1562 {
1563     //bperr("emitA(op=%d,src1=%d,src2=XX,dest=%d)\n",op,src1,dest);
1564     codeBufIndex_t retval = 0;
1565     switch (op) {
1566       case ifOp: {
1567         // cmpi 0,0,src1,0
1568           instruction insn;
1569           insn.clear();
1570           DFORM_OP_SET(insn, CMPIop);
1571           DFORM_RA_SET(insn, src1);
1572           DFORM_SI_SET(insn, 0);
1573           insnCodeGen::generate(gen,insn);
1574           retval = gen.getIndex();
1575           
1576           // be 0, dest
1577           insn.clear();
1578           BFORM_OP_SET(insn, BCop);
1579           BFORM_BO_SET(insn, BTRUEcond);
1580           BFORM_BI_SET(insn, EQcond);
1581           BFORM_BD_SET(insn, dest/4);
1582           BFORM_AA_SET(insn, 0);
1583           BFORM_LK_SET(insn, 0);
1584           
1585           insnCodeGen::generate(gen,insn);
1586           break;
1587       }
1588     case branchOp: {
1589         retval = gen.getIndex();
1590         insnCodeGen::generateBranch(gen, dest);
1591         break;
1592     }
1593     case trampPreamble: {
1594         // nothing to do in this platform
1595         return(0);              // let's hope this is expected!
1596     }        
1597     default:
1598         assert(0);        // unexpected op for this emit!
1599     }
1600     return retval;
1601 }
1602
1603 Register emitR(opCode op, Register src1, Register src2, Register dest,
1604                codeGen &gen, bool /*noCost*/,
1605                const instPoint * /*location*/, bool /*for_MT*/)
1606 {
1607     //bperr("emitR(op=%d,src1=%d,src2=XX,dest=%d)\n",op,src1,dest);
1608
1609     registerSlot *regSlot = NULL;
1610     unsigned addrWidth = gen.width();
1611
1612     switch (op) {
1613     case getRetValOp: {
1614         regSlot = (*(gen.rs()))[registerSpace::r3];
1615         break;
1616     }
1617
1618     case getParamOp: {
1619         // The first 8 parameters (0-7) are stored in registers (r3-r10) upon
1620         // entering the function and then saved above the stack upon entering
1621         // the trampoline; in emit functional call the stack pointer is moved
1622         // so the saved registers are not over-written the other parameters >
1623         // 8 are stored on the caller's stack at an offset.
1624         // 
1625         // src1 is the argument number 0..X, the first 8 are stored in regs
1626         // src2 (if not REG_NULL) holds the value to be written into src1
1627
1628         if(src1 < 8) {
1629             // src1 is 0..8 - it's a parameter number, not a register
1630             regSlot = (*(gen.rs()))[registerSpace::r3 + src1];
1631             break;
1632
1633         } else {
1634             // Registers from 11 (src = 8) and beyond are saved on the stack.
1635             // On AIX this is +56 bytes; for ELF it's something different.
1636
1637             int stkOffset;
1638             if (addrWidth == 4) {
1639                 stkOffset = TRAMP_FRAME_SIZE_32 +
1640                             (src1 - 8) * sizeof(int) +
1641                             PARAM_OFFSET(addrWidth);
1642             } else {
1643               // Linux ABI says:
1644               // Parameters go in the "argument save area", which starts at
1645               // PARAM_OFFSET(...). However, we'd save argument _0_ at the base
1646               // of it, so the first 8 slots are normally empty (as they go in
1647               // registers). To get the 9th, etc. argument you want
1648               // PARAM_OFFSET(...) + (8 * arg number) instead of
1649               // 8 * (arg_number - 8)
1650               int stackSlot = src1;
1651               stkOffset = TRAMP_FRAME_SIZE_64 +
1652                             stackSlot * sizeof(long) +
1653                             PARAM_OFFSET(addrWidth);
1654             }
1655
1656             if (src2 != REG_NULL) saveRegisterAtOffset(gen, src2, stkOffset);
1657             restoreRegisterAtOffset(gen, dest, stkOffset);
1658             return(dest);
1659       }
1660       break;
1661     }
1662
1663     case getRetAddrOp: {
1664       regSlot = (*(gen.rs()))[registerSpace::lr];
1665       break;
1666     }
1667
1668     default:
1669         assert(0);
1670         break;
1671     }
1672
1673     assert(regSlot);
1674     Register reg = regSlot->number;
1675
1676     switch(regSlot->liveState) {
1677     case registerSlot::spilled: {
1678       int offset = TRAMP_GPR_OFFSET(addrWidth);
1679       
1680       // its on the stack so load it.
1681       if (src2 != REG_NULL) saveRegister(gen, src2, reg, offset);
1682       restoreRegister(gen, reg, dest, offset);
1683       return(dest);
1684     }
1685     case registerSlot::live: {
1686         // its still in a register so return the register it is in.
1687         
1688         return(reg);
1689     }
1690     case registerSlot::dead: {
1691         // Uhhh... wha?
1692         assert(0);
1693     }
1694     }
1695
1696     assert(0);
1697     return REG_NULL;
1698 }
1699
1700 void emitJmpMC(int /*condition*/, int /*offset*/, codeGen &)
1701 {
1702   // Not needed for memory instrumentation, otherwise TBD
1703 }
1704
1705
1706 // VG(11/16/01): Say if we have to restore a register to get its original value
1707 // VG(03/15/02): Sync'd with the new AIX tramp
1708 static inline bool needsRestore(Register x)
1709 {
1710   //return (x == 0) || ((x >= 3) && (x <= 12)) || (x == POWER_XER2531);
1711   return ((x <= 12) && !(x==2)) || (x == POWER_XER2531);
1712 }
1713
1714 // VG(03/15/02): Restore mutatee value of GPR reg to dest GPR
1715 static inline void restoreGPRtoGPR(codeGen &gen,
1716                                    Register reg, Register dest)
1717 {
1718     int frame_size, gpr_size, gpr_off;
1719     if (gen.width() == 4) {
1720         frame_size = TRAMP_FRAME_SIZE_32;
1721         gpr_size   = GPRSIZE_32;
1722         gpr_off    = TRAMP_GPR_OFFSET_32;
1723     } else /* gen.width() == 8 */ {
1724         frame_size = TRAMP_FRAME_SIZE_64;
1725         gpr_size   = GPRSIZE_64;
1726         gpr_off    = TRAMP_GPR_OFFSET_64;
1727     }
1728
1729     if (reg == 1) // SP is in a different place, but we don't need to
1730                   // restore it, just subtract the stack frame size
1731         insnCodeGen::generateImm(gen, CALop, dest, REG_SP, frame_size);
1732
1733     else if((reg == 0) || ((reg >= 3) && (reg <=12)))
1734         insnCodeGen::generateImm(gen, Lop, dest, REG_SP,
1735                                  gpr_off + reg*gpr_size);
1736     else {
1737         bperr( "GPR %d should not be restored...", reg);
1738         assert(0);
1739     }
1740     //bperr( "Loading reg %d (into reg %d) at 0x%x off the stack\n", 
1741     //  reg, dest, offset + reg*GPRSIZE);
1742 }
1743
1744 // VG(03/15/02): Restore mutatee value of XER to dest GPR
1745 static inline void restoreXERtoGPR(codeGen &gen, Register dest)
1746 {
1747     if (gen.width() == 4) {
1748         insnCodeGen::generateImm(gen, Lop, dest, REG_SP,
1749                                  TRAMP_SPR_OFFSET(4) + STK_XER_32);
1750     } else /* gen.width() == 8 */ {
1751         insnCodeGen::generateMemAccess64(gen, LDop, LDxop, dest, REG_SP,
1752                                          TRAMP_SPR_OFFSET(8) + STK_XER_64);
1753     }
1754 }
1755
1756 // VG(03/15/02): Move bits 25:31 of GPR reg to GPR dest
1757 static inline void moveGPR2531toGPR(codeGen &gen,
1758                                     Register reg, Register dest)
1759 {
1760   // keep only bits 32+25:32+31; extrdi dest, reg, 7 (n bits), 32+25 (start at b)
1761   // which is actually: rldicl dest, reg, 32+25+7 (b+n), 64-7 (64-n)
1762   // which is the same as: clrldi dest,reg,57 because 32+25+7 = 64
1763     instruction rld;
1764     rld.clear();
1765     MDFORM_OP_SET( rld, RLDop);
1766     MDFORM_RS_SET( rld, reg);
1767     MDFORM_RA_SET( rld, dest);
1768     MDFORM_SH_SET( rld, 0);  //(32+25+7) % 32;
1769     MDFORM_MB_SET( rld, (64-7) % 32);
1770     MDFORM_MB2_SET(rld, (64-7) / 32);
1771     MDFORM_XO_SET( rld, ICLxop);
1772     MDFORM_SH2_SET(rld, 0); //(32+25+7) / 32;
1773     MDFORM_RC_SET( rld, 0);
1774     insnCodeGen::generate(gen,rld);
1775 }
1776
1777 // VG(11/16/01): Emit code to add the original value of a register to
1778 // another. The original value may need to be restored from stack...
1779 // VG(03/15/02): Made functionality more obvious by adding the above functions
1780 static inline void emitAddOriginal(Register src, Register acc, 
1781                                    codeGen &gen, bool noCost)
1782 {
1783     bool nr = needsRestore(src);
1784     Register temp;
1785     
1786     if(nr) {
1787         // this needs gen because it uses emitV...
1788         temp = gen.rs()->allocateRegister(gen, noCost);
1789         
1790         // Emit code to restore the original ra register value in temp.
1791         // The offset compensates for the gap 0, 3, 4, ...
1792         // This writes at insn, and updates insn and base.
1793         
1794         if(src == POWER_XER2531) { // hack for XER_25:31
1795             //bperr( "XER_25:31\n");
1796             restoreXERtoGPR(gen, temp);
1797             moveGPR2531toGPR(gen, temp, temp);
1798         }
1799         else
1800             restoreGPRtoGPR(gen, src, temp);
1801     }
1802     else
1803         temp = src;
1804     
1805     // add temp to dest;
1806     // writes at gen+base and updates base, we must update insn...
1807     emitV(plusOp, temp, acc, acc, gen, noCost, 0);
1808     
1809     if(nr)
1810         gen.rs()->freeRegister(temp);
1811 }
1812
1813 // VG(11/07/01): Load in destination the effective address given
1814 // by the address descriptor. Used for memory access stuff.
1815 void emitASload(const BPatch_addrSpec_NP *as, Register dest, int stackShift,
1816                 codeGen &gen,
1817                 bool noCost)
1818 {
1819   // Haven't implemented non-zero shifts yet
1820   assert(stackShift == 0);
1821   //instruction *insn = (instruction *) ((void*)&gen[base]);
1822   int imm = as->getImm();
1823   int ra  = as->getReg(0);
1824   int rb  = as->getReg(1);
1825   // TODO: optimize this to generate the minimum number of
1826   // instructions; think about schedule
1827
1828   // emit code to load the immediate (constant offset) into dest; this
1829   // writes at gen+base and updates base, we must update insn...
1830   emitVload(loadConstOp, (Address)imm, dest, dest, gen, noCost);
1831   
1832   // If ra is used in the address spec, allocate a temp register and
1833   // get the value of ra from stack into it
1834   if(ra > -1)
1835       emitAddOriginal(ra, dest, gen, noCost);
1836
1837   // If rb is used in the address spec, allocate a temp register and
1838   // get the value of ra from stack into it
1839   if(rb > -1)
1840     emitAddOriginal(rb, dest, gen, noCost);
1841
1842 }
1843
1844 void emitCSload(const BPatch_addrSpec_NP *as, Register dest, codeGen &gen,               
1845                 bool noCost)
1846 {
1847   emitASload(as, dest, 0, gen, noCost);
1848 }
1849
1850 void emitVload(opCode op, Address src1, Register src2, Register dest,
1851                codeGen &gen, bool /*noCost*/, 
1852                registerSpace * /*rs*/, int size,
1853                const instPoint * /* location */, AddressSpace *proc)
1854 {
1855   switch(op) {
1856   case loadConstOp:
1857     insnCodeGen::loadImmIntoReg(gen, dest, (long)src1);
1858     break;
1859   case loadOp:
1860     insnCodeGen::loadPartialImmIntoReg(gen, dest, (long)src1);
1861     
1862     // really load dest, (dest)imm
1863     if (size == 1) {
1864       insnCodeGen::generateImm(gen, LBZop, dest, dest, LOW(src1));
1865     }
1866     else if (size == 2) {
1867       insnCodeGen::generateImm(gen, LHZop, dest, dest, LOW(src1));
1868     }
1869     else if ((size == 4) ||
1870              (size == 8 && proc->getAddressWidth() == 4)) // Override bogus size
1871       insnCodeGen::generateImm(gen, Lop,   dest, dest, LOW(src1));
1872     else if (size == 8)
1873       insnCodeGen::generateMemAccess64(gen, LDop, LDxop,
1874                                        dest, dest, (int16_t)LOW(src1));
1875     else assert(0 && "Incompatible loadOp size");
1876     break;
1877   case loadFrameRelativeOp: {
1878         long offset = (long)src1;
1879         if (gen.width() == 4)
1880             offset += TRAMP_FRAME_SIZE_32;
1881         else /* gen.width() == 8 */
1882             offset += TRAMP_FRAME_SIZE_64;
1883
1884         // return the value that is FP offset from the original fp
1885         if (size == 1)
1886             insnCodeGen::generateImm(gen, LBZop, dest, REG_SP, offset);
1887         else if (size == 2)
1888             insnCodeGen::generateImm(gen, LHZop, dest, REG_SP, offset);
1889         else if ((size == 4) ||
1890                  (size == 8 && proc->getAddressWidth() == 4)) // Override bogus size
1891             insnCodeGen::generateImm(gen, Lop,   dest, REG_SP, offset);
1892         else if (size == 8)
1893             insnCodeGen::generateMemAccess64(gen, LDop, LDxop,
1894                                              dest, REG_SP, offset);
1895         else assert(0 && "Incompatible loadFrameRelativeOp size");
1896   }
1897     break;
1898   case loadFrameAddr: {
1899     // offsets are signed!
1900     long offset = (long)src1;
1901     offset += (gen.width() == 4 ? TRAMP_FRAME_SIZE_32
1902                : TRAMP_FRAME_SIZE_64);
1903     
1904     if (offset < MIN_IMM16 || MAX_IMM16 < offset) assert(0);
1905     insnCodeGen::generateImm(gen, CALop, dest, REG_SP, offset);
1906   }
1907     break;
1908   case loadRegRelativeAddr:
1909     // (readReg(src2) + src1)
1910     gen.rs()->readProgramRegister(gen, src2, dest, size);
1911     emitImm(plusOp, dest, src1, dest, gen, false);
1912     break;
1913   case loadRegRelativeOp:
1914     // *(readReg(src2) + src1)
1915     gen.rs()->readProgramRegister(gen, src2, dest, size);
1916
1917     if (size == 1)
1918       insnCodeGen::generateImm(gen, LBZop, dest, dest, src1);
1919     else if (size == 2)
1920       insnCodeGen::generateImm(gen, LHZop, dest, dest, src1);
1921     else if ((size == 4) ||
1922              (size == 8 && proc->getAddressWidth() == 4)) // Override bogus size
1923       insnCodeGen::generateImm(gen, Lop,   dest, dest, src1);
1924     else if (size == 8)
1925       insnCodeGen::generateMemAccess64(gen, LDop, LDxop,
1926                                        dest, dest, src1);
1927     break;
1928   default:
1929
1930
1931     cerr << "Unknown op " << op << endl;
1932     assert(0);
1933   }
1934 }
1935
1936 void emitVstore(opCode op, Register src1, Register /*src2*/, Address dest,
1937                 codeGen &gen, bool noCost, 
1938                 registerSpace * /* rs */, int size,
1939                 const instPoint * /* location */, AddressSpace *proc)
1940 {
1941     if (op == storeOp) {
1942         // temp register to hold base address for store (added 6/26/96 jkh)
1943         Register temp = gen.rs()->getScratchRegister(gen, noCost);
1944
1945         insnCodeGen::loadPartialImmIntoReg(gen, temp, (long)dest);
1946         if (size == 1)
1947             insnCodeGen::generateImm(gen, STBop, src1, temp, LOW(dest));
1948         else if (size == 2)
1949             insnCodeGen::generateImm(gen, STHop, src1, temp, LOW(dest));
1950         else if ((size == 4) ||
1951                  (size == 8 && proc->getAddressWidth() == 4)) // Override bogus size
1952             insnCodeGen::generateImm(gen, STop,  src1, temp, LOW(dest));
1953         else if (size == 8)
1954             insnCodeGen::generateMemAccess64(gen, STDop, STDxop,
1955                                              src1, temp, (int16_t)BOT_LO(dest));
1956         else assert(0 && "Incompatible storeOp size");
1957
1958     } else if (op == storeFrameRelativeOp) {
1959         long offset = (long)dest;
1960         offset += (gen.width() == 4
1961                    ? TRAMP_FRAME_SIZE_32
1962                    : TRAMP_FRAME_SIZE_64);
1963
1964         if (size == 1)
1965             insnCodeGen::generateImm(gen, STBop, src1, REG_SP, offset);
1966         else if (size == 2)
1967             insnCodeGen::generateImm(gen, STHop, src1, REG_SP, offset);
1968         else if ((size == 4) ||
1969                  (size == 8 || proc->getAddressWidth() == 4)) // Override bogus size
1970             insnCodeGen::generateImm(gen, STop,  src1, REG_SP, offset);
1971         else if (size == 8)
1972             insnCodeGen::generateMemAccess64(gen, STDop, STDxop, src1,
1973                                              REG_SP, offset);
1974         else assert(0 && "Incompatible storeFrameRelativeOp size");
1975
1976     } else assert(0 && "Unknown op passed to emitVstore");
1977 }
1978
1979 void emitV(opCode op, Register src1, Register src2, Register dest,
1980            codeGen &gen, bool /*noCost*/,
1981            registerSpace * /*rs*/, int size,
1982            const instPoint * /* location */, AddressSpace *proc)
1983 {
1984     //bperr("emitV(op=%d,src1=%d,src2=%d,dest=%d)\n",op,src1,src2,dest);
1985
1986     assert ((op!=branchOp) && (op!=ifOp) && 
1987             (op!=trampPreamble));         // !emitA
1988     assert ((op!=getRetValOp) && (op!=getParamOp));             // !emitR
1989     assert ((op!=loadOp) && (op!=loadConstOp));                 // !emitVload
1990     assert ((op!=storeOp));                                     // !emitVstore
1991     assert ((op!=updateCostOp));                                // !emitVupdate
1992
1993     instruction insn;
1994
1995     if (op == loadIndirOp) {
1996        // really load dest, (dest)imm
1997        assert(src2 == 0); // Since we don't use it.
1998        if (!size)
1999           size = proc->getAddressWidth();
2000        if (size == 1)
2001           insnCodeGen::generateImm(gen, LBZop, dest, src1, 0);
2002        else if (size == 2)
2003           insnCodeGen::generateImm(gen, LHZop, dest, src1, 0);
2004        else if ((size == 4) ||
2005                 (size == 8 && proc->getAddressWidth() == 4)) // Override bogus size
2006           insnCodeGen::generateImm(gen, Lop,   dest, src1, 0);
2007        else if (size == 8) {
2008           insnCodeGen::generateMemAccess64(gen, LDop, LDxop,
2009                                            dest, src1, 0);
2010        } 
2011        else 
2012           assert(0 && "Incompatible loadOp size");
2013     } else if (op == storeIndirOp) {
2014         // generate -- st src1, dest
2015         if (size == 1)
2016             insnCodeGen::generateImm(gen, STBop, src1, dest, 0);
2017         else if (size == 2)
2018             insnCodeGen::generateImm(gen, STHop, src1, dest, 0);
2019         else if ((size == 4) ||
2020                  (size == 8 && proc->getAddressWidth() == 4)) // Override bogus size
2021             insnCodeGen::generateImm(gen, STop,  src1, dest, 0);
2022         else if (size == 8)
2023             insnCodeGen::generateMemAccess64(gen, STDop, STDxop,
2024                                              src1, dest, 0);
2025         else assert(0 && "Incompatible storeOp size");
2026
2027     } else if (op == noOp) {
2028         insnCodeGen::generateNOOP(gen);
2029
2030     } else if (op == saveRegOp) {
2031         saveRegister(gen,src1,8);
2032
2033     } else {
2034         int instXop=-1;
2035         int instOp=-1;
2036         switch (op) {
2037             // integer ops
2038             case plusOp:
2039                 instOp = CAXop;
2040                 instXop = CAXxop;
2041                 break;
2042
2043             case minusOp:
2044                 Register temp;
2045                 // need to flip operands since this computes ra-rb not rb-ra
2046                 temp = src1;
2047                 src1 = src2;
2048                 src2 = temp;
2049                 instOp = SFop;
2050                 instXop = SFxop;
2051                 break;
2052
2053             case timesOp:
2054                 instOp = MULSop;
2055                 instXop = MULSxop;
2056                 break;
2057
2058             case divOp:
2059                 instOp = DIVSop;   // POWER divide instruction
2060                                    // Same as DIVWop for PowerPC
2061                 instXop = DIVWxop; // PowerPC
2062                 break;
2063
2064             // Bool ops
2065             case orOp:
2066                 //genSimple(gen, ORop, src1, src2, dest);
2067                 insn.clear();
2068                 XOFORM_OP_SET(insn, ORop);
2069                 // operation is ra <- rs | rb (or rs,ra,rb)
2070                 XOFORM_RA_SET(insn, dest);
2071                 XOFORM_RT_SET(insn, src1);
2072                 XOFORM_RB_SET(insn, src2);
2073                 XOFORM_XO_SET(insn, ORxop);
2074                 insnCodeGen::generate(gen,insn);
2075                 return;
2076                 break;
2077
2078             case andOp:
2079                 //genSimple(gen, ANDop, src1, src2, dest);
2080                 // This is a Boolean and with true == 1 so bitwise is OK
2081                 insn.clear();
2082                 XOFORM_OP_SET(insn, ANDop);
2083                 // operation is ra <- rs & rb (and rs,ra,rb)
2084                 XOFORM_RA_SET(insn, dest);
2085                 XOFORM_RT_SET(insn, src1);
2086                 XOFORM_RB_SET(insn, src2);
2087                 XOFORM_XO_SET(insn, ANDxop);
2088                 insnCodeGen::generate(gen,insn);
2089                 return;
2090                 break;
2091
2092             // rel ops
2093             case eqOp:
2094                 insnCodeGen::generateRelOp(gen, EQcond, BTRUEcond, src1, src2, dest);
2095                 return;
2096                 break;
2097
2098             case neOp:
2099                 insnCodeGen::generateRelOp(gen, EQcond, BFALSEcond, src1, src2, dest);
2100                 return;
2101                 break;
2102
2103             case lessOp:
2104                 insnCodeGen::generateRelOp(gen, LTcond, BTRUEcond, src1, src2, dest);
2105                 return;
2106                 break;
2107
2108             case greaterOp:
2109                 insnCodeGen::generateRelOp(gen, GTcond, BTRUEcond, src1, src2, dest);
2110                 return;
2111                 break;
2112
2113             case leOp:
2114                 insnCodeGen::generateRelOp(gen, GTcond, BFALSEcond, src1, src2, dest);
2115                 return;
2116                 break;
2117
2118             case geOp:
2119                 insnCodeGen::generateRelOp(gen, LTcond, BFALSEcond, src1, src2, dest);
2120                 return;
2121                 break;
2122
2123             default:
2124                 // internal error, invalid op.
2125                 bperr( "Invalid op passed to emit, instOp = %d\n", instOp);
2126                 assert(0 && "Invalid op passed to emit");
2127                 break;
2128         }
2129
2130         
2131         assert((instOp != -1) && (instXop != -1));
2132         insn.clear();
2133         XOFORM_OP_SET(insn, instOp);
2134         XOFORM_RT_SET(insn, dest);
2135         XOFORM_RA_SET(insn, src1);
2136         XOFORM_RB_SET(insn, src2);
2137         XOFORM_XO_SET(insn, instXop);
2138         insnCodeGen::generate(gen,insn);
2139     }
2140   return;
2141 }
2142
2143
2144 //
2145 // I don't know how to compute cycles for POWER instructions due to 
2146 //   multiple functional units.  However, we can compute the number of
2147 //   instructions and hope that is fairly close. - jkh 1/30/96
2148 //
2149 int getInsnCost(opCode op)
2150   {
2151     int cost = 0;
2152
2153     /* XXX Need to add branchOp */
2154     switch (op) {
2155       
2156     case noOp:
2157     case loadIndirOp:
2158     case saveRegOp:
2159
2160       // worse case is it is on the stack and takes one instruction.
2161     case getParamOp:
2162
2163       // integer ops
2164     case plusOp:
2165     case minusOp:
2166     case timesOp:
2167     case divOp:
2168       cost = 1;
2169       break;
2170
2171     case loadConstOp:
2172       // worse case is addi followed by ori
2173
2174     case loadOp:
2175       // addis, l
2176       
2177     case storeOp:
2178     case storeIndirOp:
2179       cost = 2;
2180       break;
2181
2182     case ifOp:
2183       // cmpi 0,0,src1,0
2184       // be 0, dest
2185       // nop
2186       cost = 3;
2187       break;
2188
2189       // rel ops
2190     case eqOp:
2191     case neOp:
2192     case lessOp:
2193     case greaterOp:
2194     case leOp:
2195     case geOp:
2196       cost = 4;
2197       break;
2198       
2199     case callOp:
2200       // mflr r0
2201       // st r0, (r1)
2202       cost += 2;
2203       
2204       // Should compute the cost to save registers here.  However, we lack 
2205       //   sufficient information to compute this value. We need to be 
2206       //   inside the code generator to know this amount.
2207       //
2208       // We know it is at *least* every live register (i.e. parameter reg)
2209       cost += 13;
2210       
2211       // clr r5
2212       // clr r6
2213       // decrement stack pointer -- STUop
2214       // load r0 with address, then move to link reg and branch and link.
2215       // ori dest,dest,LOW(src1)
2216       // mtlr   0 (aka mtspr 8, rs) = 0x7c0803a6
2217       // brl - branch and link through the link reg.
2218       cost += 7;
2219       
2220       // now cleanup.
2221       
2222       // increment stack pointer -- CALop
2223       // restore the saved register 0.
2224       cost += 2;
2225       
2226       // Should compute the cost to restore registers here.  However, we lack 
2227       //   sufficient information to compute this value. We need to be 
2228       //   inside the code generator to know this amount.
2229       //
2230       // We know it is at *least* every live register (i.e. parameter reg)
2231       cost += 13;
2232       
2233       // mtlr   0 
2234       cost++;
2235       break;
2236
2237     case updateCostOp:
2238       // In most cases this cost is 4, but if we can't use CALop because
2239       // the value is to large, then we'll need 2 additional operations to
2240       // load that value - naim
2241       // Why the +=? Isn't it equivalent to an = here? -- bernat
2242       cost += 4;
2243       break;
2244       
2245     case trampPreamble:
2246       // Generate code to update the observed cost.
2247       // generated code moved to the base trampoline.
2248       cost += 0;
2249       break;
2250
2251     default:
2252       cost = 0;
2253       break;
2254     }
2255     return (cost);
2256 }
2257
2258 #if 0
2259 // What does this do???
2260 void registerSpace::saveClobberInfo(const instPoint *location)
2261 {
2262   registerSlot *regSlot = NULL;
2263   registerSlot *regFPSlot = NULL;
2264   if (location == NULL)
2265     return;
2266   if (location->actualGPRLiveSet_ != NULL && location->actualFPRLiveSet_ != NULL)
2267     {
2268       
2269       // REG guard registers, if live, must be saved
2270       if (location->actualGPRLiveSet_[ REG_GUARD_ADDR ] == LIVE_REG)
2271         location->actualGPRLiveSet_[ REG_GUARD_ADDR ] = LIVE_CLOBBERED_REG;
2272       
2273       if (location->actualGPRLiveSet_[ REG_GUARD_OFFSET ] == LIVE_REG)
2274         location->actualGPRLiveSet_[ REG_GUARD_OFFSET ] = LIVE_CLOBBERED_REG;
2275
2276       // GPR and FPR scratch registers, if live, must be saved
2277       if (location->actualGPRLiveSet_[ REG_SCRATCH ] == LIVE_REG)
2278         location->actualGPRLiveSet_[ REG_SCRATCH ] = LIVE_CLOBBERED_REG;
2279
2280       if (location->actualFPRLiveSet_[ REG_SCRATCH ] == LIVE_REG)
2281         location->actualFPRLiveSet_[ REG_SCRATCH ] = LIVE_CLOBBERED_REG;
2282
2283       // Return func call register, since we make a call because
2284       // of multithreading (regardless if it's threaded) from BT
2285       // we must save return register
2286       if (location->actualGPRLiveSet_[ 3 ] == LIVE_REG)
2287         location->actualGPRLiveSet_[ 3 ] = LIVE_CLOBBERED_REG;
2288
2289     
2290       for (u_int i = 0; i < getRegisterCount(); i++)
2291         {
2292           regSlot = getRegSlot(i);
2293
2294           if (  location->actualGPRLiveSet_[ (int) registers[i].number ] == LIVE_REG )
2295             {
2296               if (!registers[i].beenClobbered)
2297                 location->actualGPRLiveSet_[ (int) registers[i].number ] = LIVE_UNCLOBBERED_REG;
2298               else
2299                 location->actualGPRLiveSet_[ (int) registers[i].number ] = LIVE_CLOBBERED_REG;
2300             }
2301
2302
2303           if (  location->actualGPRLiveSet_[ (int) registers[i].number ] == LIVE_UNCLOBBERED_REG ) 
2304             {
2305               if (registers[i].beenClobbered)
2306                 location->actualGPRLiveSet_[ (int) registers[i].number ] = LIVE_CLOBBERED_REG;
2307             }
2308         }
2309           
2310       for (u_int i = 0; i < getFPRegisterCount(); i++)
2311         {
2312           regFPSlot = getFPRegSlot(i);
2313           
2314           if (  location->actualFPRLiveSet_[ (int) fpRegisters[i].number ] == LIVE_REG )
2315             {
2316               if (!fpRegisters[i].beenClobbered)
2317                 location->actualFPRLiveSet_[ (int) fpRegisters[i].number ] = LIVE_UNCLOBBERED_REG;
2318               else
2319                 location->actualFPRLiveSet_[ (int) fpRegisters[i].number ] = LIVE_CLOBBERED_REG;
2320             }
2321           
2322           if (  location->actualFPRLiveSet_[ (int) fpRegisters[i].number ] == LIVE_UNCLOBBERED_REG )
2323             {
2324               if (fpRegisters[i].beenClobbered)
2325                 location->actualFPRLiveSet_[ (int) fpRegisters[i].number ] = LIVE_CLOBBERED_REG;
2326             }
2327         }
2328     }
2329 }
2330 #endif
2331
2332
2333 bool doNotOverflow(int value)
2334 {
2335   // we are assuming that we have 15 bits to store the immediate operand.
2336   if ( (value <= 32767) && (value >= -32768) ) return(true);
2337   else return(false);
2338 }
2339
2340 #if !defined(os_vxworks)
2341 // hasBeenBound: returns true if the runtime linker has bound the
2342 // function symbol corresponding to the relocation entry in at the address
2343 // specified by entry and base_addr.  If it has been bound, then the callee 
2344 // function is returned in "target_pdf", else it returns false.
2345 bool PCProcess::hasBeenBound(const SymtabAPI::relocationEntry &entry, 
2346                 func_instance *&target_pdf, Address base_addr) 
2347 {
2348
2349         if (isTerminated()) return false;
2350
2351         // if the relocationEntry has not been bound yet, then the value
2352         // at rel_addr is the address of the instruction immediately following
2353         // the first instruction in the PLT entry (which is at the target_addr) 
2354         // The PLT entries are never modified, instead they use an indirrect 
2355         // jump to an address stored in the _GLOBAL_OFFSET_TABLE_.  When the 
2356         // function symbol is bound by the runtime linker, it changes the address
2357         // in the _GLOBAL_OFFSET_TABLE_ corresponding to the PLT entry
2358
2359         Address got_entry = entry.rel_addr() + base_addr;
2360         Address bound_addr = 0;
2361         if (!readDataSpace((const void*)got_entry, sizeof(Address),
2362                                 &bound_addr, true)){
2363                 sprintf(errorLine, "read error in PCProcess::hasBeenBound addr 0x%x, pid=%d\n (readDataSpace returns 0)",(unsigned)got_entry,getPid());
2364                 logLine(errorLine);
2365                 //print_read_error_info(entry, target_pdf, base_addr);
2366                 fprintf(stderr, "%s[%d]: %s\n", FILE__, __LINE__, errorLine);
2367                 return false;
2368         }
2369
2370    //fprintf(stderr, "%s[%d]:  hasBeenBound:  %p ?= %p ?\n", FILE__, __LINE__, bound_addr, entry.target_addr() + 6 + base_addr);
2371         if ( !( bound_addr == (entry.target_addr()+6+base_addr)) ) {
2372           // the callee function has been bound by the runtime linker
2373           // find the function and return it
2374           target_pdf = findFuncByEntry(bound_addr);
2375           if(!target_pdf){
2376             return false;
2377           }
2378           return true;
2379         }
2380         return false;
2381 }
2382
2383 #endif
2384
2385 bool PCProcess::bindPLTEntry(const SymtabAPI::relocationEntry &, Address, 
2386                            func_instance *, Address) {
2387    assert(0 && "TODO!");
2388    return false;
2389 }
2390 void emitLoadPreviousStackFrameRegister(Address register_num, 
2391                                         Register dest,
2392                                         codeGen &gen,
2393                                         int /*size*/,
2394                                         bool noCost)
2395 {
2396     // As of 10/24/2007, the size parameter is still incorrect.
2397     // Luckily, we know implicitly what size they actually want.
2398
2399     // Offset if needed
2400     int offset;
2401     // Unused, 3OCT03
2402     //instruction *insn_ptr = (instruction *)insn;
2403     // We need values to define special registers.
2404
2405     switch ( (int) register_num) {
2406     case registerSpace::lr:
2407         // LR is saved on the stack
2408         // Note: this is only valid for non-function entry/exit instru. 
2409         // Once we've entered a function, the LR is stomped to point
2410         // at the exit tramp!
2411       offset = TRAMP_SPR_OFFSET(gen.width()) + STK_LR; 
2412
2413         // Get address (SP + offset) and stick in register dest.
2414         emitImm(plusOp ,(Register) REG_SP, (RegValue) offset, dest,
2415                 gen, noCost, gen.rs());
2416         // Load LR into register dest
2417         emitV(loadIndirOp, dest, 0, dest, gen, noCost, gen.rs(),
2418               gen.width(), gen.point(), gen.addrSpace());
2419         break;
2420
2421     case registerSpace::ctr:
2422         // CTR is saved down the stack
2423         if (gen.width() == 4)
2424           offset = TRAMP_SPR_OFFSET(gen.width()) + STK_CTR_32;
2425         else
2426           offset = TRAMP_SPR_OFFSET(gen.width()) + STK_CTR_64;
2427
2428         // Get address (SP + offset) and stick in register dest.
2429         emitImm(plusOp ,(Register) REG_SP, (RegValue) offset, dest,
2430                 gen, noCost, gen.rs());
2431         // Load LR into register dest
2432         emitV(loadIndirOp, dest, 0, dest, gen, noCost, gen.rs(),
2433               gen.width(), gen.point(), gen.addrSpace());
2434       break;
2435
2436     default:
2437         cerr << "Fallthrough in emitLoadPreviousStackFrameRegister" << endl;
2438         cerr << "Unexpected register " << register_num << endl;
2439         assert(0);
2440         break;
2441     }
2442 }
2443
2444 void emitStorePreviousStackFrameRegister(Address,
2445                                          Register,
2446                                          codeGen &,
2447                                          int,
2448                                          bool) {
2449     assert(0);
2450 }
2451
2452 using namespace Dyninst::InstructionAPI; 
2453 bool AddressSpace::getDynamicCallSiteArgs(InstructionAPI::Instruction::Ptr i,
2454                                           Address addr, 
2455                                           pdvector<AstNodePtr> &args)
2456 {
2457   static RegisterAST::Ptr ctr32(new RegisterAST(ppc32::ctr));
2458   static RegisterAST::Ptr ctr64(new RegisterAST(ppc64::ctr));
2459   static RegisterAST::Ptr lr32(new RegisterAST(ppc32::lr));
2460   static RegisterAST::Ptr lr64(new RegisterAST(ppc64::lr));
2461     Register branch_target = registerSpace::ignored;
2462
2463     // Is this a branch conditional link register (BCLR)
2464     // BCLR uses the xlform (6,5,5,5,10,1)
2465     for(Instruction::cftConstIter curCFT = i->cft_begin();
2466         curCFT != i->cft_end();
2467         ++curCFT)
2468     {
2469       if(curCFT->target->isUsed(ctr32) ||
2470          curCFT->target->isUsed(ctr64))
2471         {
2472             branch_target = registerSpace::ctr;
2473             break;
2474         }
2475       else if(curCFT->target->isUsed(lr32) ||
2476               curCFT->target->isUsed(lr64))
2477         {
2478           fprintf(stderr, "setting lr\n");
2479             branch_target = registerSpace::lr;
2480             break;
2481         }
2482     }
2483     if(branch_target != registerSpace::ignored)
2484     {
2485         // Where we're jumping to (link register, count register)
2486         args.push_back( AstNode::operandNode(AstNode::origRegister,
2487                         (void *) branch_target));
2488
2489         // Where we are now
2490         args.push_back( AstNode::operandNode(AstNode::Constant,
2491                         (void *) addr));
2492
2493         return true;
2494     }
2495     else
2496     {
2497       return false;
2498     }
2499 }
2500
2501 bool writeFunctionPtr(AddressSpace *p, Address addr, func_instance *f)
2502 {
2503     // 64-bit ELF PowerPC Linux uses r2 (same as AIX) for TOC base register
2504     if (p->getAddressWidth() == sizeof(uint64_t)) {
2505         Address val_to_write = f->addr();
2506         // Use function descriptor address, if available.
2507         if (f->getPtrAddress()) val_to_write = f->getPtrAddress();
2508         return p->writeDataSpace((void *) addr,
2509                                  sizeof(val_to_write), &val_to_write);
2510     }
2511     else {
2512         // Originally copied from inst-x86.C
2513         // 32-bit ELF PowerPC Linux mutatee
2514         uint32_t val_to_write = (uint32_t)f->addr();
2515         return p->writeDataSpace((void *) addr,
2516                                  sizeof(val_to_write), &val_to_write);
2517     }
2518 }
2519
2520 Emitter *AddressSpace::getEmitter() 
2521 {
2522     static EmitterPOWER32Dyn emitter32Dyn;
2523     static EmitterPOWER64Dyn emitter64Dyn;
2524     static EmitterPOWER32Stat emitter32Stat;
2525     static EmitterPOWER64Stat emitter64Stat;
2526
2527     if (getAddressWidth() == 8) {
2528         if (proc()) {
2529             return &emitter64Dyn;
2530         }
2531         else return &emitter64Stat;
2532     }
2533     if (proc())
2534         return &emitter32Dyn;
2535     else
2536         return &emitter32Stat;
2537
2538     assert(0);
2539     return NULL;
2540 }
2541
2542 #define GET_IP      0x429f0005
2543 #define MFLR_30     0x7fc802a6
2544 #define ADDIS_30_30 0x3fde0000
2545 #define ADDI_30_30  0x3bde0000
2546 #define LWZ_11_30   0x817e0000
2547 #define ADDIS_11_30 0x3d7e0000
2548
2549 /*
2550  * If the target stub_addr is a glink stub, try to determine the actual
2551  * function called (through the GOT) and fill in that information.
2552  *
2553  * The function at stub_addr may not have been created when this method
2554  * is called.
2555  *
2556  * XXX Is this a candidate to move into general parsing code, or is
2557  *     this properly a Dyninst-only technique?
2558  */
2559 bool image::updatePltFunc(parse_func *caller_func, Address stub_addr)
2560 {
2561     unsigned int *stub;
2562     Address got2 = 0;
2563
2564     if(!getPltFuncs())
2565         return false;
2566
2567     // If we're calling an empty glink stub.
2568     unordered_map<Address, std::string>::iterator entry = pltFuncs->find(stub_addr);
2569     if (entry != pltFuncs->end() && entry->second == "@plt")
2570     {
2571         int state = 0;
2572
2573         // Find GOT2 value
2574         auto bl = caller_func->blocks();
2575         auto bit = bl.begin();
2576         for( ; bit != bl.end(); ++bit) {
2577           ParseAPI::Block * b = *bit;
2578           for(Address addr = b->start(); addr < b->end();
2579               addr += instruction::size()) // XXX 4
2580           {
2581             unsigned int * caller_insn = 
2582                 (unsigned int *)caller_func->isrc()->getPtrToInstruction(addr);
2583
2584             if (state == 0 && *caller_insn == GET_IP) {
2585                 got2 = addr + instruction::size();
2586                 ++state;
2587             } else if (state == 1 && *caller_insn == MFLR_30) {
2588                 ++state;
2589             } else if (state == 4) {
2590                 break;
2591             } 
2592             else if (state >= 2 && (*caller_insn & 0xffff0000) == ADDIS_30_30)
2593             {
2594                 got2 += ((signed short)(*caller_insn & 0x0000ffff)) << 16;
2595                 ++state;
2596             } 
2597             else if (state >= 2 && (*caller_insn & 0xffff0000) == ADDI_30_30)
2598             {
2599                 got2 += (signed short)(*caller_insn & 0x0000ffff);
2600                 ++state;
2601             }
2602           }
2603         }
2604         if (state != 4) return false;
2605
2606         // Find stub offset
2607         stub = (unsigned int *)
2608             caller_func->isrc()->getPtrToInstruction(stub_addr);
2609         int offset = 0;
2610         if ( (stub[0] & 0xffff0000) == LWZ_11_30) {
2611             offset = (signed short)(stub[0] & 0x0000ffff);
2612         } else if ( (stub[0] & 0xffff0000) == ADDIS_11_30) {
2613             offset &= (stub[0] & 0x0000ffff) << 16;
2614             offset &= (stub[1] & 0x0000ffff);
2615         }
2616
2617         // Update all PLT based structures
2618         Address plt_addr = got2 + offset;
2619         (*pltFuncs)[stub_addr] = (*pltFuncs)[plt_addr];
2620         getObject()->updateFuncBindingTable(stub_addr, plt_addr);
2621     }
2622     return true;
2623 }
2624
2625 bool EmitterPOWER::emitCallRelative(Register dest, Address offset, Register base, codeGen &gen){
2626     // Loads a saved register from the stack. 
2627     int imm = offset;
2628     if (gen.width() == 4) {
2629       if (((signed)MIN_IMM16 <= (signed)imm) && ((signed)imm <= (signed)MAX_IMM16))
2630         {
2631           insnCodeGen::generateImm (gen, CALop, dest, base, imm);
2632
2633         }
2634       else if (((signed)MIN_IMM32 <= (signed)imm) && ((signed)imm <= (signed)MAX_IMM32))
2635         {
2636           insnCodeGen::generateImm (gen, CAUop, dest, 0, BOT_HI (offset));
2637           insnCodeGen::generateImm (gen, ORILop, dest, dest, BOT_LO (offset));
2638           insnCodeGen::generateAddReg (gen, CAXop, dest, dest, base);
2639         }
2640         else {
2641                 assert(0);
2642         }
2643         
2644     }
2645     else {
2646 /*        insnCodeGen::generateMemAccess64(gen, LDop, LDxop,
2647                                          dest,
2648                                          base,
2649                                          offset);
2650 */
2651     }
2652     return true;
2653 }
2654
2655 bool EmitterPOWER::emitLoadRelative(Register dest, Address offset, Register base, int size, codeGen &gen){ 
2656   if (((long)MIN_IMM16 <= (long)offset) && ((long) offset <= (long)MAX_IMM16)) {
2657     int ocode = Lop;
2658     switch (size) {
2659     case 1:
2660       ocode = LBZop;
2661       break;
2662     case 2:
2663       ocode = LHZop;
2664       break;
2665     case 4:
2666       ocode = Lop;
2667       break;
2668     case 8:
2669       ocode = LDop;
2670       break;
2671     default:
2672       return false;
2673       break;
2674     }
2675     insnCodeGen::generateImm (gen, ocode, dest, base, offset);    
2676   }
2677   else {
2678     // We're about to stomp dest to get a number in it... make sure that
2679     // it's not also the base register
2680     assert(dest != base); 
2681     Register scratch = dest;
2682     if (dest == base) {
2683       // Can't use it because base holds a value we need
2684       scratch = gen.rs()->getScratchRegister(gen, true);
2685     }
2686
2687     insnCodeGen::loadImmIntoReg(gen, scratch, offset);
2688
2689     int ocode = LXop;
2690     int xcode = 0;
2691     switch (size) {
2692     case 1:
2693       xcode = LBZXxop;
2694       break;
2695     case 2:
2696       xcode = LHZXxop;
2697       break;
2698     case 4:
2699       xcode = LXxop;
2700       break;
2701     case 8:
2702       xcode = LDXxop;
2703       break;
2704     default:
2705       printf(" Unrecognized size for load operation(%d). Assuming size of 4 \n", size);
2706       return false;
2707       break;
2708     }
2709     
2710     instruction insn; insn.clear();
2711     XFORM_OP_SET(insn, ocode);
2712     XFORM_RT_SET(insn, dest);
2713     XFORM_RA_SET(insn, scratch);
2714     XFORM_RB_SET(insn, base);
2715     XFORM_XO_SET(insn, xcode);
2716     XFORM_RC_SET(insn, 0);
2717     insnCodeGen::generate(gen, insn);
2718   }
2719   return true;
2720 }
2721
2722
2723 void EmitterPOWER::emitStoreRelative(Register source, Address offset, Register base, int size, codeGen &gen){
2724   if (((long)MIN_IMM16 <= (long)offset) && ((long) offset <= (long)MAX_IMM16)) {
2725     int ocode = STop;
2726     switch (size) {
2727     case 1:
2728       ocode = STBop;
2729       break;
2730     case 2:
2731       ocode = STHop;
2732       break;
2733     case 4:
2734       ocode = STop;
2735       break;
2736     case 8:
2737       ocode = STDop;
2738       break;
2739     default:
2740       //return false;
2741       assert(0);
2742       break;
2743     }
2744     insnCodeGen::generateImm (gen, ocode, source, base, offset);    
2745   }
2746   else {
2747     Register scratch = gen.rs()->getScratchRegister(gen, true);
2748     assert(scratch != REG_NULL);
2749
2750     insnCodeGen::loadImmIntoReg(gen, scratch, offset);
2751
2752     int ocode = STXop;
2753     int xcode = 0;
2754     switch (size) {
2755     case 1:
2756       xcode = STBXxop;
2757       break;
2758     case 2:
2759       xcode = STHXxop;
2760       break;
2761     case 4:
2762       xcode = STXxop;
2763       break;
2764     case 8:
2765       xcode = STDXxop;
2766       break;
2767     default:
2768       printf(" Unrecognized size for load operation(%d). Assuming size of 4 \n", size);
2769       //return false;
2770       assert(0);
2771       break;
2772     }
2773     
2774     instruction insn; insn.clear();
2775     XFORM_OP_SET(insn, ocode);
2776     XFORM_RT_SET(insn, source);
2777     XFORM_RA_SET(insn, scratch);
2778     XFORM_RB_SET(insn, base);
2779     XFORM_XO_SET(insn, xcode);
2780     XFORM_RC_SET(insn, 0);
2781     insnCodeGen::generate(gen, insn);
2782   }
2783   //return true;
2784 }
2785
2786 bool EmitterPOWER::emitMoveRegToReg(registerSlot *src,
2787                                     registerSlot *dest,
2788                                     codeGen &gen) {
2789     assert(dest->type == registerSlot::GPR);
2790
2791     switch (src->type) {
2792     case registerSlot::GPR:
2793         insnCodeGen::generateImm(gen, ORILop, src->encoding(), dest->encoding(), 0);
2794         break;
2795     case registerSlot::SPR: {
2796         instruction insn;
2797         
2798         switch (src->number) {
2799         case registerSpace::lr:
2800         case registerSpace::xer:
2801         case registerSpace::ctr:
2802         case registerSpace::mq:
2803             insn.clear();
2804             XFORM_OP_SET(insn, EXTop);
2805             XFORM_RT_SET(insn, dest->encoding());
2806             XFORM_RA_SET(insn, src->encoding() & 0x1f);
2807             XFORM_RB_SET(insn, (src->encoding() >> 5) & 0x1f);
2808             XFORM_XO_SET(insn, MFSPRxop);
2809             insnCodeGen::generate(gen,insn);
2810             break;
2811         case registerSpace::cr:
2812             insn.clear();                    //mtcrf:  scratchReg
2813             XFXFORM_OP_SET(insn, EXTop);
2814             XFXFORM_RT_SET(insn, dest->encoding());
2815             XFXFORM_XO_SET(insn, MFCRxop);
2816             insnCodeGen::generate(gen,insn);
2817             break;
2818         default:
2819             assert(0);
2820             break;
2821         }
2822         break;
2823     }
2824
2825     default:
2826         assert(0);
2827         break;
2828     }
2829     return true;
2830 }
2831
2832 /*
2833 bool EmitterPOWER32Stat::emitPIC(codeGen& gen, Address origAddr, Address relocAddr) {
2834
2835       Register scratchPCReg = gen.rs()->getScratchRegister(gen, true);
2836       pdvector<Register> excludeReg;
2837       excludeReg.push_back(scratchPCReg);
2838       Register scratchReg = gen.rs()->getScratchRegister(gen, excludeReg, true);
2839       bool newStackFrame = false;
2840       int stack_size = 0;
2841       int gpr_off, fpr_off, ctr_off;
2842       //fprintf(stderr, " emitPIC origAddr 0x%lx reloc 0x%lx Registers PC %d scratch %d \n", origAddr, relocAddr, scratchPCReg, scratchReg);
2843       if ((scratchPCReg == REG_NULL) || (scratchReg == REG_NULL)) {
2844                 //fprintf(stderr, " Creating new stack frame for 0x%lx to 0x%lx \n", origAddr, relocAddr);
2845
2846                 newStackFrame = true;
2847                 //create new stack frame
2848                 gpr_off = TRAMP_GPR_OFFSET_32;
2849                 fpr_off = TRAMP_FPR_OFFSET_32;
2850                 ctr_off = STK_CTR_32;
2851
2852                 // Make a stack frame.
2853                 pushStack(gen);
2854
2855                 // Save GPRs
2856               stack_size = saveGPRegisters(gen, gen.rs(), gpr_off, 2);
2857
2858               scratchPCReg = gen.rs()->getScratchRegister(gen, true);
2859               assert(scratchPCReg != REG_NULL);
2860               excludeReg.clear();
2861               excludeReg.push_back(scratchPCReg);
2862               scratchReg = gen.rs()->getScratchRegister(gen, excludeReg, true);
2863               assert(scratchReg != REG_NULL);
2864               // relocaAddr has moved since we added instructions to setup a new stack frame
2865               relocAddr = relocAddr + ((stack_size + 1)*(gen.width()));
2866               //fprintf(stderr, " emitPIC origAddr 0x%lx reloc 0x%lx stack size %d Registers PC %d scratch %d \n", origAddr, relocAddr, stack_size, scratchPCReg, scratchReg);
2867
2868         } 
2869         emitMovePCToReg(scratchPCReg, gen);     
2870         Address varOffset = origAddr - relocAddr;
2871         emitCallRelative(scratchReg, varOffset, scratchPCReg, gen);
2872         insnCodeGen::generateMoveToLR(gen, scratchReg);
2873         if(newStackFrame) {
2874               // GPRs
2875               restoreGPRegisters(gen, gen.rs(), gpr_off);
2876               popStack(gen);
2877         }
2878
2879       return 0;
2880 }
2881
2882 bool EmitterPOWER64Stat::emitPIC(codeGen& gen, Address origAddr, Address relocAddr) {
2883         assert(0);
2884         return false;
2885 }
2886 bool EmitterPOWERDyn::emitPIC(codeGen &gen, Address origAddr, Address relocAddr) {
2887
2888         Address origRet = origAddr + 4;
2889         Register scratch = gen.rs()->getScratchRegister(gen, true);
2890         assert(scratch != REG_NULL);
2891         instruction::loadImmIntoReg(gen, scratch, origRet);
2892         insnCodeGen::generateMoveToLR(gen, scratch);
2893         return true;
2894
2895 }
2896 */
2897
2898
2899 // It seems like we should be able to do a better job...
2900 bool EmitterPOWER32Stat::emitCallInstruction(codeGen& gen, func_instance* callee, bool /* setTOC */, Address) {
2901 // 32 - No TOC 
2902 // if inter module, gen PIC code
2903   if (gen.func()->obj() != callee->obj()) {
2904     return emitPLTCall(callee, gen);
2905   }
2906
2907   insnCodeGen::generateCall(gen, gen.currAddr(), callee->addr());
2908   return true;
2909 }
2910
2911 bool EmitterPOWER32Stat::emitPLTCommon(func_instance *callee, bool call, codeGen &gen) {
2912   Register scratchReg = gen.rs()->getScratchRegister(gen, true);
2913   if (scratchReg == REG_NULL) return false;
2914
2915   Register scratchLR = REG_NULL;
2916   std::vector<Register> excluded; excluded.push_back(scratchReg);
2917   scratchLR = gen.rs()->getScratchRegister(gen, excluded, true);
2918   if (scratchLR == REG_NULL) {
2919     if (scratchReg == registerSpace::r0) return false;
2920     // We can use r0 for this, since it's volatile. 
2921     scratchLR = registerSpace::r0;
2922   }
2923
2924   if (!call) {
2925     // Save the LR in scratchLR
2926     insnCodeGen::generateMoveFromLR(gen, scratchLR);
2927   }
2928
2929   // Generate the PLT call
2930
2931   Address dest = getInterModuleFuncAddr(callee, gen);  
2932   Address pcVal = emitMovePCToReg(scratchReg, gen);
2933
2934   if (!call) {
2935     insnCodeGen::generateMoveToLR(gen, scratchLR);
2936   }
2937
2938   // We can now use scratchLR
2939
2940   Address varOffset = dest - pcVal;
2941   emitLoadRelative(scratchLR, varOffset, scratchReg, gen.width(), gen);
2942   
2943   insnCodeGen::generateMoveToCR(gen, scratchLR);
2944
2945   if (!call) {
2946     instruction br(BCTRraw);
2947     insnCodeGen::generate(gen, br);
2948   }
2949   else {
2950     instruction brl(BCTRLraw);
2951     insnCodeGen::generate(gen, brl);
2952   }
2953
2954   return true;
2955 }
2956
2957
2958 // TODO 32/64-bit? 
2959 bool EmitterPOWER32Stat::emitPLTCall(func_instance *callee, codeGen &gen) {
2960   return emitPLTCommon(callee, true, gen);
2961 }
2962
2963 bool EmitterPOWER32Stat::emitPLTJump(func_instance *callee, codeGen &gen) {
2964   return emitPLTCommon(callee, false, gen);
2965 }
2966
2967 bool EmitterPOWER32Stat::emitTOCCall(block_instance *block, codeGen &gen) {
2968   return emitTOCCommon(block, true, gen);
2969 }
2970
2971 bool EmitterPOWER32Stat::emitTOCJump(block_instance *block, codeGen &gen) {
2972   return emitTOCCommon(block, false, gen);
2973 }
2974
2975
2976 bool EmitterPOWER32Stat::emitTOCCommon(block_instance *block, bool call, codeGen &gen) {
2977   Register scratchReg = gen.rs()->getScratchRegister(gen, true);
2978   if (scratchReg == REG_NULL) return false;
2979
2980   Register scratchLR = REG_NULL;
2981   std::vector<Register> excluded; excluded.push_back(scratchReg);
2982   scratchLR = gen.rs()->getScratchRegister(gen, excluded, true);
2983   if (scratchLR == REG_NULL) {
2984     if (scratchReg == registerSpace::r0) return false;
2985     // We can use r0 for this, since it's volatile. 
2986     scratchReg = registerSpace::r0;
2987   }
2988
2989   if (!call) {
2990     // Save the LR in scratchLR
2991     insnCodeGen::generateMoveFromLR(gen, scratchLR);
2992   }
2993
2994   // Generate the PLT call
2995
2996   Address dest = block->llb()->firstInsnOffset();
2997   Address pcVal = emitMovePCToReg(scratchReg, gen);
2998
2999   if (!call) {
3000     insnCodeGen::generateMoveToLR(gen, scratchLR);
3001   }
3002
3003   // We can now use scratchLR
3004
3005   Address varOffset = dest - pcVal;
3006   emitLoadRelative(scratchLR, varOffset, scratchReg, gen.width(), gen);
3007   
3008   insnCodeGen::generateMoveToCR(gen, scratchLR);
3009
3010   if (!call) {
3011     instruction br(BCTRraw);
3012     insnCodeGen::generate(gen, br);
3013   }
3014   else {
3015     instruction brl(BCTRLraw);
3016     insnCodeGen::generate(gen, brl);
3017   }
3018
3019   return true;
3020 }
3021
3022 bool EmitterPOWER64Stat::emitPLTCommon(func_instance *callee, bool call, codeGen &gen) {
3023   // Okay, I'm going to try and describe how this works. 
3024   //
3025   // PPC64 uses a TOC, a range of memory pointed to by R2. The TOC is full of 
3026   // data pointers (64-bit pointers).
3027   //
3028   // For our purpose, a TOC entry _points to_ a function descriptor, which is 3 words:
3029   //   1) Function addr
3030   //   2) TOC value
3031   //   3) Environment pointer (optional)
3032   //
3033   // For a dynamic binary, we need to do the following to perform a PLT jump/call:
3034   //   1) Set the destination
3035   //   2) Set the TOC to the destination's value
3036   // We do so as follows:
3037   //   1) func_desc <- getInterModuleFuncAddr(callee)  // this is an allocated function descriptor
3038   //                                                   // that isn't allocated relative to the TOC,
3039   //                                                   // if I'm reading things right...
3040   //   2) r_tmp := func_desc
3041   //   3) r2 := *(r_tmp + 8)
3042   //   4) r_tmp2 := *(r_tmp)
3043   //   5) ctr := r_tmp2
3044   //   6) bctr/bctrl
3045   // 
3046   //   This code implies that we can reuse r_tmp for r_tmp2. 
3047   //
3048   // Now, we make things better; we also need to reset r2 when we're done. How do we do this for
3049   // a branch, which doesn't return control? I'm glad you asked!
3050   // If we save the LR, we can have control return to our current execution point, restore LR,
3051   // and then return again. So we get code like the following:
3052   //
3053   //  1) save LR
3054   //  2) r_tmp := func_desc
3055   //  3) r2 := *(r_tmp + 8)
3056   //  4) r_tmp := *(r_tmp)
3057   //  5) lr := r_tmp
3058   //  6) blrl
3059   //  7) if (!call) restore LR
3060   //  8) r2 := caller TOC value
3061   //  9) (if branch) return
3062   //
3063
3064   // Even if we're in a static binary we may need to change the TOC. Heck,
3065   // we may need to change the TOC in an intra-module call no matter what.
3066   // This is caused by a GOT that is larger than 64k (the only addressable
3067   // distance from the TOC). 
3068   //
3069   // TODO: the large model where everything is a 32-bit reference off the TOC. 
3070
3071
3072   const unsigned TOCreg = 2;
3073   const unsigned wordsize = gen.width();
3074   assert(wordsize == 8);
3075
3076   Address func_desc = getInterModuleFuncAddr(callee, gen);
3077
3078   Address caller_toc = 0;
3079   if (gen.func()) {
3080     caller_toc = gen.addrSpace()->getTOCoffsetInfo(gen.func());
3081   }
3082   else if (gen.point()) {
3083     caller_toc = gen.addrSpace()->getTOCoffsetInfo(gen.point()->func());
3084   }
3085   else {
3086     // Don't need it, and this might be an iRPC
3087   }
3088
3089   // We need a scratch register and a place to store the LR. However, in 64-bit PPC, there
3090   // are two words on the stack that are free at SP + 3W and SP + 4W. So we save r0 and LR there.
3091
3092   // Save R0 and LR
3093   unsigned r_tmp = 12; // R12 ; using R0 is dangerous since many memory operations treat it as 0. 
3094   insnCodeGen::generateMemAccess64(gen, STDop, STDxop, r_tmp, REG_SP, 3*wordsize);
3095   insnCodeGen::generateMoveFromLR(gen, r_tmp);
3096   insnCodeGen::generateMemAccess64(gen, STDop, STDxop, r_tmp, REG_SP, 4*wordsize);
3097
3098   // Save R2
3099   insnCodeGen::generateMemAccess64(gen, STDop, STDxop, TOCreg, REG_SP, 5*wordsize);
3100
3101   // r_tmp := func_desc
3102   // We don't load func_desc directly, as it's an offset rather than an address. 
3103   // What we can do though is load it relative to a different register value. Like, 
3104   // say, the current TOC. 
3105   Address func_desc_from_TOC = func_desc - caller_toc;
3106   insnCodeGen::loadImmIntoReg(gen, r_tmp, func_desc_from_TOC);
3107   if (caller_toc) {
3108     // If we know what the value is in R2 and thus used it...
3109     insnCodeGen::generateAddReg(gen, CAXop, r_tmp, r_tmp, TOCreg);
3110   }
3111
3112   // r2 := *(r_tmp + 8)
3113   insnCodeGen::generateMemAccess64(gen, LDop, LDxop, TOCreg, r_tmp, wordsize);
3114
3115   // r_tmp := *(r_tmp)
3116   insnCodeGen::generateMemAccess64(gen, LDop, LDxop, r_tmp, r_tmp, 0);
3117   
3118   // lr := r_tmp;
3119   insnCodeGen::generateMoveToLR(gen, r_tmp);
3120
3121   // Restore r_tmp to be sure
3122   insnCodeGen::generateMemAccess64(gen, LDop, LDxop, r_tmp, REG_SP, 3*wordsize);
3123
3124   // blrl
3125   instruction branch_insn(BRLraw);
3126   insnCodeGen::generate(gen, branch_insn);
3127
3128   // if (!call) restore LR
3129   if (!call) {
3130     insnCodeGen::generateMemAccess64(gen, STDop, STDxop, r_tmp, REG_SP, 3*wordsize);
3131     insnCodeGen::generateMemAccess64(gen, LDop, LDxop, r_tmp, REG_SP, 4*wordsize);
3132     insnCodeGen::generateMoveToLR(gen, r_tmp);
3133     insnCodeGen::generateMemAccess64(gen, LDop, LDxop, r_tmp, REG_SP, 3*wordsize);
3134   }
3135
3136   // Restore TOC
3137   insnCodeGen::generateMemAccess64(gen, LDop, LDxop, TOCreg, REG_SP, 5*wordsize);
3138
3139   if (!call) {
3140     instruction ret(BRraw);
3141     insnCodeGen::generate(gen, ret);
3142   }
3143  
3144   return true;
3145 }
3146
3147 #if 0
3148 bool EmitterPOWER64Stat::emitPLTCommon(func_instance *callee, bool call, codeGen &gen) {
3149   // In PPC64 Linux, function descriptors are used in place of direct
3150   // function pointers.  The descriptors have the following layout:
3151   //
3152   // Function Descriptor --> + 0: <Function Text Address>
3153   //                         + 8: <TOC Pointer Value>
3154   //                         +16: <Environment Pointer [Optional]>
3155   //
3156   // Additionally, this should be able to stomp on the link register (LR)
3157   // and TOC register (r2), as they were saved by Emitter::emitCall() if
3158   // necessary.
3159   //
3160   // So here's a brief sketch of the code this function generates:
3161   // 
3162   //   Set up new branch target in LR from function descriptor
3163   //   Set up new TOC in R2 from function descriptor + 8
3164   //   Call
3165   bool isStaticBinary = false;
3166   
3167   if(gen.addrSpace()->edit()->getMappedObject()->parse_img()->getObject()->isStaticBinary()) {
3168     isStaticBinary = true;
3169   }
3170   
3171   const unsigned TOCreg = 2;
3172   const unsigned wordsize = gen.width();
3173   assert(wordsize == 8);
3174   Address dest = getInterModuleFuncAddr(callee, gen);
3175   Address caller_toc = 0;
3176   Address toc_anchor = gen.addrSpace()->getTOCoffsetInfo(callee);
3177   // Instead of saving the TOC (if we can't), just reset it afterwards.
3178   if (gen.func()) {
3179     caller_toc = gen.addrSpace()->getTOCoffsetInfo(gen.func());
3180   }
3181   else if (gen.point()) {
3182     caller_toc = gen.addrSpace()->getTOCoffsetInfo(gen.point()->func());
3183   }
3184   else {
3185     // Don't need it, and this might be an iRPC
3186   }
3187   
3188   if(isStaticBinary)
3189     caller_toc = 0;
3190   
3191   //Offset destOff = dest - gen.currAddr();
3192   Offset destOff = dest - caller_toc;
3193   
3194   //    insnCodeGen::loadPartialImmIntoReg(gen, TOCreg, destOff);
3195   // Broken to see if any of this generates intellible code.
3196
3197   Register scratchReg = 3; // = gen.rs()->getScratchRegister(gen, true);
3198   int stackSize = 0;
3199   if (scratchReg == REG_NULL) {
3200     pdvector<Register> freeReg;
3201     pdvector<Register> excludeReg;
3202     stackSize = insnCodeGen::createStackFrame(gen, 1, freeReg, excludeReg);
3203     assert (stackSize == 1);
3204     scratchReg = freeReg[0];
3205   }
3206   insnCodeGen::loadImmIntoReg(gen, scratchReg, destOff);
3207
3208   if(!isStaticBinary) {
3209     insnCodeGen::generateLoadReg64(gen, scratchReg, scratchReg, TOCreg);
3210     
3211     insnCodeGen::generateMemAccess64(gen, LDop, LDxop,
3212                                      TOCreg, scratchReg, 8);
3213   } 
3214   insnCodeGen::generateMemAccess64(gen, LDop, LDxop,
3215                                    scratchReg, scratchReg, 0);
3216   
3217   insnCodeGen::generateMoveToCR(gen, scratchReg);
3218
3219   if (stackSize > 0)
3220     insnCodeGen::removeStackFrame(gen);
3221   
3222   
3223   instruction branch_insn(call ? BCTRLraw : BCTRraw);
3224   insnCodeGen::generate(gen, branch_insn);
3225   
3226   return true;
3227 }
3228 #endif
3229
3230 bool EmitterPOWER64Dyn::emitTOCCommon(block_instance *block, bool call, codeGen &gen) {
3231   // This code is complicated by the need to set the new TOC and restore it
3232   // post-(call/branch). That means we can't use a branch if asked, since we won't
3233   // regain control. Fun. 
3234   //
3235   // However, we can abuse the compiler word on the stack (SP + 3W) to store temporaries.
3236   //
3237   // So, we use the following:
3238   //
3239   // IF (!call)
3240   //   Save LR in <SP + 3W>
3241   // LR := Address of callee (Optimization: we can use a short branch here); use TOC as it's free
3242   // R2 := TOC of callee
3243   // Call LR
3244   // IF (!call)
3245   //   Restore LR from <SP + 3W>
3246   // R2 := TOC of caller
3247   // IF (!call)
3248   //   Return
3249
3250   const unsigned TOCreg = 2;
3251   const unsigned wordsize = gen.width();
3252   assert(wordsize == 8);
3253   Address dest = block->start();
3254
3255   // We need the callee TOC, which we find by function, not by block. 
3256   std::vector<func_instance *> funcs;
3257   block->getFuncs(std::back_inserter(funcs));
3258   Address callee_toc = gen.addrSpace()->getTOCoffsetInfo(funcs[0]);
3259   
3260   Address caller_toc = 0;
3261   if (gen.func()) {
3262     caller_toc = gen.addrSpace()->getTOCoffsetInfo(gen.func());
3263   }
3264   else if (gen.point()) {
3265     assert(gen.point()->func());
3266     caller_toc = gen.addrSpace()->getTOCoffsetInfo(gen.point()->func());
3267   }
3268   else {
3269     // Don't need it, and this might be an iRPC
3270   }
3271
3272   if (!call) {
3273     insnCodeGen::generateMoveFromLR(gen, TOCreg);
3274     insnCodeGen::generateMemAccess64(gen, STDop, STDxop,
3275                                      TOCreg, REG_SP, 3*wordsize);
3276   }
3277                                      
3278   // Use the TOC to generate the destination address
3279   insnCodeGen::loadImmIntoReg(gen, TOCreg, dest);
3280   insnCodeGen::generateMoveToLR(gen, TOCreg);
3281   
3282   // Load the callee TOC
3283   insnCodeGen::loadImmIntoReg(gen, TOCreg, callee_toc);
3284   
3285   instruction branch_insn(BRLraw);
3286   insnCodeGen::generate(gen, branch_insn);
3287
3288   if (!call) {
3289     insnCodeGen::generateMemAccess64(gen, LDop, LDxop,
3290                                      TOCreg, REG_SP, 3*wordsize);
3291     insnCodeGen::generateMoveToLR(gen, TOCreg);
3292   }  
3293
3294   insnCodeGen::loadImmIntoReg(gen, TOCreg, caller_toc);
3295
3296   if (!call) {
3297     instruction ret(BRraw);
3298     insnCodeGen::generate(gen, ret);
3299   }
3300   
3301   return true;
3302 }
3303
3304 // TODO 32/64-bit? 
3305 bool EmitterPOWER64Stat::emitPLTCall(func_instance *callee, codeGen &gen) {
3306   return emitPLTCommon(callee, true, gen);
3307 }
3308
3309 bool EmitterPOWER64Stat::emitPLTJump(func_instance *callee, codeGen &gen) {
3310   return emitPLTCommon(callee, false, gen);
3311 }
3312
3313 bool EmitterPOWER64Stat::emitTOCCall(block_instance *block, codeGen &gen) {
3314   return emitTOCCommon(block, true, gen);
3315 }
3316
3317 bool EmitterPOWER64Stat::emitTOCJump(block_instance *block, codeGen &gen) {
3318   return emitTOCCommon(block, false, gen);
3319 }
3320
3321 bool EmitterPOWER64Stat::emitTOCCommon(block_instance *block, bool call, codeGen &gen) {
3322   // Right now we can only jump to a block if it's the entry of a function
3323   // since it needs a relocation entry, which implies symbols, which implies... a function.
3324   // Theoretically, we could create symbols for this block, if anyone ever cares.
3325   std::vector<func_instance *> funcs;
3326   block->getFuncs(std::back_inserter(funcs));
3327   for (unsigned i = 0; i < funcs.size(); ++i) {
3328     if (block == funcs[i]->entry()) {
3329       return emitPLTCommon(funcs[i], call, gen);
3330     }
3331   }
3332   return false;
3333 }
3334
3335 bool EmitterPOWER64Stat::emitCallInstruction(codeGen &gen,
3336                                              func_instance *callee,
3337                                              bool setTOC, Address) {
3338     // if the TOC changes, generate a PIC call
3339
3340     Address dest =  callee->addr();
3341     if( dest == 0)
3342         dest = getInterModuleFuncAddr(callee, gen);
3343
3344  
3345
3346     if (setTOC) {
3347         return emitPLTCall(callee, gen);
3348     }
3349
3350     insnCodeGen::generateCall(gen, gen.currAddr(), dest);
3351     return true;
3352 }
3353
3354 // Generates call instruction sequence for all POWER-based systems
3355 // under dynamic instrumentation.
3356 //
3357 // This should be able to stomp on the link register (LR) and TOC
3358 // register (r2), as they were saved by Emitter::emitCall() as necessary.
3359 bool EmitterPOWER::emitCallInstruction(codeGen &gen, func_instance *callee, bool setTOC, Address toc_anchor) {
3360
3361     bool needLongBranch = false;
3362     if (gen.startAddr() == (Address) -1) { // Unset...
3363         needLongBranch = true;
3364         inst_printf("Unknown generation addr, long call required\n");
3365     }
3366     else {
3367         long displacement = callee->addr() - gen.currAddr();
3368         // Increase the displacement to be conservative. 
3369         // We use fewer than 6 instructions, too. But again,
3370         // conservative.
3371
3372         if ((ABS(displacement) + 6*instruction::size()) > MAX_BRANCH) {
3373             needLongBranch = true;
3374             inst_printf("Need long call to get from 0x%lx to 0x%lx\n",
3375                     gen.currAddr(), callee->addr());
3376         }
3377     }
3378
3379     // Need somewhere to put the destination calculation...
3380     int scratchReg = 0;
3381     if (needLongBranch) {
3382         // Use scratchReg to set destination of the call...
3383         emitVload(loadConstOp, callee->addr(), scratchReg, scratchReg, gen, false);
3384         insnCodeGen::generateMoveToLR(gen, scratchReg);
3385         inst_printf("Generated LR value in %d\n", scratchReg);
3386     }
3387
3388
3389     // Linux 64
3390     if (setTOC) {
3391         // Set up the new TOC value
3392         emitVload(loadConstOp, toc_anchor, 2, 2, gen, false);
3393         //inst_printf("toc setup (%d)...");
3394         inst_printf("Set new TOC\n");
3395     }
3396
3397     // ALL dynamic; call instruction generation
3398     if (needLongBranch) {
3399         instruction brl(BRLraw);
3400         insnCodeGen::generate(gen,brl);
3401         inst_printf("Generated BRL\n");
3402     }
3403     else {
3404         insnCodeGen::generateCall(gen, gen.currAddr(), callee->addr());
3405         inst_printf("Generated short call from 0x%lx to 0x%lx\n",
3406                 gen.currAddr(), callee->addr());
3407     }
3408
3409     return true;
3410 }
3411
3412 void EmitterPOWER::emitLoadShared(opCode op, Register dest, const image_variable* var, bool is_local, int size, codeGen &gen, Address offset)
3413 {
3414    // create or retrieve jump slot
3415    Address addr;
3416    int stackSize = 0;
3417
3418    if(var == NULL) {
3419       addr = offset;
3420    }
3421    else if(!is_local) {
3422       addr = getInterModuleVarAddr(var, gen);
3423    }
3424    else {
3425       addr = (Address)var->getOffset();
3426    }
3427
3428    // load register with address from jump slot
3429
3430    inst_printf("emitLoadShared addr 0x%lx curr adress 0x%lx offset %ld 0x%lx size %d\n", 
3431         addr, gen.currAddr(), addr - gen.currAddr()+4, addr - gen.currAddr()+4, size);
3432    Register scratchReg = gen.rs()->getScratchRegister(gen, true);
3433
3434    if (scratchReg == REG_NULL) {
3435         pdvector<Register> freeReg;
3436         pdvector<Register> excludeReg;
3437         stackSize = insnCodeGen::createStackFrame(gen, 1, freeReg, excludeReg);
3438         assert (stackSize == 1);
3439         scratchReg = freeReg[0];
3440         inst_printf("emitLoadrelative - after new stack frame - addr 0x%lx curr adress 0x%lx offset %ld 0x%lx size %d\n", 
3441                 addr, gen.currAddr(), addr - gen.currAddr()+4, addr - gen.currAddr()+4, size);
3442    }
3443
3444    emitMovePCToReg(scratchReg, gen);
3445    Address varOffset = addr - gen.currAddr()+4;
3446    
3447    if (op ==loadOp) {
3448         if(!is_local && (var != NULL)){
3449
3450           emitLoadRelative(dest, varOffset, scratchReg, gen.width(), gen);
3451           // Deference the pointer to get the variable
3452           emitLoadRelative(dest, 0, dest, size, gen);
3453         } else {
3454
3455           emitLoadRelative(dest, varOffset, scratchReg, size, gen);
3456         }
3457    } else { //loadConstop
3458      if(!is_local && (var != NULL)){
3459
3460        emitLoadRelative(dest, varOffset, scratchReg, gen.width(), gen);
3461      } else {
3462
3463        // Move address of the variable into the register - load effective address
3464        //dest = effective address of pc+offset ;
3465        insnCodeGen::generateImm (gen, CAUop, dest, 0, BOT_HI (varOffset));
3466        insnCodeGen::generateImm (gen, ORILop, dest, dest, BOT_LO (varOffset));
3467        insnCodeGen::generateAddReg (gen, CAXop, dest, dest, scratchReg);
3468      }
3469    }
3470    
3471    if (stackSize > 0)
3472         insnCodeGen::removeStackFrame(gen);
3473
3474   return;
3475 }
3476
3477 void EmitterPOWER::emitStoreShared(Register source, const image_variable * var, bool is_local, int size, codeGen & gen)
3478 {
3479    // create or retrieve jump slot
3480    Address addr;
3481    int stackSize = 0;
3482    if(!is_local) {
3483       addr = getInterModuleVarAddr(var, gen);