1. Fix x86-64 codegen for binary operators with 64-bit imm values
[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     if (!p->writeDataSpace((void *)loc, instruction::size(), i.ptr()))
706         fprintf(stderr, "%s[%d]:  writeDataSpace failed\n", FILE__, __LINE__);
707 }
708
709 void saveRegisterAtOffset(codeGen &gen,
710                           Register reg,
711                           int save_off) {
712     if (gen.width() == 4) {
713         insnCodeGen::generateImm(gen, STop,
714                                  reg, REG_SP, save_off);
715     } else /* gen.width() == 8 */ {
716         insnCodeGen::generateMemAccess64(gen, STDop, STDxop,
717                                          reg, REG_SP, save_off);
718     }
719 }
720
721 // Dest != reg : optimizate away a load/move pair
722 void saveRegister(codeGen &gen,
723                   Register source,
724                   Register dest,
725                   int save_off)
726 {
727     saveRegisterAtOffset(gen, source, save_off + (dest * gen.width()));
728     //  bperr("Saving reg %d at 0x%x off the stack\n", reg, offset + reg*GPRSIZE);
729 }
730
731 void saveRegister(codeGen &gen,
732                   Register reg,
733                   int save_off)
734 {
735     saveRegister(gen, reg, reg, save_off);
736 }
737
738 void restoreRegisterAtOffset(codeGen &gen,
739                              Register dest,
740                              int saved_off) {
741     if (gen.width() == 4) {
742         insnCodeGen::generateImm(gen, Lop, 
743                                  dest, REG_SP, saved_off);
744     } else /* gen.width() == 8 */ {
745         insnCodeGen::generateMemAccess64(gen, LDop, LDxop,
746                                          dest, REG_SP, saved_off);
747     }
748 }
749
750 // Dest != reg : optimizate away a load/move pair
751 void restoreRegister(codeGen &gen,
752                      Register source,
753                      Register dest, 
754                      int saved_off)
755 {
756     return restoreRegisterAtOffset(gen, dest, saved_off + (source * gen.width()));
757     //bperr( "Loading reg %d (into reg %d) at 0x%x off the stack\n", 
758     //  reg, dest, offset + reg*GPRSIZE);
759 }
760
761 void restoreRegister(codeGen &gen,
762                      Register reg,
763                      int save_off)
764 {
765     restoreRegister(gen, reg, reg, save_off);
766 }
767
768 void saveFPRegister(codeGen &gen, 
769                     Register reg,
770                     int save_off)
771 {
772     assert("WE SHOULD NOT BE HERE" == 0);
773
774     insnCodeGen::generateImm(gen, STFDop, 
775                              reg, REG_SP, save_off + reg*FPRSIZE);
776     //fprintf(stderr, "Save offset: %d\n", save_off + reg*FPRSIZE);
777     //bperr( "Saving FP reg %d at 0x%x off the stack\n", 
778     //  reg, offset + reg*FPRSIZE);
779 }
780
781 void restoreFPRegister(codeGen &gen,
782                        Register source,
783                        Register dest,
784                        int save_off)
785 {
786     assert("WE SHOULD NOT BE HERE" == 0);
787     
788     insnCodeGen::generateImm(gen, LFDop, 
789                              dest, REG_SP, save_off + source*FPRSIZE);
790     //  bperr("Loading FP reg %d (into %d) at 0x%x off the stack\n", 
791     //  reg, dest, offset + reg*FPRSIZE);
792 }
793
794 void restoreFPRegister(codeGen &gen,
795                        Register reg,
796                        int save_off)
797 {
798     restoreFPRegister(gen, reg, reg, save_off);
799 }       
800
801 /*
802  * Emit code to push down the stack, AST-generate style
803  */
804 void pushStack(codeGen &gen)
805 {
806     if (gen.width() == 4) {
807         insnCodeGen::generateImm(gen, STUop,
808                                  REG_SP, REG_SP, -TRAMP_FRAME_SIZE_32);
809     } else /* gen.width() == 8 */ {
810         insnCodeGen::generateMemAccess64(gen, STDop, STDUxop,
811                                   REG_SP, REG_SP, -TRAMP_FRAME_SIZE_64);
812     }
813 }
814
815 void popStack(codeGen &gen)
816 {
817     if (gen.width() == 4) {
818         insnCodeGen::generateImm(gen, CALop, 
819                                  REG_SP, REG_SP, TRAMP_FRAME_SIZE_32);
820
821     } else /* gen.width() == 8 */ {
822         insnCodeGen::generateImm(gen, CALop,
823                                  REG_SP, REG_SP, TRAMP_FRAME_SIZE_64);
824     }
825 }
826
827 /*
828  * Save necessary registers on the stack
829  * insn, base: for code generation. Offset: regs saved at offset + reg
830  * Returns: number of registers saved.
831  * Side effects: instruction pointer and base param are shifted to 
832  *   next free slot.
833  */
834 unsigned saveGPRegisters(codeGen &gen,
835                          registerSpace *theRegSpace,
836                          int save_off, int numReqGPRs)
837 {
838     int numRegs = 0;
839     if (numReqGPRs == -1 ) numReqGPRs = theRegSpace->numGPRs();
840     for(int i = 0; i < theRegSpace->numGPRs(); i++) {
841         registerSlot *reg = theRegSpace->GPRs()[i];
842         if (reg->liveState == registerSlot::live) {
843             saveRegister(gen, reg->encoding(), save_off);
844             // saveRegister implicitly adds in (reg * word size)
845             // Do that by hand here.
846             
847             int actual_save_off = save_off;
848
849             actual_save_off += (reg->encoding() * gen.width());
850
851             gen.rs()->markSavedRegister(reg->number, actual_save_off);
852             numRegs++;
853             if (numRegs == numReqGPRs) break;
854         }
855     }
856     return numRegs;
857 }
858
859 /*
860  * Restore necessary registers from the stack
861  * insn, base: for code generation. Offset: regs restored from offset + reg
862  * Returns: number of registers restored.
863  * Side effects: instruction pointer and base param are shifted to 
864  *   next free slot.
865  */
866
867 unsigned restoreGPRegisters(codeGen &gen,
868                             registerSpace *theRegSpace,
869                             int save_off)
870 {
871     unsigned numRegs = 0;
872     for(int i = 0; i < theRegSpace->numGPRs(); i++) {
873         registerSlot *reg = theRegSpace->GPRs()[i];
874         if (reg->liveState == registerSlot::spilled) {
875             restoreRegister(gen, reg->encoding(), save_off);
876             numRegs++;
877         }
878     }
879
880     return numRegs;
881 }
882
883 /*
884  * Save FPR registers on the stack. (0-13)
885  * insn, base: for code generation. Offset: regs saved at offset + reg
886  * Returns: number of regs saved.
887  */
888
889 unsigned saveFPRegisters(codeGen &gen,
890                          registerSpace * theRegSpace,
891                          int save_off)
892 {
893   unsigned numRegs = 0;
894   insnCodeGen::saveVectors(gen, save_off);
895
896   // for(int i = 0; i < theRegSpace->numFPRs(); i++) {
897   //     registerSlot *reg = theRegSpace->FPRs()[i];
898   //     if (reg->liveState == registerSlot::live) {
899   //         saveFPRegister(gen, reg->encoding(), save_off);
900   //         reg->liveState = registerSlot::spilled;
901   //         numRegs++;
902   //     }
903   // }  
904   
905   return 32;
906 }
907
908 /*
909  * Restore FPR registers from the stack. (0-13)
910  * insn, base: for code generation. Offset: regs restored from offset + reg
911  * Returns: number of regs restored.
912  */
913
914 unsigned restoreFPRegisters(codeGen &gen, 
915                             registerSpace *theRegSpace,
916                             int save_off)
917 {
918   
919   unsigned numRegs = 0;
920   insnCodeGen::restoreVectors(gen, save_off);
921   // for(int i = 0; i < theRegSpace->numFPRs(); i++) {
922   //     registerSlot *reg = theRegSpace->FPRs()[i];
923   //     if (reg->liveState == registerSlot::spilled) {
924   //         restoreFPRegister(gen, reg->encoding(), save_off);
925   //         numRegs++;
926   //     }
927   // }
928   
929   return 32;
930 }
931
932 /*
933  * Save the special purpose registers (for Dyninst conservative tramp)
934  * CTR, CR, XER, SPR0, FPSCR
935  */
936 unsigned saveSPRegisters(codeGen &gen,
937                          registerSpace *,
938                          int save_off,
939                          int force_save)
940 {
941     unsigned num_saved = 0;
942     int cr_off, ctr_off, xer_off, spr0_off, fpscr_off;
943     
944     if (gen.width() == 4) {
945         cr_off    = STK_CR_32;
946         ctr_off   = STK_CTR_32;
947         xer_off   = STK_XER_32;
948         fpscr_off = STK_FP_CR_32;
949         spr0_off  = STK_SPR0_32;
950     } else /* gen.width() == 8 */ {
951         cr_off    = STK_CR_64;
952         ctr_off   = STK_CTR_64;
953         xer_off   = STK_XER_64;
954         fpscr_off = STK_FP_CR_64;
955         spr0_off  = STK_SPR0_64;
956     }
957
958     registerSlot *regCR = (*(gen.rs()))[registerSpace::cr]; 
959     assert (regCR != NULL); 
960     if (force_save || regCR->liveState == registerSlot::live) 
961     {
962     saveCR(gen, 10, save_off + cr_off); num_saved++;
963     gen.rs()->markSavedRegister(registerSpace::cr, save_off + cr_off);
964     }
965     registerSlot *regCTR = (*(gen.rs()))[registerSpace::ctr]; 
966     assert (regCTR != NULL); 
967     if (force_save || regCTR->liveState == registerSlot::live) 
968     {
969     saveSPR(gen, 10, SPR_CTR, save_off + ctr_off); num_saved++;
970     gen.rs()->markSavedRegister(registerSpace::ctr, save_off + ctr_off);
971     }
972
973     registerSlot *regXER = (*(gen.rs()))[registerSpace::xer]; 
974     assert (regXER != NULL); 
975     if (force_save || regXER->liveState == registerSlot::live) 
976    {
977     saveSPR(gen, 10, SPR_XER, save_off + xer_off); num_saved++;
978     gen.rs()->markSavedRegister(registerSpace::xer, save_off + xer_off);
979     }
980
981     saveFPSCR(gen, 10, save_off + fpscr_off); num_saved++;
982
983     return num_saved;
984 }
985
986 /*
987  * Restore the special purpose registers (for Dyninst conservative tramp)
988  * CTR, CR, XER, SPR0, FPSCR
989  */
990
991 unsigned restoreSPRegisters(codeGen &gen,
992                             registerSpace *,
993                             int save_off,
994                             int force_save)
995 {
996     int cr_off, ctr_off, xer_off, spr0_off, fpscr_off;
997     unsigned num_restored = 0;
998
999     if (gen.width() == 4) {
1000         cr_off    = STK_CR_32;
1001         ctr_off   = STK_CTR_32;
1002         xer_off   = STK_XER_32;
1003         fpscr_off = STK_FP_CR_32;
1004         spr0_off  = STK_SPR0_32;
1005     } else /* gen.width() == 8 */ {
1006         cr_off    = STK_CR_64;
1007         ctr_off   = STK_CTR_64;
1008         xer_off   = STK_XER_64;
1009         fpscr_off = STK_FP_CR_64;
1010         spr0_off  = STK_SPR0_64;
1011     }
1012
1013     registerSlot *regCR = (*(gen.rs()))[registerSpace::cr]; 
1014     assert (regCR != NULL); 
1015     if (force_save || regCR->liveState == registerSlot::spilled) 
1016     {
1017     restoreCR(gen, 10, save_off + cr_off); num_restored++;
1018     }
1019     registerSlot *regCTR = (*(gen.rs()))[registerSpace::ctr]; 
1020     assert (regCTR != NULL); 
1021     if (force_save || regCTR->liveState == registerSlot::spilled) 
1022     {
1023     restoreSPR(gen, 10, SPR_CTR, save_off + ctr_off); num_restored++;
1024     }
1025     registerSlot *regXER = (*(gen.rs()))[registerSpace::xer]; 
1026     assert (regXER != NULL); 
1027     if (force_save || regXER->liveState == registerSlot::spilled) 
1028     {
1029     restoreSPR(gen, 10, SPR_XER, save_off + xer_off); num_restored++;
1030     }
1031     restoreFPSCR(gen, 10, save_off + fpscr_off); num_restored++;
1032
1033     return num_restored;
1034 }
1035
1036
1037 bool baseTramp::generateSaves(codeGen &gen,
1038                               registerSpace *)
1039 {
1040     regalloc_printf("========== baseTramp::generateSaves\n");
1041     unsigned int width = gen.width();
1042
1043     int gpr_off, fpr_off;
1044     gpr_off = TRAMP_GPR_OFFSET(width);
1045     fpr_off = TRAMP_FPR_OFFSET(width);
1046
1047     // Make a stack frame.
1048     pushStack(gen);
1049
1050     // Save GPRs
1051     saveGPRegisters(gen, gen.rs(), gpr_off);
1052
1053     if(BPatch::bpatch->isSaveFPROn() ||  // Save FPRs
1054         BPatch::bpatch->isForceSaveFPROn() ) 
1055         saveFPRegisters(gen, gen.rs(), fpr_off);
1056
1057     // Save LR            
1058     saveLR(gen, REG_SCRATCH /* register to use */, TRAMP_SPR_OFFSET(width) + STK_LR);
1059
1060     saveSPRegisters(gen, gen.rs(), TRAMP_SPR_OFFSET(width), true); // FIXME get liveness fixed
1061     return true;
1062 }
1063
1064 bool baseTramp::generateRestores(codeGen &gen,
1065                                  registerSpace *)
1066 {
1067     unsigned int width = gen.width();
1068
1069     regalloc_printf("========== baseTramp::generateRestores\n");
1070
1071     int gpr_off, fpr_off;
1072     gpr_off = TRAMP_GPR_OFFSET(width);
1073     fpr_off = TRAMP_FPR_OFFSET(width);
1074
1075     // Restore possible SPR saves
1076     restoreSPRegisters(gen, gen.rs(), TRAMP_SPR_OFFSET(width), false);
1077
1078     // LR
1079     restoreLR(gen, REG_SCRATCH, TRAMP_SPR_OFFSET(width) + STK_LR);
1080
1081     if (BPatch::bpatch->isSaveFPROn() || // FPRs
1082         BPatch::bpatch->isForceSaveFPROn() ) 
1083         restoreFPRegisters(gen, gen.rs(), fpr_off);
1084
1085     // GPRs
1086     restoreGPRegisters(gen, gen.rs(), gpr_off);
1087
1088     /*
1089     // Multithread GPR -- always save
1090     restoreRegister(gen, REG_MT_POS, TRAMP_GPR_OFFSET);
1091     */
1092
1093     popStack(gen);
1094
1095     return true;
1096 }
1097
1098
1099 void emitImm(opCode op, Register src1, RegValue src2imm, Register dest, 
1100              codeGen &gen, bool noCost, registerSpace * /* rs */)
1101 {
1102         //bperr("emitImm(op=%d,src=%d,src2imm=%d,dest=%d)\n",
1103         //        op, src1, src2imm, dest);
1104     int iop=-1;
1105     int result=-1;
1106     switch (op) {
1107         // integer ops
1108     case plusOp:
1109         iop = CALop;
1110         insnCodeGen::generateImm(gen, iop, dest, src1, src2imm);
1111         return;
1112         break;
1113         
1114     case minusOp:
1115         iop = SIop;
1116         insnCodeGen::generateImm(gen, iop, dest, src1, src2imm);
1117         return;
1118         break;
1119         
1120     case timesOp:
1121        if (isPowerOf2(src2imm,result) && (result < (int) (gen.width() * 8))) {
1122             insnCodeGen::generateLShift(gen, src1, result, dest);
1123             return;
1124         }
1125         else {
1126             Register dest2 = gen.rs()->getScratchRegister(gen, noCost);
1127             emitVload(loadConstOp, src2imm, dest2, dest2, gen, noCost);
1128             emitV(op, src1, dest2, dest, gen, noCost);
1129             return;
1130         }
1131         break;
1132         
1133     case divOp:
1134         if (isPowerOf2(src2imm,result) && (result < (int) (gen.width() * 8))) {
1135             insnCodeGen::generateRShift(gen, src1, result, dest);
1136             return;
1137         }
1138         else {
1139             Register dest2 = gen.rs()->getScratchRegister(gen, noCost);
1140             emitVload(loadConstOp, src2imm, dest2, dest2, gen, noCost);
1141             emitV(op, src1, dest2, dest, gen, noCost);
1142             return;
1143         }
1144         break;
1145         
1146         // Bool ops
1147     case orOp:
1148         iop = ORILop;
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         
1154     case andOp:
1155         iop = ANDILop;
1156         // For some reason, the destField is 2nd for ORILop and ANDILop
1157         insnCodeGen::generateImm(gen, iop, src1, dest, src2imm);
1158         return;
1159         break;
1160     default:
1161         Register dest2 = gen.rs()->getScratchRegister(gen, noCost);
1162         emitVload(loadConstOp, src2imm, dest2, dest2, gen, noCost);
1163         emitV(op, src1, dest2, dest, gen, noCost);
1164         return;
1165         break;
1166     }
1167 }
1168
1169
1170 /* Recursive function that goes to where our instrumentation is calling
1171 to figure out what registers are clobbered there, and in any function
1172 that it calls, to a certain depth ... at which point we clobber everything
1173
1174 Update-12/06, njr, since we're going to a cached system we are just going to 
1175 look at the first level and not do recursive, since we would have to also
1176 store and reexamine every call out instead of doing it on the fly like before*/
1177 bool EmitterPOWER::clobberAllFuncCall( registerSpace *rs,
1178                                        func_instance * callee)
1179                    
1180 {
1181   unsigned i;
1182   if (!callee) return true;
1183
1184   stats_codegen.startTimer(CODEGEN_LIVENESS_TIMER);
1185     
1186   /* usedRegs does calculations if not done before and returns
1187      whether or not the callee is a leaf function.
1188      if it is, we use the register info we gathered,
1189      otherwise, we punt and save everything */
1190   //     bool isLeafFunc = callee->ifunc()->usedRegs();
1191
1192   if (callee->ifunc()->isLeafFunc()) {
1193       std::set<Register> * gprs = callee->ifunc()->usedGPRs();
1194       std::set<Register>::iterator It = gprs->begin();
1195       for(i = 0; i < gprs->size(); i++) {
1196           //while (It != gprs->end()){
1197           rs->GPRs()[*(It++)]->beenUsed = true;
1198       }
1199       
1200       std::set<Register> * fprs = callee->ifunc()->usedFPRs();
1201       std::set<Register>::iterator It2 = fprs->begin();
1202       for(i = 0; i < fprs->size(); i++)
1203       {
1204           //while (It2 != fprs->end()){
1205           rs->FPRs()[*(It2++)]->beenUsed = true;
1206       }
1207     }
1208   else {
1209       for (int i = 0; i < rs->numGPRs(); i++) {
1210           rs->GPRs()[i]->beenUsed = true;
1211       }
1212       for (int i = 0; i < rs->numFPRs(); i++) {
1213           rs->FPRs()[i]->beenUsed = true;
1214       }
1215   }
1216   stats_codegen.stopTimer(CODEGEN_LIVENESS_TIMER);
1217   return false;
1218 }
1219
1220
1221 //
1222 // Author: Jeff Hollingsworth (3/26/96)
1223 //
1224 // Emit a function call.
1225 //   It saves registers as needed.
1226 //   copy the passed arguments into the canonical argument registers (r3-r10)
1227 //   64-bit ELF Linux ONLY: 
1228 //     Locate the TOC entry of the callee module and copy it into R2
1229 //   generate a branch and link the destination
1230 //   64-bit ELF Linux ONLY:
1231 //     Restore the original TOC into R2
1232 //   restore the saved registers.
1233 //
1234 // Parameters:
1235 //   op - unused parameter (to be compatible with sparc)
1236 //   srcs - vector of ints indicating the registers that contain the parameters
1237 //   dest - the destination address (should be Address not reg). 
1238 //   insn - pointer to the code we are generating
1239 //   based - offset into the code generated.
1240 //
1241
1242 Register emitFuncCall(opCode, codeGen &, pdvector<AstNodePtr> &, bool, Address) {
1243         assert(0);
1244         return 0;
1245 }
1246
1247 Register emitFuncCall(opCode op,
1248                       codeGen &gen,
1249                       pdvector<AstNodePtr> &operands, bool noCost,
1250                       func_instance *callee) {
1251     //fprintf(stderr, "[DEBUG_CRAP] Generaating function call to %p\n", callee->entryBlock()->GetBlockStartingAddress());
1252     return gen.emitter()->emitCall(op, gen, operands, noCost, callee);
1253 }
1254
1255 void EmitterPOWER::emitCallWithSaves(codeGen &gen, Address dest, bool saveToc, bool saveLR, bool saveR12) {
1256     // Save the values onto the stack.... (might be needed).
1257     if (saveToc) {}
1258     if (saveLR) {}
1259     if (saveR12) {}
1260
1261     emitVload(loadConstOp, dest, 0, 0, gen, false);
1262     insnCodeGen::generateMoveToLR(gen, 0);
1263     emitVload(loadConstOp, dest, 12, 12, gen, false);
1264     instruction brl(BRLraw);
1265     insnCodeGen::generate(gen,brl);
1266     inst_printf("Generated BRL\n");
1267     // Retore the original
1268     if (saveToc) {}
1269     if (saveLR) {}
1270     if (saveR12) {}
1271 }
1272
1273
1274 Register EmitterPOWER::emitCallReplacement(opCode ocode,
1275                                            codeGen &gen,
1276                                            bool /* noCost */,
1277                                            func_instance *callee) {
1278     // This takes care of the special case where we are replacing an existing
1279     // linking branch instruction.
1280     //
1281     // This code makes two crucial assumptions:
1282     // 1) LR is free: Linking branch instructions place pre-branch IP in LR.
1283     // 2) TOC (r2) is free: r2 should hold TOC of destination.  So use it
1284     //    as scratch, and set it to destination module's TOC upon return.
1285     //    This works for both the inter and intra module call cases.
1286     // In the 32-bit case where we can't use r2, stomp on r0 and pray...
1287
1288     //  Sanity check for opcode.
1289     assert(ocode == funcJumpOp);
1290
1291     Register freeReg = 0;
1292     instruction mtlr(MTLR0raw);
1293
1294     // 64-bit Mutatees
1295     if (gen.addrSpace()->proc()->getAddressWidth() == 8) {
1296         freeReg = 2;
1297         mtlr = instruction(MTLR2raw);
1298     }
1299
1300     // Load register with address.
1301     emitVload(loadConstOp, callee->addr(), freeReg, freeReg, gen, false);
1302
1303     // Move to link register.
1304     insnCodeGen::generate(gen,mtlr);
1305
1306     Address toc_new = gen.addrSpace()->proc()->getTOCoffsetInfo(callee);
1307     if (toc_new) {
1308         // Set up the new TOC value
1309         emitVload(loadConstOp, toc_new, freeReg, freeReg, gen, false);
1310     }
1311
1312     // blr - branch through the link reg.
1313     instruction blr(BRraw);
1314     insnCodeGen::generate(gen,blr);
1315
1316     func_instance *caller = gen.point()->func();
1317     Address toc_orig = gen.addrSpace()->proc()->getTOCoffsetInfo(caller);
1318     if (toc_new) {
1319         // Restore the original TOC value.
1320         emitVload(loadConstOp, toc_orig, freeReg, freeReg, gen, false);
1321     }
1322
1323     // What to return here?
1324     return REG_NULL;
1325 }
1326
1327
1328 // Register EmitterPOWER::emitCallReplacementLR(opCode ocode,
1329 //                                            codeGen &gen,
1330 //                                            bool /* noCost */,
1331 //                                            func_instance *callee) {
1332 //     // This takes care of the special case where we are replacing an existing
1333 //     // linking branch instruction.
1334 //     //
1335 //     // This code makes two crucial assumptions:
1336 //     // 1) LR is free: Linking branch instructions place pre-branch IP in LR.
1337 //     // 2) TOC (r2) is free: r2 should hold TOC of destination.  So use it
1338 //     //    as scratch, and set it to destination module's TOC upon return.
1339 //     //    This works for both the inter and intra module call cases.
1340 //     // In the 32-bit case where we can't use r2, stomp on r0 and pray...
1341
1342 //     //  Sanity check for opcode.
1343 //     assert(ocode == funcJumpOp);
1344
1345 //     Register freeReg = 0;
1346 //     instruction mtlr(MTLR0raw);
1347
1348 //     // 64-bit Mutatees
1349 //     if (gen.addrSpace()->proc()->getAddressWidth() == 8) {
1350 //         freeReg = 2;
1351 //         mtlr = instruction(MTLR2raw);
1352 //     }
1353
1354 //     // Load register with address.
1355 //     emitVload(loadConstOp, callee->addr(), freeReg, freeReg, gen, false);
1356
1357 //     // Move to link register.
1358 //     insnCodeGen::generate(gen,mtlr);
1359
1360 //     Address toc_new = gen.addrSpace()->proc()->getTOCoffsetInfo(callee);
1361 //     if (toc_new) {
1362 //         // Set up the new TOC value
1363 //         emitVload(loadConstOp, toc_new, freeReg, freeReg, gen, false);
1364 //     }
1365
1366 //     // blr - branch through the link reg.
1367 //     instruction blr(BRraw);
1368 //     insnCodeGen::generate(gen,blr);
1369
1370 //     func_instance *caller = gen.point()->func();
1371 //     Address toc_orig = gen.addrSpace()->proc()->getTOCoffsetInfo(caller);
1372 //     if (toc_new) {
1373 //         // Restore the original TOC value.
1374 //         emitVload(loadConstOp, toc_orig, freeReg, freeReg, gen, false);
1375 //     }
1376
1377 //     // What to return here?
1378 //     return REG_NULL;
1379 // }
1380 // There are four "axes" going on here:
1381 // 32 bit vs 64 bit  
1382 // Instrumentation vs function call replacement
1383 // Static vs. dynamic 
1384
1385 Register EmitterPOWER::emitCall(opCode ocode,
1386                                 codeGen &gen,
1387                                 const pdvector<AstNodePtr> &operands,
1388                                 bool noCost,
1389                                 func_instance *callee) {
1390     bool inInstrumentation = true;
1391
1392     //fprintf(stderr, "[EmitterPOWER::emitCall] making call to: %llx\n", callee-> );
1393     // If inInstrumentation is true we're in instrumentation;
1394     // if false we're in function call replacement
1395
1396     //fprintf(stderr, "%s %p\n", "[DEBUG_CRAP] In emit call for ", callee->entryBlock()->GetBlockStartingAddress());
1397     if (ocode == funcJumpOp)
1398         return emitCallReplacement(ocode, gen, noCost, callee);
1399
1400     //  Sanity check for NULL address argument
1401     if (!callee) {
1402         char msg[256];
1403         sprintf(msg, "%s[%d]:  internal error:  emitFuncCall called w/out"
1404                 "callee argument", __FILE__, __LINE__);
1405         showErrorCallback(80, msg);
1406         assert(0);
1407     }
1408
1409     // Now that we have the destination address (unique, hopefully) 
1410     // get the TOC anchor value for that function
1411     // The TOC offset is stored in the Object. 
1412     // file() -> pdmodule "parent"
1413     // exec() -> image "parent"
1414  
1415     Address toc_anchor = 0;
1416     Address caller_toc = 0;
1417     pdvector <Register> srcs;
1418
1419     // Linux, 64, static/dynamic, inst/repl
1420     // DYN
1421     toc_anchor = gen.addrSpace()->getTOCoffsetInfo(callee);
1422     
1423     // Instead of saving the TOC (if we can't), just reset it afterwards.
1424     if (gen.func()) {
1425 //      fprintf(stderr, "info: %s:%d: \n", __FILE__, __LINE__); 
1426       caller_toc = gen.addrSpace()->getTOCoffsetInfo(gen.func());
1427     }
1428     else if (gen.point()) {
1429       //fprintf(stderr, "info: %s:%d: \n", __FILE__, __LINE__);
1430       caller_toc = gen.addrSpace()->getTOCoffsetInfo(gen.point()->func());
1431     }
1432     else {
1433       // Don't need it, and this might be an iRPC
1434     }
1435     
1436     inst_printf("Caller TOC 0x%lx; callee 0x%lx\n",
1437                 caller_toc, toc_anchor);
1438     // ALL
1439     bool needToSaveLR = false;
1440     registerSlot *regLR = (*(gen.rs()))[registerSpace::lr];
1441     if (regLR && regLR->liveState == registerSlot::live) {
1442         needToSaveLR = true;
1443         //fprintf(stderr, "info: %s:%d: \n", __FILE__, __LINE__);
1444         inst_printf("... need to save LR\n");
1445     }
1446
1447     // Note: For 32-bit ELF PowerPC Linux (and other SYSV ABI followers)
1448     // r2 is described as "reserved for system use and is not to be 
1449     // changed by application code".
1450     // On these platforms, we return 0 when getTOCoffsetInfo is called.
1451
1452     pdvector<int> savedRegs;
1453
1454     //  Save the link register.
1455     // mflr r0
1456     // Linux, 32/64, stat/dynamic, instrumentation
1457     if (needToSaveLR) {
1458         //fprintf(stderr, "info: %s:%d: \n", __FILE__, __LINE__);
1459         assert(inInstrumentation);
1460         insnCodeGen::generateMoveFromLR(gen, 0);
1461         saveRegister(gen, 0, FUNC_CALL_SAVE(gen.width()));
1462         savedRegs.push_back(0);
1463         inst_printf("saved LR in 0\n");
1464     }
1465
1466     if (inInstrumentation &&
1467         (toc_anchor != caller_toc)) {
1468         // Save register 2 (TOC)
1469         //fprintf(stderr, "info: %s:%d: \n", __FILE__, __LINE__); 
1470       saveRegister(gen, 2, FUNC_CALL_SAVE(gen.width()));
1471         savedRegs.push_back(2);
1472     }
1473
1474     // see what others we need to save.
1475     for (int i = 0; i < gen.rs()->numGPRs(); i++) {
1476         //fprintf(stderr, "info: %s:%d: \n", __FILE__, __LINE__);
1477        registerSlot *reg = gen.rs()->GPRs()[i];
1478
1479        // We must save if:
1480        // refCount > 0 (and not a source register)
1481        // keptValue == true (keep over the call)
1482        // liveState == live (technically, only if not saved by the callee) 
1483        
1484        if (inInstrumentation &&
1485            ((reg->refCount > 0) || 
1486             reg->keptValue ||
1487             (reg->liveState == registerSlot::live))) {
1488         //fprintf(stderr, "info: %s:%d: Register: %d \n", __FILE__, __LINE__, reg->number); 
1489          saveRegister(gen, reg->number, FUNC_CALL_SAVE(gen.width()));
1490           savedRegs.push_back(reg->number);
1491        }
1492     }
1493
1494     // Generate the code for all function parameters, and keep a list
1495     // of what registers they're in.
1496     for (unsigned u = 0; u < operands.size(); u++) {
1497     // Note: if we're in function replacement, we can assert operands.empty()
1498 /*
1499         if (operands[u]->getSize() == 8) {
1500             // What does this do?
1501             bperr( "in weird code\n");
1502             Register dummyReg = gen.rs()->allocateRegister(gen, noCost);
1503             srcs.push_back(dummyReg);
1504
1505             insnCodeGen::generateImm(gen, CALop, dummyReg, 0, 0);
1506         }
1507 */
1508         //Register src = REG_NULL;
1509         // Try to target the code generation
1510         
1511         Register reg = REG_NULL;
1512         // Try to allocate the correct parameter register
1513         if (gen.rs()->allocateSpecificRegister(gen, registerSpace::r3 + u, true))
1514             reg = registerSpace::r3 + u;
1515              //fprintf(stderr, "info: %s:%d: Register: %d \n", __FILE__, __LINE__, reg); 
1516         Address unused = ADDR_NULL;
1517         if (!operands[u]->generateCode_phase2( gen, false, unused, reg)) assert(0);
1518         assert(reg != REG_NULL);
1519         srcs.push_back(reg);
1520         //bperr( "Generated operand %d, base %d\n", u, base);
1521     }
1522   
1523     if(srcs.size() > 8) {
1524         // This is not necessarily true; more then 8 arguments could be passed,
1525         // the first 8 need to be in registers while the others need to be on
1526         // the stack, -- sec 3/1/97
1527        std::string msg = "Too many arguments to function call in instrumentation code:"
1528             " only 8 arguments can (currently) be passed on the POWER architecture.\n";
1529         bperr( msg.c_str());
1530         showErrorCallback(94,msg);
1531         exit(-1);
1532     }
1533
1534     // If we got the wrong register, we may need to do a 3-way swap. 
1535
1536     int scratchRegs[8];
1537     for (int a = 0; a < 8; a++) {
1538         scratchRegs[a] = -1;
1539     }
1540
1541     // Now load the parameters into registers.
1542     for (unsigned u=0; u<srcs.size(); u++){
1543
1544         // Parameters start at register 3 - so we're already done
1545         // in this case
1546         if (srcs[u] == (registerSpace::r3+u)) {
1547          //fprintf(stderr, "info: %s:%d: Register: %d \n", __FILE__, __LINE__, srcs[u]); 
1548             gen.rs()->freeRegister(srcs[u]);
1549             continue;
1550         }
1551
1552         int whichSource = -1;
1553         bool hasSourceBeenCopied = true;
1554         
1555
1556         // If the parameter we want exists in a scratch register...
1557         if (scratchRegs[u] != -1) {
1558          //fprintf(stderr, "info: %s:%d: Register: %d \n", __FILE__, __LINE__,u+3); 
1559             insnCodeGen::generateImm(gen, ORILop, scratchRegs[u], u+3, 0);
1560             gen.rs()->freeRegister(scratchRegs[u]);
1561             // We should check to make sure the one we want isn't occupied?
1562         } else {
1563             for (unsigned v=u; v < srcs.size(); v++) {
1564                 if (srcs[v] == u+3) {
1565                     // Okay, so the source we want is actuall in srcs[v]
1566                     hasSourceBeenCopied = false;
1567                     whichSource = v;
1568                     break;
1569                 }
1570             }
1571             // Ummm... we didn't find it? Ah, so copying us (since we're wrong)
1572             // into scratch.
1573             if (!hasSourceBeenCopied) {
1574                 Register scratch = gen.rs()->getScratchRegister(gen);
1575                 insnCodeGen::generateImm(gen, ORILop, u+3, scratch, 0);
1576                 gen.rs()->freeRegister(u+3);
1577                 scratchRegs[whichSource] = scratch;
1578                 hasSourceBeenCopied = true;
1579
1580                 insnCodeGen::generateImm(gen, ORILop, srcs[u], u+3, 0);
1581                 gen.rs()->freeRegister(srcs[u]);
1582
1583             } else {
1584                 insnCodeGen::generateImm(gen, ORILop, srcs[u], u+3, 0);
1585                 gen.rs()->freeRegister(srcs[u]);
1586                 // Not sure why this was needed
1587                 //gen.rs()->clobberRegister(u+3);
1588             }
1589         } 
1590     }
1591
1592     // Call generation time.
1593     bool setTOC = false;
1594
1595         // Linux, 64, stat/dyn, inst/repl
1596     if (toc_anchor != caller_toc) {
1597          //fprintf(stderr, "info: %s:%d: \n", __FILE__, __LINE__); 
1598         setTOC = true;
1599     }
1600     
1601     emitCallInstruction(gen, callee, setTOC, toc_anchor);
1602     // ALL instrumentation
1603     Register retReg = REG_NULL;
1604     if (inInstrumentation) {
1605         // get a register to keep the return value in.
1606         retReg = gen.rs()->allocateRegister(gen, noCost);        
1607         // put the return value from register 3 to the newly allocated register.
1608         insnCodeGen::generateImm(gen, ORILop, 3, retReg, 0);
1609     }
1610
1611         
1612     // Otherwise we're replacing a call and so we don't want to move
1613     // anything. 
1614
1615     // restore saved registers.
1616     // If inInstrumentation == false then this vector should be empty...
1617         // ALL instrumentation
1618  
1619     if (!inInstrumentation) assert(savedRegs.size() == 0);
1620     for (u_int ui = 0; ui < savedRegs.size(); ui++) {
1621       restoreRegister(gen, savedRegs[ui], FUNC_CALL_SAVE(gen.width()));
1622     }
1623   
1624     // mtlr     0 (aka mtspr 8, rs) = 0x7c0803a6
1625     // Move to link register
1626     // Reused from above. instruction mtlr0(MTLR0raw);
1627     if (needToSaveLR) {
1628         // We only use register 0 to save LR. 
1629         insnCodeGen::generateMoveToLR(gen, 0);
1630     }
1631     
1632     if (!inInstrumentation && setTOC) {
1633         // Need to reset the TOC
1634         emitVload(loadConstOp, caller_toc, 2, 2, gen, false);
1635
1636         // Also store toc_orig [r2] into the TOC save area [40(r1)].
1637         // Subsequent code will look for it there.
1638         saveRegisterAtOffset(gen, 2, 40);
1639     }        
1640
1641     /*
1642       gen = (instruction *) gen;
1643       for (unsigned foo = initBase/4; foo < base/4; foo++)
1644       bperr( "0x%x,\n", gen[foo].raw);
1645     */ 
1646     // return value is the register with the return value from the called function
1647     return(retReg);
1648 }
1649
1650  
1651 codeBufIndex_t emitA(opCode op, Register src1, Register /*src2*/, long dest,
1652               codeGen &gen, RegControl, bool /*noCost*/)
1653 {
1654     //bperr("emitA(op=%d,src1=%d,src2=XX,dest=%d)\n",op,src1,dest);
1655     codeBufIndex_t retval = 0;
1656     switch (op) {
1657       case ifOp: {
1658         // cmpi 0,0,src1,0
1659           instruction insn;
1660           insn.clear();
1661           DFORM_OP_SET(insn, CMPIop);
1662           DFORM_RA_SET(insn, src1);
1663           DFORM_SI_SET(insn, 0);
1664           insnCodeGen::generate(gen,insn);
1665           retval = gen.getIndex();
1666           
1667           // be 0, dest
1668           insn.clear();
1669           BFORM_OP_SET(insn, BCop);
1670           BFORM_BO_SET(insn, BTRUEcond);
1671           BFORM_BI_SET(insn, EQcond);
1672           BFORM_BD_SET(insn, dest/4);
1673           BFORM_AA_SET(insn, 0);
1674           BFORM_LK_SET(insn, 0);
1675           
1676           insnCodeGen::generate(gen,insn);
1677           break;
1678       }
1679     case branchOp: {
1680         retval = gen.getIndex();
1681         insnCodeGen::generateBranch(gen, dest);
1682         break;
1683     }
1684     case trampPreamble: {
1685         // nothing to do in this platform
1686         return(0);              // let's hope this is expected!
1687     }        
1688     default:
1689         assert(0);        // unexpected op for this emit!
1690     }
1691     return retval;
1692 }
1693
1694 Register emitR(opCode op, Register src1, Register src2, Register dest,
1695                codeGen &gen, bool /*noCost*/,
1696                const instPoint * /*location*/, bool /*for_MT*/)
1697 {
1698     //bperr("emitR(op=%d,src1=%d,src2=XX,dest=%d)\n",op,src1,dest);
1699
1700     registerSlot *regSlot = NULL;
1701     unsigned addrWidth = gen.width();
1702
1703     switch (op) {
1704     case getRetValOp: {
1705         regSlot = (*(gen.rs()))[registerSpace::r3];
1706         break;
1707     }
1708
1709     case getParamOp: {
1710         // The first 8 parameters (0-7) are stored in registers (r3-r10) upon
1711         // entering the function and then saved above the stack upon entering
1712         // the trampoline; in emit functional call the stack pointer is moved
1713         // so the saved registers are not over-written the other parameters >
1714         // 8 are stored on the caller's stack at an offset.
1715         // 
1716         // src1 is the argument number 0..X, the first 8 are stored in regs
1717         // src2 (if not REG_NULL) holds the value to be written into src1
1718
1719         if(src1 < 8) {
1720             // src1 is 0..8 - it's a parameter number, not a register
1721             regSlot = (*(gen.rs()))[registerSpace::r3 + src1];
1722             break;
1723
1724         } else {
1725             // Registers from 11 (src = 8) and beyond are saved on the stack.
1726             // On AIX this is +56 bytes; for ELF it's something different.
1727
1728             int stkOffset;
1729             if (addrWidth == 4) {
1730                 stkOffset = TRAMP_FRAME_SIZE_32 +
1731                             (src1 - 8) * sizeof(int) +
1732                             PARAM_OFFSET(addrWidth);
1733             } else {
1734               // Linux ABI says:
1735               // Parameters go in the "argument save area", which starts at
1736               // PARAM_OFFSET(...). However, we'd save argument _0_ at the base
1737               // of it, so the first 8 slots are normally empty (as they go in
1738               // registers). To get the 9th, etc. argument you want
1739               // PARAM_OFFSET(...) + (8 * arg number) instead of
1740               // 8 * (arg_number - 8)
1741               int stackSlot = src1;
1742               stkOffset = TRAMP_FRAME_SIZE_64 +
1743                             stackSlot * sizeof(long) +
1744                             PARAM_OFFSET(addrWidth);
1745             }
1746
1747             if (src2 != REG_NULL) saveRegisterAtOffset(gen, src2, stkOffset);
1748             restoreRegisterAtOffset(gen, dest, stkOffset);
1749             return(dest);
1750       }
1751       break;
1752     }
1753
1754     case getRetAddrOp: {
1755       regSlot = (*(gen.rs()))[registerSpace::lr];
1756       break;
1757     }
1758
1759     default:
1760         assert(0);
1761         break;
1762     }
1763
1764     assert(regSlot);
1765     Register reg = regSlot->number;
1766
1767     switch(regSlot->liveState) {
1768     case registerSlot::spilled: {
1769       int offset = TRAMP_GPR_OFFSET(addrWidth);
1770       
1771       // its on the stack so load it.
1772       if (src2 != REG_NULL) saveRegister(gen, src2, reg, offset);
1773       restoreRegister(gen, reg, dest, offset);
1774       return(dest);
1775     }
1776     case registerSlot::live: {
1777         // its still in a register so return the register it is in.
1778         
1779         return(reg);
1780     }
1781     case registerSlot::dead: {
1782         // Uhhh... wha?
1783         assert(0);
1784     }
1785     }
1786
1787     assert(0);
1788     return REG_NULL;
1789 }
1790
1791 void emitJmpMC(int /*condition*/, int /*offset*/, codeGen &)
1792 {
1793   // Not needed for memory instrumentation, otherwise TBD
1794 }
1795
1796
1797 // VG(11/16/01): Say if we have to restore a register to get its original value
1798 // VG(03/15/02): Sync'd with the new AIX tramp
1799 static inline bool needsRestore(Register x)
1800 {
1801   //return (x == 0) || ((x >= 3) && (x <= 12)) || (x == POWER_XER2531);
1802   return ((x <= 12) && !(x==2)) || (x == POWER_XER2531);
1803 }
1804
1805 // VG(03/15/02): Restore mutatee value of GPR reg to dest GPR
1806 static inline void restoreGPRtoGPR(codeGen &gen,
1807                                    Register reg, Register dest)
1808 {
1809     int frame_size, gpr_size, gpr_off;
1810     if (gen.width() == 4) {
1811         frame_size = TRAMP_FRAME_SIZE_32;
1812         gpr_size   = GPRSIZE_32;
1813         gpr_off    = TRAMP_GPR_OFFSET_32;
1814     } else /* gen.width() == 8 */ {
1815         frame_size = TRAMP_FRAME_SIZE_64;
1816         gpr_size   = GPRSIZE_64;
1817         gpr_off    = TRAMP_GPR_OFFSET_64;
1818     }
1819
1820     if (reg == 1) // SP is in a different place, but we don't need to
1821                   // restore it, just subtract the stack frame size
1822         insnCodeGen::generateImm(gen, CALop, dest, REG_SP, frame_size);
1823
1824     else if((reg == 0) || ((reg >= 3) && (reg <=12)))
1825         insnCodeGen::generateImm(gen, Lop, dest, REG_SP,
1826                                  gpr_off + reg*gpr_size);
1827     else {
1828         bperr( "GPR %d should not be restored...", reg);
1829         assert(0);
1830     }
1831     //bperr( "Loading reg %d (into reg %d) at 0x%x off the stack\n", 
1832     //  reg, dest, offset + reg*GPRSIZE);
1833 }
1834
1835 // VG(03/15/02): Restore mutatee value of XER to dest GPR
1836 static inline void restoreXERtoGPR(codeGen &gen, Register dest)
1837 {
1838     if (gen.width() == 4) {
1839         insnCodeGen::generateImm(gen, Lop, dest, REG_SP,
1840                                  TRAMP_SPR_OFFSET(4) + STK_XER_32);
1841     } else /* gen.width() == 8 */ {
1842         insnCodeGen::generateMemAccess64(gen, LDop, LDxop, dest, REG_SP,
1843                                          TRAMP_SPR_OFFSET(8) + STK_XER_64);
1844     }
1845 }
1846
1847 // VG(03/15/02): Move bits 25:31 of GPR reg to GPR dest
1848 static inline void moveGPR2531toGPR(codeGen &gen,
1849                                     Register reg, Register dest)
1850 {
1851   // keep only bits 32+25:32+31; extrdi dest, reg, 7 (n bits), 32+25 (start at b)
1852   // which is actually: rldicl dest, reg, 32+25+7 (b+n), 64-7 (64-n)
1853   // which is the same as: clrldi dest,reg,57 because 32+25+7 = 64
1854     instruction rld;
1855     rld.clear();
1856     MDFORM_OP_SET( rld, RLDop);
1857     MDFORM_RS_SET( rld, reg);
1858     MDFORM_RA_SET( rld, dest);
1859     MDFORM_SH_SET( rld, 0);  //(32+25+7) % 32;
1860     MDFORM_MB_SET( rld, (64-7) % 32);
1861     MDFORM_MB2_SET(rld, (64-7) / 32);
1862     MDFORM_XO_SET( rld, ICLxop);
1863     MDFORM_SH2_SET(rld, 0); //(32+25+7) / 32;
1864     MDFORM_RC_SET( rld, 0);
1865     insnCodeGen::generate(gen,rld);
1866 }
1867
1868 // VG(11/16/01): Emit code to add the original value of a register to
1869 // another. The original value may need to be restored from stack...
1870 // VG(03/15/02): Made functionality more obvious by adding the above functions
1871 static inline void emitAddOriginal(Register src, Register acc, 
1872                                    codeGen &gen, bool noCost)
1873 {
1874     bool nr = needsRestore(src);
1875     Register temp;
1876     
1877     if(nr) {
1878         // this needs gen because it uses emitV...
1879         temp = gen.rs()->allocateRegister(gen, noCost);
1880         
1881         // Emit code to restore the original ra register value in temp.
1882         // The offset compensates for the gap 0, 3, 4, ...
1883         // This writes at insn, and updates insn and base.
1884         
1885         if(src == POWER_XER2531) { // hack for XER_25:31
1886             //bperr( "XER_25:31\n");
1887             restoreXERtoGPR(gen, temp);
1888             moveGPR2531toGPR(gen, temp, temp);
1889         }
1890         else
1891             restoreGPRtoGPR(gen, src, temp);
1892     }
1893     else
1894         temp = src;
1895     
1896     // add temp to dest;
1897     // writes at gen+base and updates base, we must update insn...
1898     emitV(plusOp, temp, acc, acc, gen, noCost, 0);
1899     
1900     if(nr)
1901         gen.rs()->freeRegister(temp);
1902 }
1903
1904 // VG(11/07/01): Load in destination the effective address given
1905 // by the address descriptor. Used for memory access stuff.
1906 void emitASload(const BPatch_addrSpec_NP *as, Register dest, int stackShift,
1907                 codeGen &gen,
1908                 bool noCost)
1909 {
1910   // Haven't implemented non-zero shifts yet
1911   assert(stackShift == 0);
1912   //instruction *insn = (instruction *) ((void*)&gen[base]);
1913   int imm = as->getImm();
1914   int ra  = as->getReg(0);
1915   int rb  = as->getReg(1);
1916   // TODO: optimize this to generate the minimum number of
1917   // instructions; think about schedule
1918
1919   // emit code to load the immediate (constant offset) into dest; this
1920   // writes at gen+base and updates base, we must update insn...
1921   emitVload(loadConstOp, (Address)imm, dest, dest, gen, noCost);
1922   
1923   // If ra is used in the address spec, allocate a temp register and
1924   // get the value of ra from stack into it
1925   if(ra > -1)
1926       emitAddOriginal(ra, dest, gen, noCost);
1927
1928   // If rb is used in the address spec, allocate a temp register and
1929   // get the value of ra from stack into it
1930   if(rb > -1)
1931     emitAddOriginal(rb, dest, gen, noCost);
1932
1933 }
1934
1935 void emitCSload(const BPatch_addrSpec_NP *as, Register dest, codeGen &gen,               
1936                 bool noCost)
1937 {
1938   emitASload(as, dest, 0, gen, noCost);
1939 }
1940
1941 void emitVload(opCode op, Address src1, Register src2, Register dest,
1942                codeGen &gen, bool /*noCost*/, 
1943                registerSpace * /*rs*/, int size,
1944                const instPoint * /* location */, AddressSpace *proc)
1945 {
1946   switch(op) {
1947   case loadConstOp:
1948     insnCodeGen::loadImmIntoReg(gen, dest, (long)src1);
1949     break;
1950   case loadOp:
1951     insnCodeGen::loadPartialImmIntoReg(gen, dest, (long)src1);
1952     
1953     // really load dest, (dest)imm
1954     if (size == 1) {
1955       insnCodeGen::generateImm(gen, LBZop, dest, dest, LOW(src1));
1956     }
1957     else if (size == 2) {
1958       insnCodeGen::generateImm(gen, LHZop, dest, dest, LOW(src1));
1959     }
1960     else if ((size == 4) ||
1961              (size == 8 && proc->getAddressWidth() == 4)) // Override bogus size
1962       insnCodeGen::generateImm(gen, Lop,   dest, dest, LOW(src1));
1963     else if (size == 8)
1964       insnCodeGen::generateMemAccess64(gen, LDop, LDxop,
1965                                        dest, dest, (int16_t)LOW(src1));
1966     else assert(0 && "Incompatible loadOp size");
1967     break;
1968   case loadFrameRelativeOp: {
1969         long offset = (long)src1;
1970         if (gen.width() == 4)
1971             offset += TRAMP_FRAME_SIZE_32;
1972         else /* gen.width() == 8 */
1973             offset += TRAMP_FRAME_SIZE_64;
1974
1975         // return the value that is FP offset from the original fp
1976         if (size == 1)
1977             insnCodeGen::generateImm(gen, LBZop, dest, REG_SP, offset);
1978         else if (size == 2)
1979             insnCodeGen::generateImm(gen, LHZop, dest, REG_SP, offset);
1980         else if ((size == 4) ||
1981                  (size == 8 && proc->getAddressWidth() == 4)) // Override bogus size
1982             insnCodeGen::generateImm(gen, Lop,   dest, REG_SP, offset);
1983         else if (size == 8)
1984             insnCodeGen::generateMemAccess64(gen, LDop, LDxop,
1985                                              dest, REG_SP, offset);
1986         else assert(0 && "Incompatible loadFrameRelativeOp size");
1987   }
1988     break;
1989   case loadFrameAddr: {
1990     // offsets are signed!
1991     long offset = (long)src1;
1992     offset += (gen.width() == 4 ? TRAMP_FRAME_SIZE_32
1993                : TRAMP_FRAME_SIZE_64);
1994     
1995     if (offset < MIN_IMM16 || MAX_IMM16 < offset) assert(0);
1996     insnCodeGen::generateImm(gen, CALop, dest, REG_SP, offset);
1997   }
1998     break;
1999   case loadRegRelativeAddr:
2000     // (readReg(src2) + src1)
2001     gen.rs()->readProgramRegister(gen, src2, dest, size);
2002     emitImm(plusOp, dest, src1, dest, gen, false);
2003     break;
2004   case loadRegRelativeOp:
2005     // *(readReg(src2) + src1)
2006     gen.rs()->readProgramRegister(gen, src2, dest, size);
2007
2008     if (size == 1)
2009       insnCodeGen::generateImm(gen, LBZop, dest, dest, src1);
2010     else if (size == 2)
2011       insnCodeGen::generateImm(gen, LHZop, dest, dest, src1);
2012     else if ((size == 4) ||
2013              (size == 8 && proc->getAddressWidth() == 4)) // Override bogus size
2014       insnCodeGen::generateImm(gen, Lop,   dest, dest, src1);
2015     else if (size == 8)
2016       insnCodeGen::generateMemAccess64(gen, LDop, LDxop,
2017                                        dest, dest, src1);
2018     break;
2019   default:
2020
2021
2022     cerr << "Unknown op " << op << endl;
2023     assert(0);
2024   }
2025 }
2026
2027 void emitVstore(opCode op, Register src1, Register /*src2*/, Address dest,
2028                 codeGen &gen, bool noCost, 
2029                 registerSpace * /* rs */, int size,
2030                 const instPoint * /* location */, AddressSpace *proc)
2031 {
2032     if (op == storeOp) {
2033         // temp register to hold base address for store (added 6/26/96 jkh)
2034         Register temp = gen.rs()->getScratchRegister(gen, noCost);
2035
2036         insnCodeGen::loadPartialImmIntoReg(gen, temp, (long)dest);
2037         if (size == 1)
2038             insnCodeGen::generateImm(gen, STBop, src1, temp, LOW(dest));
2039         else if (size == 2)
2040             insnCodeGen::generateImm(gen, STHop, src1, temp, LOW(dest));
2041         else if ((size == 4) ||
2042                  (size == 8 && proc->getAddressWidth() == 4)) // Override bogus size
2043             insnCodeGen::generateImm(gen, STop,  src1, temp, LOW(dest));
2044         else if (size == 8)
2045             insnCodeGen::generateMemAccess64(gen, STDop, STDxop,
2046                                              src1, temp, (int16_t)BOT_LO(dest));
2047         else assert(0 && "Incompatible storeOp size");
2048
2049     } else if (op == storeFrameRelativeOp) {
2050         long offset = (long)dest;
2051         offset += (gen.width() == 4
2052                    ? TRAMP_FRAME_SIZE_32
2053                    : TRAMP_FRAME_SIZE_64);
2054
2055         if (size == 1)
2056             insnCodeGen::generateImm(gen, STBop, src1, REG_SP, offset);
2057         else if (size == 2)
2058             insnCodeGen::generateImm(gen, STHop, src1, REG_SP, offset);
2059         else if ((size == 4) ||
2060                  (size == 8 || proc->getAddressWidth() == 4)) // Override bogus size
2061             insnCodeGen::generateImm(gen, STop,  src1, REG_SP, offset);
2062         else if (size == 8)
2063             insnCodeGen::generateMemAccess64(gen, STDop, STDxop, src1,
2064                                              REG_SP, offset);
2065         else assert(0 && "Incompatible storeFrameRelativeOp size");
2066
2067     } else assert(0 && "Unknown op passed to emitVstore");
2068 }
2069
2070 void emitV(opCode op, Register src1, Register src2, Register dest,
2071            codeGen &gen, bool /*noCost*/,
2072            registerSpace * /*rs*/, int size,
2073            const instPoint * /* location */, AddressSpace *proc)
2074 {
2075     //bperr("emitV(op=%d,src1=%d,src2=%d,dest=%d)\n",op,src1,src2,dest);
2076
2077     assert ((op!=branchOp) && (op!=ifOp) && 
2078             (op!=trampPreamble));         // !emitA
2079     assert ((op!=getRetValOp) && (op!=getParamOp));             // !emitR
2080     assert ((op!=loadOp) && (op!=loadConstOp));                 // !emitVload
2081     assert ((op!=storeOp));                                     // !emitVstore
2082     assert ((op!=updateCostOp));                                // !emitVupdate
2083
2084     instruction insn;
2085
2086     if (op == loadIndirOp) {
2087        // really load dest, (dest)imm
2088        assert(src2 == 0); // Since we don't use it.
2089        if (!size)
2090           size = proc->getAddressWidth();
2091        if (size == 1)
2092           insnCodeGen::generateImm(gen, LBZop, dest, src1, 0);
2093        else if (size == 2)
2094           insnCodeGen::generateImm(gen, LHZop, dest, src1, 0);
2095        else if ((size == 4) ||
2096                 (size == 8 && proc->getAddressWidth() == 4)) // Override bogus size
2097           insnCodeGen::generateImm(gen, Lop,   dest, src1, 0);
2098        else if (size == 8) {
2099           insnCodeGen::generateMemAccess64(gen, LDop, LDxop,
2100                                            dest, src1, 0);
2101        } 
2102        else 
2103           assert(0 && "Incompatible loadOp size");
2104     } else if (op == storeIndirOp) {
2105         // generate -- st src1, dest
2106         if (size == 1)
2107             insnCodeGen::generateImm(gen, STBop, src1, dest, 0);
2108         else if (size == 2)
2109             insnCodeGen::generateImm(gen, STHop, src1, dest, 0);
2110         else if ((size == 4) ||
2111                  (size == 8 && proc->getAddressWidth() == 4)) // Override bogus size
2112             insnCodeGen::generateImm(gen, STop,  src1, dest, 0);
2113         else if (size == 8)
2114             insnCodeGen::generateMemAccess64(gen, STDop, STDxop,
2115                                              src1, dest, 0);
2116         else assert(0 && "Incompatible storeOp size");
2117
2118     } else if (op == noOp) {
2119         insnCodeGen::generateNOOP(gen);
2120
2121     } else if (op == saveRegOp) {
2122         saveRegister(gen,src1,8);
2123
2124     } else {
2125         int instXop=-1;
2126         int instOp=-1;
2127         switch (op) {
2128             // integer ops
2129             case plusOp:
2130                 instOp = CAXop;
2131                 instXop = CAXxop;
2132                 break;
2133
2134             case minusOp:
2135                 Register temp;
2136                 // need to flip operands since this computes ra-rb not rb-ra
2137                 temp = src1;
2138                 src1 = src2;
2139                 src2 = temp;
2140                 instOp = SFop;
2141                 instXop = SFxop;
2142                 break;
2143
2144             case timesOp:
2145                 instOp = MULSop;
2146                 instXop = MULSxop;
2147                 break;
2148
2149             case divOp:
2150                 instOp = DIVSop;   // POWER divide instruction
2151                                    // Same as DIVWop for PowerPC
2152                 instXop = DIVWxop; // PowerPC
2153                 break;
2154
2155             // Bool ops
2156             case orOp:
2157                 //genSimple(gen, ORop, src1, src2, dest);
2158                 insn.clear();
2159                 XOFORM_OP_SET(insn, ORop);
2160                 // operation is ra <- rs | rb (or rs,ra,rb)
2161                 XOFORM_RA_SET(insn, dest);
2162                 XOFORM_RT_SET(insn, src1);
2163                 XOFORM_RB_SET(insn, src2);
2164                 XOFORM_XO_SET(insn, ORxop);
2165                 insnCodeGen::generate(gen,insn);
2166                 return;
2167                 break;
2168
2169             case andOp:
2170                 //genSimple(gen, ANDop, src1, src2, dest);
2171                 // This is a Boolean and with true == 1 so bitwise is OK
2172                 insn.clear();
2173                 XOFORM_OP_SET(insn, ANDop);
2174                 // operation is ra <- rs & rb (and rs,ra,rb)
2175                 XOFORM_RA_SET(insn, dest);
2176                 XOFORM_RT_SET(insn, src1);
2177                 XOFORM_RB_SET(insn, src2);
2178                 XOFORM_XO_SET(insn, ANDxop);
2179                 insnCodeGen::generate(gen,insn);
2180                 return;
2181                 break;
2182
2183             case xorOp:
2184                 insn.clear();
2185                 XOFORM_OP_SET(insn, XORop);
2186                 // operation is ra <- rs ^ rb (xor rs,ra,rb)
2187                 XOFORM_RA_SET(insn, dest);
2188                 XOFORM_RT_SET(insn, src1);
2189                 XOFORM_RB_SET(insn, src2);
2190                 XOFORM_XO_SET(insn, XORxop);
2191                 insnCodeGen::generate(gen, insn);
2192                 return;
2193                 break;
2194
2195             // rel ops
2196             case eqOp:
2197                 insnCodeGen::generateRelOp(gen, EQcond, BTRUEcond, src1, src2, dest);
2198                 return;
2199                 break;
2200
2201             case neOp:
2202                 insnCodeGen::generateRelOp(gen, EQcond, BFALSEcond, src1, src2, dest);
2203                 return;
2204                 break;
2205
2206             case lessOp:
2207                 insnCodeGen::generateRelOp(gen, LTcond, BTRUEcond, src1, src2, dest);
2208                 return;
2209                 break;
2210
2211             case greaterOp:
2212                 insnCodeGen::generateRelOp(gen, GTcond, BTRUEcond, src1, src2, dest);
2213                 return;
2214                 break;
2215
2216             case leOp:
2217                 insnCodeGen::generateRelOp(gen, GTcond, BFALSEcond, src1, src2, dest);
2218                 return;
2219                 break;
2220
2221             case geOp:
2222                 insnCodeGen::generateRelOp(gen, LTcond, BFALSEcond, src1, src2, dest);
2223                 return;
2224                 break;
2225
2226             default:
2227                 // internal error, invalid op.
2228                 bperr( "Invalid op passed to emit, instOp = %d\n", instOp);
2229                 assert(0 && "Invalid op passed to emit");
2230                 break;
2231         }
2232
2233         
2234         assert((instOp != -1) && (instXop != -1));
2235         insn.clear();
2236         XOFORM_OP_SET(insn, instOp);
2237         XOFORM_RT_SET(insn, dest);
2238         XOFORM_RA_SET(insn, src1);
2239         XOFORM_RB_SET(insn, src2);
2240         XOFORM_XO_SET(insn, instXop);
2241         insnCodeGen::generate(gen,insn);
2242     }
2243   return;
2244 }
2245
2246
2247 //
2248 // I don't know how to compute cycles for POWER instructions due to 
2249 //   multiple functional units.  However, we can compute the number of
2250 //   instructions and hope that is fairly close. - jkh 1/30/96
2251 //
2252 int getInsnCost(opCode op)
2253   {
2254     int cost = 0;
2255
2256     /* XXX Need to add branchOp */
2257     switch (op) {
2258       
2259     case noOp:
2260     case loadIndirOp:
2261     case saveRegOp:
2262
2263       // worse case is it is on the stack and takes one instruction.
2264     case getParamOp:
2265
2266       // integer ops
2267     case plusOp:
2268     case minusOp:
2269     case timesOp:
2270     case divOp:
2271       cost = 1;
2272       break;
2273
2274     case loadConstOp:
2275       // worse case is addi followed by ori
2276
2277     case loadOp:
2278       // addis, l
2279       
2280     case storeOp:
2281     case storeIndirOp:
2282       cost = 2;
2283       break;
2284
2285     case ifOp:
2286       // cmpi 0,0,src1,0
2287       // be 0, dest
2288       // nop
2289       cost = 3;
2290       break;
2291
2292       // rel ops
2293     case eqOp:
2294     case neOp:
2295     case lessOp:
2296     case greaterOp:
2297     case leOp:
2298     case geOp:
2299       cost = 4;
2300       break;
2301       
2302     case callOp:
2303       // mflr r0
2304       // st r0, (r1)
2305       cost += 2;
2306       
2307       // Should compute the cost to save registers here.  However, we lack 
2308       //   sufficient information to compute this value. We need to be 
2309       //   inside the code generator to know this amount.
2310       //
2311       // We know it is at *least* every live register (i.e. parameter reg)
2312       cost += 13;
2313       
2314       // clr r5
2315       // clr r6
2316       // decrement stack pointer -- STUop
2317       // load r0 with address, then move to link reg and branch and link.
2318       // ori dest,dest,LOW(src1)
2319       // mtlr   0 (aka mtspr 8, rs) = 0x7c0803a6
2320       // brl - branch and link through the link reg.
2321       cost += 7;
2322       
2323       // now cleanup.
2324       
2325       // increment stack pointer -- CALop
2326       // restore the saved register 0.
2327       cost += 2;
2328       
2329       // Should compute the cost to restore registers here.  However, we lack 
2330       //   sufficient information to compute this value. We need to be 
2331       //   inside the code generator to know this amount.
2332       //
2333       // We know it is at *least* every live register (i.e. parameter reg)
2334       cost += 13;
2335       
2336       // mtlr   0 
2337       cost++;
2338       break;
2339
2340     case updateCostOp:
2341       // In most cases this cost is 4, but if we can't use CALop because
2342       // the value is to large, then we'll need 2 additional operations to
2343       // load that value - naim
2344       // Why the +=? Isn't it equivalent to an = here? -- bernat
2345       cost += 4;
2346       break;
2347       
2348     case trampPreamble:
2349       // Generate code to update the observed cost.
2350       // generated code moved to the base trampoline.
2351       cost += 0;
2352       break;
2353
2354     default:
2355       cost = 0;
2356       break;
2357     }
2358     return (cost);
2359 }
2360
2361 #if 0
2362 // What does this do???
2363 void registerSpace::saveClobberInfo(const instPoint *location)
2364 {
2365   registerSlot *regSlot = NULL;
2366   registerSlot *regFPSlot = NULL;
2367   if (location == NULL)
2368     return;
2369   if (location->actualGPRLiveSet_ != NULL && location->actualFPRLiveSet_ != NULL)
2370     {
2371       
2372       // REG guard registers, if live, must be saved
2373       if (location->actualGPRLiveSet_[ REG_GUARD_ADDR ] == LIVE_REG)
2374         location->actualGPRLiveSet_[ REG_GUARD_ADDR ] = LIVE_CLOBBERED_REG;
2375       
2376       if (location->actualGPRLiveSet_[ REG_GUARD_OFFSET ] == LIVE_REG)
2377         location->actualGPRLiveSet_[ REG_GUARD_OFFSET ] = LIVE_CLOBBERED_REG;
2378
2379       // GPR and FPR scratch registers, if live, must be saved
2380       if (location->actualGPRLiveSet_[ REG_SCRATCH ] == LIVE_REG)
2381         location->actualGPRLiveSet_[ REG_SCRATCH ] = LIVE_CLOBBERED_REG;
2382
2383       if (location->actualFPRLiveSet_[ REG_SCRATCH ] == LIVE_REG)
2384         location->actualFPRLiveSet_[ REG_SCRATCH ] = LIVE_CLOBBERED_REG;
2385
2386       // Return func call register, since we make a call because
2387       // of multithreading (regardless if it's threaded) from BT
2388       // we must save return register
2389       if (location->actualGPRLiveSet_[ 3 ] == LIVE_REG)
2390         location->actualGPRLiveSet_[ 3 ] = LIVE_CLOBBERED_REG;
2391
2392     
2393       for (u_int i = 0; i < getRegisterCount(); i++)
2394         {
2395           regSlot = getRegSlot(i);
2396
2397           if (  location->actualGPRLiveSet_[ (int) registers[i].number ] == LIVE_REG )
2398             {
2399               if (!registers[i].beenClobbered)
2400                 location->actualGPRLiveSet_[ (int) registers[i].number ] = LIVE_UNCLOBBERED_REG;
2401               else
2402                 location->actualGPRLiveSet_[ (int) registers[i].number ] = LIVE_CLOBBERED_REG;
2403             }
2404
2405
2406           if (  location->actualGPRLiveSet_[ (int) registers[i].number ] == LIVE_UNCLOBBERED_REG ) 
2407             {
2408               if (registers[i].beenClobbered)
2409                 location->actualGPRLiveSet_[ (int) registers[i].number ] = LIVE_CLOBBERED_REG;
2410             }
2411         }
2412           
2413       for (u_int i = 0; i < getFPRegisterCount(); i++)
2414         {
2415           regFPSlot = getFPRegSlot(i);
2416           
2417           if (  location->actualFPRLiveSet_[ (int) fpRegisters[i].number ] == LIVE_REG )
2418             {
2419               if (!fpRegisters[i].beenClobbered)
2420                 location->actualFPRLiveSet_[ (int) fpRegisters[i].number ] = LIVE_UNCLOBBERED_REG;
2421               else
2422                 location->actualFPRLiveSet_[ (int) fpRegisters[i].number ] = LIVE_CLOBBERED_REG;
2423             }
2424           
2425           if (  location->actualFPRLiveSet_[ (int) fpRegisters[i].number ] == LIVE_UNCLOBBERED_REG )
2426             {
2427               if (fpRegisters[i].beenClobbered)
2428                 location->actualFPRLiveSet_[ (int) fpRegisters[i].number ] = LIVE_CLOBBERED_REG;
2429             }
2430         }
2431     }
2432 }
2433 #endif
2434
2435
2436 bool doNotOverflow(int64_t value)
2437 {
2438   // we are assuming that we have 15 bits to store the immediate operand.
2439   if ( (value <= 32767) && (value >= -32768) ) return(true);
2440   else return(false);
2441 }
2442
2443 #if !defined(os_vxworks)
2444 // hasBeenBound: returns true if the runtime linker has bound the
2445 // function symbol corresponding to the relocation entry in at the address
2446 // specified by entry and base_addr.  If it has been bound, then the callee 
2447 // function is returned in "target_pdf", else it returns false.
2448 bool PCProcess::hasBeenBound(const SymtabAPI::relocationEntry &entry, 
2449                 func_instance *&target_pdf, Address base_addr) 
2450 {
2451
2452         if (isTerminated()) return false;
2453
2454         // if the relocationEntry has not been bound yet, then the value
2455         // at rel_addr is the address of the instruction immediately following
2456         // the first instruction in the PLT entry (which is at the target_addr) 
2457         // The PLT entries are never modified, instead they use an indirrect 
2458         // jump to an address stored in the _GLOBAL_OFFSET_TABLE_.  When the 
2459         // function symbol is bound by the runtime linker, it changes the address
2460         // in the _GLOBAL_OFFSET_TABLE_ corresponding to the PLT entry
2461
2462         Address got_entry = entry.rel_addr() + base_addr;
2463         Address bound_addr = 0;
2464         if (!readDataSpace((const void*)got_entry, sizeof(Address),
2465                                 &bound_addr, true)){
2466                 sprintf(errorLine, "read error in PCProcess::hasBeenBound addr 0x%x, pid=%d\n (readDataSpace returns 0)",(unsigned)got_entry,getPid());
2467                 logLine(errorLine);
2468                 //print_read_error_info(entry, target_pdf, base_addr);
2469                 fprintf(stderr, "%s[%d]: %s\n", FILE__, __LINE__, errorLine);
2470                 return false;
2471         }
2472
2473    //fprintf(stderr, "%s[%d]:  hasBeenBound:  %p ?= %p ?\n", FILE__, __LINE__, bound_addr, entry.target_addr() + 6 + base_addr);
2474         if ( !( bound_addr == (entry.target_addr()+6+base_addr)) ) {
2475           // the callee function has been bound by the runtime linker
2476           // find the function and return it
2477           target_pdf = findFuncByEntry(bound_addr);
2478           if(!target_pdf){
2479             return false;
2480           }
2481           return true;
2482         }
2483         return false;
2484 }
2485
2486 #endif
2487
2488 bool PCProcess::bindPLTEntry(const SymtabAPI::relocationEntry &entry, Address base_addr, 
2489                            func_instance * origFunc, Address target_addr) {
2490    fprintf(stderr, "[PCProcess::bindPLTEntry] Relocation Entry location target: %llx, relocation: %llx - base_addr: %llx, original_function: %llx, original_name: %s, new_target: %llx\n", entry.target_addr(), entry.rel_addr(), base_addr, origFunc->getPtrAddress(), origFunc->name().c_str(), target_addr);
2491    Address got_entry = entry.rel_addr() + base_addr;
2492    return true;//writeDataSpace((void *)got_entry, sizeof(Address), &target_addr);
2493
2494    //assert(0 && "TODO!");
2495    // return false;
2496 }
2497 void emitLoadPreviousStackFrameRegister(Address register_num, 
2498                                         Register dest,
2499                                         codeGen &gen,
2500                                         int /*size*/,
2501                                         bool noCost)
2502 {
2503     // As of 10/24/2007, the size parameter is still incorrect.
2504     // Luckily, we know implicitly what size they actually want.
2505
2506     // Offset if needed
2507     int offset;
2508     // Unused, 3OCT03
2509     //instruction *insn_ptr = (instruction *)insn;
2510     // We need values to define special registers.
2511
2512     switch ( (int) register_num) {
2513     case registerSpace::lr:
2514         // LR is saved on the stack
2515         // Note: this is only valid for non-function entry/exit instru. 
2516         // Once we've entered a function, the LR is stomped to point
2517         // at the exit tramp!
2518       offset = TRAMP_SPR_OFFSET(gen.width()) + STK_LR; 
2519
2520         // Get address (SP + offset) and stick in register dest.
2521         emitImm(plusOp ,(Register) REG_SP, (RegValue) offset, dest,
2522                 gen, noCost, gen.rs());
2523         // Load LR into register dest
2524         emitV(loadIndirOp, dest, 0, dest, gen, noCost, gen.rs(),
2525               gen.width(), gen.point(), gen.addrSpace());
2526         break;
2527
2528     case registerSpace::ctr:
2529         // CTR is saved down the stack
2530         if (gen.width() == 4)
2531           offset = TRAMP_SPR_OFFSET(gen.width()) + STK_CTR_32;
2532         else
2533           offset = TRAMP_SPR_OFFSET(gen.width()) + STK_CTR_64;
2534
2535         // Get address (SP + offset) and stick in register dest.
2536         emitImm(plusOp ,(Register) REG_SP, (RegValue) offset, dest,
2537                 gen, noCost, gen.rs());
2538         // Load LR into register dest
2539         emitV(loadIndirOp, dest, 0, dest, gen, noCost, gen.rs(),
2540               gen.width(), gen.point(), gen.addrSpace());
2541       break;
2542
2543     default:
2544         cerr << "Fallthrough in emitLoadPreviousStackFrameRegister" << endl;
2545         cerr << "Unexpected register " << register_num << endl;
2546         assert(0);
2547         break;
2548     }
2549 }
2550
2551 void emitStorePreviousStackFrameRegister(Address,
2552                                          Register,
2553                                          codeGen &,
2554                                          int,
2555                                          bool) {
2556     assert(0);
2557 }
2558
2559 using namespace Dyninst::InstructionAPI; 
2560 bool AddressSpace::getDynamicCallSiteArgs(InstructionAPI::Instruction i,
2561                                           Address addr, 
2562                                           pdvector<AstNodePtr> &args)
2563 {
2564   static RegisterAST::Ptr ctr32(new RegisterAST(ppc32::ctr));
2565   static RegisterAST::Ptr ctr64(new RegisterAST(ppc64::ctr));
2566   static RegisterAST::Ptr lr32(new RegisterAST(ppc32::lr));
2567   static RegisterAST::Ptr lr64(new RegisterAST(ppc64::lr));
2568     Register branch_target = registerSpace::ignored;
2569
2570     // Is this a branch conditional link register (BCLR)
2571     // BCLR uses the xlform (6,5,5,5,10,1)
2572     for(Instruction::cftConstIter curCFT = i.cft_begin();
2573         curCFT != i.cft_end();
2574         ++curCFT)
2575     {
2576       if(curCFT->target->isUsed(ctr32) ||
2577          curCFT->target->isUsed(ctr64))
2578         {
2579             branch_target = registerSpace::ctr;
2580             break;
2581         }
2582       else if(curCFT->target->isUsed(lr32) ||
2583               curCFT->target->isUsed(lr64))
2584         {
2585           fprintf(stderr, "setting lr\n");
2586             branch_target = registerSpace::lr;
2587             break;
2588         }
2589     }
2590     if(branch_target != registerSpace::ignored)
2591     {
2592         // Where we're jumping to (link register, count register)
2593         args.push_back( AstNode::operandNode(AstNode::origRegister,
2594                         (void *) branch_target));
2595
2596         // Where we are now
2597         args.push_back( AstNode::operandNode(AstNode::Constant,
2598                         (void *) addr));
2599
2600         return true;
2601     }
2602     else
2603     {
2604       return false;
2605     }
2606 }
2607
2608 bool writeFunctionPtr(AddressSpace *p, Address addr, func_instance *f)
2609 {
2610     // 64-bit ELF PowerPC Linux uses r2 (same as AIX) for TOC base register
2611     if (p->getAddressWidth() == sizeof(uint64_t)) {
2612         Address val_to_write = f->addr();
2613         // Use function descriptor address, if available.
2614         if (f->getPtrAddress()) val_to_write = f->getPtrAddress();
2615         return p->writeDataSpace((void *) addr,
2616                                  sizeof(val_to_write), &val_to_write);
2617     }
2618     else {
2619         // Originally copied from inst-x86.C
2620         // 32-bit ELF PowerPC Linux mutatee
2621         uint32_t val_to_write = (uint32_t)f->addr();
2622         return p->writeDataSpace((void *) addr,
2623                                  sizeof(val_to_write), &val_to_write);
2624     }
2625 }
2626
2627 Emitter *AddressSpace::getEmitter() 
2628 {
2629     static EmitterPOWER32Dyn emitter32Dyn;
2630     static EmitterPOWER64Dyn emitter64Dyn;
2631     static EmitterPOWER32Stat emitter32Stat;
2632     static EmitterPOWER64Stat emitter64Stat;
2633
2634     if (getAddressWidth() == 8) {
2635         if (proc()) {
2636             return &emitter64Dyn;
2637         }
2638         else return &emitter64Stat;
2639     }
2640     if (proc())
2641         return &emitter32Dyn;
2642     else
2643         return &emitter32Stat;
2644
2645     assert(0);
2646     return NULL;
2647 }
2648
2649 #define GET_IP      0x429f0005
2650 #define MFLR_30     0x7fc802a6
2651 #define ADDIS_30_30 0x3fde0000
2652 #define ADDI_30_30  0x3bde0000
2653 #define LWZ_11_30   0x817e0000
2654 #define ADDIS_11_30 0x3d7e0000
2655
2656 /*
2657  * If the target stub_addr is a glink stub, try to determine the actual
2658  * function called (through the GOT) and fill in that information.
2659  *
2660  * The function at stub_addr may not have been created when this method
2661  * is called.
2662  *
2663  * XXX Is this a candidate to move into general parsing code, or is
2664  *     this properly a Dyninst-only technique?
2665  */
2666 bool image::updatePltFunc(parse_func *caller_func, Address stub_addr)
2667 {
2668     unsigned int *stub;
2669     Address got2 = 0;
2670
2671     if(!getPltFuncs())
2672         return false;
2673
2674     // If we're calling an empty glink stub.
2675     unordered_map<Address, std::string>::iterator entry = pltFuncs->find(stub_addr);
2676     if (entry != pltFuncs->end() && entry->second == "@plt")
2677     {
2678         int state = 0;
2679
2680         // Find GOT2 value
2681         auto bl = caller_func->blocks();
2682         auto bit = bl.begin();
2683         for( ; bit != bl.end(); ++bit) {
2684           ParseAPI::Block * b = *bit;
2685           for(Address addr = b->start(); addr < b->end();
2686               addr += instruction::size()) // XXX 4
2687           {
2688             unsigned int * caller_insn = 
2689                 (unsigned int *)caller_func->isrc()->getPtrToInstruction(addr);
2690
2691             if (state == 0 && *caller_insn == GET_IP) {
2692                 got2 = addr + instruction::size();
2693                 ++state;
2694             } else if (state == 1 && *caller_insn == MFLR_30) {
2695                 ++state;
2696             } else if (state == 4) {
2697                 break;
2698             } 
2699             else if (state >= 2 && (*caller_insn & 0xffff0000) == ADDIS_30_30)
2700             {
2701                 got2 += ((signed short)(*caller_insn & 0x0000ffff)) << 16;
2702                 ++state;
2703             } 
2704             else if (state >= 2 && (*caller_insn & 0xffff0000) == ADDI_30_30)
2705             {
2706                 got2 += (signed short)(*caller_insn & 0x0000ffff);
2707                 ++state;
2708             }
2709           }
2710         }
2711         if (state != 4) return false;
2712
2713         // Find stub offset
2714         stub = (unsigned int *)
2715             caller_func->isrc()->getPtrToInstruction(stub_addr);
2716         int offset = 0;
2717         if ( (stub[0] & 0xffff0000) == LWZ_11_30) {
2718             offset = (signed short)(stub[0] & 0x0000ffff);
2719         } else if ( (stub[0] & 0xffff0000) == ADDIS_11_30) {
2720             offset &= (stub[0] & 0x0000ffff) << 16;
2721             offset &= (stub[1] & 0x0000ffff);
2722         }
2723
2724         // Update all PLT based structures
2725         Address plt_addr = got2 + offset;
2726         (*pltFuncs)[stub_addr] = (*pltFuncs)[plt_addr];
2727         getObject()->updateFuncBindingTable(stub_addr, plt_addr);
2728     }
2729     return true;
2730 }
2731
2732 bool EmitterPOWER::emitCallRelative(Register dest, Address offset, Register base, codeGen &gen){
2733     // Loads a saved register from the stack. 
2734     int imm = offset;
2735     if (gen.width() == 4) {
2736       if (((signed)MIN_IMM16 <= (signed)imm) && ((signed)imm <= (signed)MAX_IMM16))
2737         {
2738           insnCodeGen::generateImm (gen, CALop, dest, base, imm);
2739
2740         }
2741       else if (((signed)MIN_IMM32 <= (signed)imm) && ((signed)imm <= (signed)MAX_IMM32))
2742         {
2743           insnCodeGen::generateImm (gen, CAUop, dest, 0, BOT_HI (offset));
2744           insnCodeGen::generateImm (gen, ORILop, dest, dest, BOT_LO (offset));
2745           insnCodeGen::generateAddReg (gen, CAXop, dest, dest, base);
2746         }
2747         else {
2748                 assert(0);
2749         }
2750         
2751     }
2752     else {
2753 /*        insnCodeGen::generateMemAccess64(gen, LDop, LDxop,
2754                                          dest,
2755                                          base,
2756                                          offset);
2757 */
2758     }
2759     return true;
2760 }
2761
2762 bool EmitterPOWER::emitLoadRelative(Register dest, Address offset, Register base, int size, codeGen &gen){ 
2763   if (((long)MIN_IMM16 <= (long)offset) && ((long) offset <= (long)MAX_IMM16)) {
2764     int ocode = Lop;
2765     switch (size) {
2766     case 1:
2767       ocode = LBZop;
2768       break;
2769     case 2:
2770       ocode = LHZop;
2771       break;
2772     case 4:
2773       ocode = Lop;
2774       break;
2775     case 8:
2776       ocode = LDop;
2777       break;
2778     default:
2779       return false;
2780       break;
2781     }
2782     insnCodeGen::generateImm (gen, ocode, dest, base, offset);    
2783   }
2784   else {
2785     // We're about to stomp dest to get a number in it... make sure that
2786     // it's not also the base register
2787     assert(dest != base); 
2788     Register scratch = dest;
2789     if (dest == base) {
2790       // Can't use it because base holds a value we need
2791       scratch = gen.rs()->getScratchRegister(gen, true);
2792     }
2793
2794     insnCodeGen::loadImmIntoReg(gen, scratch, offset);
2795
2796     int ocode = LXop;
2797     int xcode = 0;
2798     switch (size) {
2799     case 1:
2800       xcode = LBZXxop;
2801       break;
2802     case 2:
2803       xcode = LHZXxop;
2804       break;
2805     case 4:
2806       xcode = LXxop;
2807       break;
2808     case 8:
2809       xcode = LDXxop;
2810       break;
2811     default:
2812       printf(" Unrecognized size for load operation(%d). Assuming size of 4 \n", size);
2813       return false;
2814       break;
2815     }
2816     
2817     instruction insn; insn.clear();
2818     XFORM_OP_SET(insn, ocode);
2819     XFORM_RT_SET(insn, dest);
2820     XFORM_RA_SET(insn, scratch);
2821     XFORM_RB_SET(insn, base);
2822     XFORM_XO_SET(insn, xcode);
2823     XFORM_RC_SET(insn, 0);
2824     insnCodeGen::generate(gen, insn);
2825   }
2826   return true;
2827 }
2828
2829
2830 void EmitterPOWER::emitStoreRelative(Register source, Address offset, Register base, int size, codeGen &gen){
2831   if (((long)MIN_IMM16 <= (long)offset) && ((long) offset <= (long)MAX_IMM16)) {
2832     int ocode = STop;
2833     switch (size) {
2834     case 1:
2835       ocode = STBop;
2836       break;
2837     case 2:
2838       ocode = STHop;
2839       break;
2840     case 4:
2841       ocode = STop;
2842       break;
2843     case 8:
2844       ocode = STDop;
2845       break;
2846     default:
2847       //return false;
2848       assert(0);
2849       break;
2850     }
2851     insnCodeGen::generateImm (gen, ocode, source, base, offset);    
2852   }
2853   else {
2854     Register scratch = gen.rs()->getScratchRegister(gen, true);
2855     assert(scratch != REG_NULL);
2856
2857     insnCodeGen::loadImmIntoReg(gen, scratch, offset);
2858
2859     int ocode = STXop;
2860     int xcode = 0;
2861     switch (size) {
2862     case 1:
2863       xcode = STBXxop;
2864       break;
2865     case 2:
2866       xcode = STHXxop;
2867       break;
2868     case 4:
2869       xcode = STXxop;
2870       break;
2871     case 8:
2872       xcode = STDXxop;
2873       break;
2874     default:
2875       printf(" Unrecognized size for load operation(%d). Assuming size of 4 \n", size);
2876       //return false;
2877       assert(0);
2878       break;
2879     }
2880     
2881     instruction insn; insn.clear();
2882     XFORM_OP_SET(insn, ocode);
2883     XFORM_RT_SET(insn, source);
2884     XFORM_RA_SET(insn, scratch);
2885     XFORM_RB_SET(insn, base);
2886     XFORM_XO_SET(insn, xcode);
2887     XFORM_RC_SET(insn, 0);
2888     insnCodeGen::generate(gen, insn);
2889   }
2890   //return true;
2891 }
2892
2893 bool EmitterPOWER::emitMoveRegToReg(registerSlot *src,
2894                                     registerSlot *dest,
2895                                     codeGen &gen) {
2896     assert(dest->type == registerSlot::GPR);
2897
2898     switch (src->type) {
2899     case registerSlot::GPR:
2900         insnCodeGen::generateImm(gen, ORILop, src->encoding(), dest->encoding(), 0);
2901         break;
2902     case registerSlot::SPR: {
2903         instruction insn;
2904         
2905         switch (src->number) {
2906         case registerSpace::lr:
2907         case registerSpace::xer:
2908         case registerSpace::ctr:
2909         case registerSpace::mq:
2910             insn.clear();
2911             XFORM_OP_SET(insn, EXTop);
2912             XFORM_RT_SET(insn, dest->encoding());
2913             XFORM_RA_SET(insn, src->encoding() & 0x1f);
2914             XFORM_RB_SET(insn, (src->encoding() >> 5) & 0x1f);
2915             XFORM_XO_SET(insn, MFSPRxop);
2916             insnCodeGen::generate(gen,insn);
2917             break;
2918         case registerSpace::cr:
2919             insn.clear();                    //mtcrf:  scratchReg
2920             XFXFORM_OP_SET(insn, EXTop);
2921             XFXFORM_RT_SET(insn, dest->encoding());
2922             XFXFORM_XO_SET(insn, MFCRxop);
2923             insnCodeGen::generate(gen,insn);
2924             break;
2925         default:
2926             assert(0);
2927             break;
2928         }
2929         break;
2930     }
2931
2932     default:
2933         assert(0);
2934         break;
2935     }
2936     return true;
2937 }
2938
2939 /*
2940 bool EmitterPOWER32Stat::emitPIC(codeGen& gen, Address origAddr, Address relocAddr) {
2941
2942       Register scratchPCReg = gen.rs()->getScratchRegister(gen, true);
2943       pdvector<Register> excludeReg;
2944       excludeReg.push_back(scratchPCReg);
2945       Register scratchReg = gen.rs()->getScratchRegister(gen, excludeReg, true);
2946       bool newStackFrame = false;
2947       int stack_size = 0;
2948       int gpr_off, fpr_off, ctr_off;
2949       //fprintf(stderr, " emitPIC origAddr 0x%lx reloc 0x%lx Registers PC %d scratch %d \n", origAddr, relocAddr, scratchPCReg, scratchReg);
2950       if ((scratchPCReg == REG_NULL) || (scratchReg == REG_NULL)) {
2951                 //fprintf(stderr, " Creating new stack frame for 0x%lx to 0x%lx \n", origAddr, relocAddr);
2952
2953                 newStackFrame = true;
2954                 //create new stack frame
2955                 gpr_off = TRAMP_GPR_OFFSET_32;
2956                 fpr_off = TRAMP_FPR_OFFSET_32;
2957                 ctr_off = STK_CTR_32;
2958
2959                 // Make a stack frame.
2960                 pushStack(gen);
2961
2962                 // Save GPRs
2963               stack_size = saveGPRegisters(gen, gen.rs(), gpr_off, 2);
2964
2965               scratchPCReg = gen.rs()->getScratchRegister(gen, true);
2966               assert(scratchPCReg != REG_NULL);
2967               excludeReg.clear();
2968               excludeReg.push_back(scratchPCReg);
2969               scratchReg = gen.rs()->getScratchRegister(gen, excludeReg, true);
2970               assert(scratchReg != REG_NULL);
2971               // relocaAddr has moved since we added instructions to setup a new stack frame
2972               relocAddr = relocAddr + ((stack_size + 1)*(gen.width()));
2973               //fprintf(stderr, " emitPIC origAddr 0x%lx reloc 0x%lx stack size %d Registers PC %d scratch %d \n", origAddr, relocAddr, stack_size, scratchPCReg, scratchReg);
2974
2975         } 
2976         emitMovePCToReg(scratchPCReg, gen);     
2977         Address varOffset = origAddr - relocAddr;
2978         emitCallRelative(scratchReg, varOffset, scratchPCReg, gen);
2979         insnCodeGen::generateMoveToLR(gen, scratchReg);
2980         if(newStackFrame) {
2981               // GPRs
2982               restoreGPRegisters(gen, gen.rs(), gpr_off);
2983               popStack(gen);
2984         }
2985
2986       return 0;
2987 }
2988
2989 bool EmitterPOWER64Stat::emitPIC(codeGen& gen, Address origAddr, Address relocAddr) {
2990         assert(0);
2991         return false;
2992 }
2993 bool EmitterPOWERDyn::emitPIC(codeGen &gen, Address origAddr, Address relocAddr) {
2994
2995         Address origRet = origAddr + 4;
2996         Register scratch = gen.rs()->getScratchRegister(gen, true);
2997         assert(scratch != REG_NULL);
2998         instruction::loadImmIntoReg(gen, scratch, origRet);
2999         insnCodeGen::generateMoveToLR(gen, scratch);
3000         return true;
3001
3002 }
3003 */
3004
3005
3006 // It seems like we should be able to do a better job...
3007 bool EmitterPOWER32Stat::emitCallInstruction(codeGen& gen, func_instance* callee, bool /* setTOC */, Address) {
3008 // 32 - No TOC 
3009 // if inter module, gen PIC code
3010   if (gen.func()->obj() != callee->obj()) {
3011     return emitPLTCall(callee, gen);
3012   }
3013   //fprintf(stderr, "info: %s:%d: \n", __FILE__, __LINE__); 
3014   insnCodeGen::generateCall(gen, gen.currAddr(), callee->addr());
3015   return true;
3016 }
3017
3018 bool EmitterPOWER32Stat::emitPLTCommon(func_instance *callee, bool call, codeGen &gen) {
3019   Register scratchReg = gen.rs()->getScratchRegister(gen, true);
3020   if (scratchReg == REG_NULL) return false;
3021
3022   Register scratchLR = REG_NULL;
3023   std::vector<Register> excluded; excluded.push_back(scratchReg);
3024   scratchLR = gen.rs()->getScratchRegister(gen, excluded, true);
3025   if (scratchLR == REG_NULL) {
3026     if (scratchReg == registerSpace::r0) return false;
3027     // We can use r0 for this, since it's volatile. 
3028     scratchLR = registerSpace::r0;
3029   }
3030
3031   if (!call) {
3032     // Save the LR in scratchLR
3033     insnCodeGen::generateMoveFromLR(gen, scratchLR);
3034   }
3035
3036   // Generate the PLT call
3037
3038   Address dest = getInterModuleFuncAddr(callee, gen);  
3039   Address pcVal = emitMovePCToReg(scratchReg, gen);
3040
3041   if (!call) {
3042     insnCodeGen::generateMoveToLR(gen, scratchLR);
3043   }
3044
3045   // We can now use scratchLR
3046
3047   Address varOffset = dest - pcVal;
3048   emitLoadRelative(scratchLR, varOffset, scratchReg, gen.width(), gen);
3049   
3050   insnCodeGen::generateMoveToCR(gen, scratchLR);
3051
3052   if (!call) {
3053     instruction br(BCTRraw);
3054     insnCodeGen::generate(gen, br);
3055   }
3056   else {
3057     instruction brl(BCTRLraw);
3058     insnCodeGen::generate(gen, brl);
3059   }
3060
3061   return true;
3062 }
3063
3064
3065 // TODO 32/64-bit? 
3066 bool EmitterPOWER32Stat::emitPLTCall(func_instance *callee, codeGen &gen) {
3067   return emitPLTCommon(callee, true, gen);
3068 }
3069
3070 bool EmitterPOWER32Stat::emitPLTJump(func_instance *callee, codeGen &gen) {
3071   return emitPLTCommon(callee, false, gen);
3072 }
3073
3074 bool EmitterPOWER32Stat::emitTOCCall(block_instance *block, codeGen &gen) {
3075   return emitTOCCommon(block, true, gen);
3076 }
3077
3078 bool EmitterPOWER32Stat::emitTOCJump(block_instance *block, codeGen &gen) {
3079   return emitTOCCommon(block, false, gen);
3080 }
3081
3082
3083 bool EmitterPOWER32Stat::emitTOCCommon(block_instance *block, bool call, codeGen &gen) {
3084   Register scratchReg = gen.rs()->getScratchRegister(gen, true);
3085   if (scratchReg == REG_NULL) return false;
3086
3087   Register scratchLR = REG_NULL;
3088   std::vector<Register> excluded; excluded.push_back(scratchReg);
3089   scratchLR = gen.rs()->getScratchRegister(gen, excluded, true);
3090   if (scratchLR == REG_NULL) {
3091     if (scratchReg == registerSpace::r0) return false;
3092     // We can use r0 for this, since it's volatile. 
3093     scratchReg = registerSpace::r0;
3094   }
3095
3096   if (!call) {
3097     // Save the LR in scratchLR
3098     insnCodeGen::generateMoveFromLR(gen, scratchLR);
3099   }
3100
3101   // Generate the PLT call
3102
3103   Address dest = block->llb()->firstInsnOffset();
3104   Address pcVal = emitMovePCToReg(scratchReg, gen);
3105
3106   if (!call) {
3107     insnCodeGen::generateMoveToLR(gen, scratchLR);
3108   }
3109
3110   // We can now use scratchLR
3111
3112   Address varOffset = dest - pcVal;
3113   emitLoadRelative(scratchLR, varOffset, scratchReg, gen.width(), gen);
3114   
3115   insnCodeGen::generateMoveToCR(gen, scratchLR);
3116
3117   if (!call) {
3118     instruction br(BCTRraw);
3119     insnCodeGen::generate(gen, br);
3120   }
3121   else {
3122     instruction brl(BCTRLraw);
3123     insnCodeGen::generate(gen, brl);
3124   }
3125
3126   return true;
3127 }
3128
3129 bool EmitterPOWER64Stat::emitPLTCommon(func_instance *callee, bool call, codeGen &gen) {
3130   // Okay, I'm going to try and describe how this works. 
3131   //
3132   // PPC64 uses a TOC, a range of memory pointed to by R2. The TOC is full of 
3133   // data pointers (64-bit pointers).
3134   //
3135   // For our purpose, a TOC entry _points to_ a function descriptor, which is 3 words:
3136   //   1) Function addr
3137   //   2) TOC value
3138   //   3) Environment pointer (optional)
3139   //
3140   // For a dynamic binary, we need to do the following to perform a PLT jump/call:
3141   //   1) Set the destination
3142   //   2) Set the TOC to the destination's value
3143   // We do so as follows:
3144   //   1) func_desc <- getInterModuleFuncAddr(callee)  // this is an allocated function descriptor
3145   //                                                   // that isn't allocated relative to the TOC,
3146   //                                                   // if I'm reading things right...
3147   //   2) r_tmp := func_desc
3148   //   3) r2 := *(r_tmp + 8)
3149   //   4) r_tmp2 := *(r_tmp)
3150   //   5) ctr := r_tmp2
3151   //   6) bctr/bctrl
3152   // 
3153   //   This code implies that we can reuse r_tmp for r_tmp2. 
3154   //
3155   // Now, we make things better; we also need to reset r2 when we're done. How do we do this for
3156   // a branch, which doesn't return control? I'm glad you asked!
3157   // If we save the LR, we can have control return to our current execution point, restore LR,
3158   // and then return again. So we get code like the following:
3159   //
3160   //  1) save LR
3161   //  2) r_tmp := func_desc
3162   //  3) r2 := *(r_tmp + 8)
3163   //  4) r_tmp := *(r_tmp)
3164   //  5) lr := r_tmp
3165   //  6) blrl
3166   //  7) if (!call) restore LR
3167   //  8) r2 := caller TOC value
3168   //  9) (if branch) return
3169   //
3170
3171   // Even if we're in a static binary we may need to change the TOC. Heck,
3172   // we may need to change the TOC in an intra-module call no matter what.
3173   // This is caused by a GOT that is larger than 64k (the only addressable
3174   // distance from the TOC). 
3175   //
3176   // TODO: the large model where everything is a 32-bit reference off the TOC. 
3177
3178   const unsigned TOCreg = 2;
3179   const unsigned wordsize = gen.width();
3180   assert(wordsize == 8);
3181
3182   Address func_desc = getInterModuleFuncAddr(callee, gen);
3183
3184   Address caller_toc = 0;
3185   if (gen.func()) {
3186     caller_toc = gen.addrSpace()->getTOCoffsetInfo(gen.func());
3187   }
3188   else if (gen.point()) {
3189     caller_toc = gen.addrSpace()->getTOCoffsetInfo(gen.point()->func());
3190   }
3191   else {
3192     // Don't need it, and this might be an iRPC
3193   }
3194
3195   // We need a scratch register and a place to store the LR. However, in 64-bit PPC, there
3196   // are two words on the stack that are free at SP + 3W and SP + 4W. So we save r0 and LR there.
3197
3198   // Save R0 and LR
3199   unsigned r_tmp = 12; // R12 ; using R0 is dangerous since many memory operations treat it as 0. 
3200   insnCodeGen::generateMemAccess64(gen, STDop, STDxop, r_tmp, REG_SP, 3*wordsize);
3201   insnCodeGen::generateMoveFromLR(gen, r_tmp);
3202   insnCodeGen::generateMemAccess64(gen, STDop, STDxop, r_tmp, REG_SP, 4*wordsize);
3203
3204   // Save R2
3205   insnCodeGen::generateMemAccess64(gen, STDop, STDxop, TOCreg, REG_SP, 5*wordsize);
3206
3207   // r_tmp := func_desc
3208   // We don't load func_desc directly, as it's an offset rather than an address. 
3209   // What we can do though is load it relative to a different register value. Like, 
3210   // say, the current TOC. 
3211   Address func_desc_from_TOC = func_desc - caller_toc;
3212   insnCodeGen::loadImmIntoReg(gen, r_tmp, func_desc_from_TOC);
3213   if (caller_toc) {
3214     // If we know what the value is in R2 and thus used it...
3215     insnCodeGen::generateAddReg(gen, CAXop, r_tmp, r_tmp, TOCreg);
3216   }
3217
3218   // r2 := *(r_tmp + 8)
3219   insnCodeGen::generateMemAccess64(gen, LDop, LDxop, TOCreg, r_tmp, wordsize);
3220
3221   // r_tmp := *(r_tmp)
3222   insnCodeGen::generateMemAccess64(gen, LDop, LDxop, r_tmp, r_tmp, 0);
3223   
3224   // lr := r_tmp;
3225   insnCodeGen::generateMoveToLR(gen, r_tmp);
3226
3227   // Restore r_tmp to be sure
3228   //insnCodeGen::generateMemAccess64(gen, LDop, LDxop, r_tmp, REG_SP, 3*wordsize);
3229
3230   // blrl
3231   instruction branch_insn(BRLraw);
3232   insnCodeGen::generate(gen, branch_insn);
3233
3234   // if (!call) restore LR
3235   if (!call) {
3236     insnCodeGen::generateMemAccess64(gen, STDop, STDxop, r_tmp, REG_SP, 3*wordsize);
3237     insnCodeGen::generateMemAccess64(gen, LDop, LDxop, r_tmp, REG_SP, 4*wordsize);
3238     insnCodeGen::generateMoveToLR(gen, r_tmp);
3239     insnCodeGen::generateMemAccess64(gen, LDop, LDxop, r_tmp, REG_SP, 3*wordsize);
3240   }
3241
3242   // Restore TOC
3243   insnCodeGen::generateMemAccess64(gen, LDop, LDxop, TOCreg, REG_SP, 5*wordsize);
3244
3245   if (!call) {
3246     instruction ret(BRraw);
3247     insnCodeGen::generate(gen, ret);
3248   }
3249  
3250   return true;
3251 }
3252
3253 bool EmitterPOWER64Dyn::emitTOCCommon(block_instance *block, bool call, codeGen &gen) {
3254   // This code is complicated by the need to set the new TOC and restore it
3255   // post-(call/branch). That means we can't use a branch if asked, since we won't
3256   // regain control. Fun. 
3257   //
3258   // However, we can abuse the compiler word on the stack (SP + 3W) to store temporaries.
3259   //
3260   // So, we use the following:
3261   //
3262   // IF (!call)
3263   //   Save LR in <SP + 3W>
3264   // LR := Address of callee (Optimization: we can use a short branch here); use TOC as it's free
3265   // R2 := TOC of callee
3266   // Call LR
3267   // IF (!call)
3268   //   Restore LR from <SP + 3W>
3269   // R2 := TOC of caller
3270   // IF (!call)
3271   //   Return
3272
3273   const unsigned TOCreg = 2;
3274   const unsigned wordsize = gen.width();
3275   assert(wordsize == 8);
3276   Address dest = block->start();
3277
3278   // We need the callee TOC, which we find by function, not by block. 
3279   std::vector<func_instance *> funcs;
3280   block->getFuncs(std::back_inserter(funcs));
3281   Address callee_toc = gen.addrSpace()->getTOCoffsetInfo(funcs[0]);
3282   
3283   Address caller_toc = 0;
3284   if (gen.func()) {
3285     caller_toc = gen.addrSpace()->getTOCoffsetInfo(gen.func());
3286   }
3287   else if (gen.point()) {
3288     assert(gen.point()->func());
3289     caller_toc = gen.addrSpace()->getTOCoffsetInfo(gen.point()->func());
3290   }
3291   else {
3292     // Don't need it, and this might be an iRPC
3293   }
3294
3295   if (!call) {
3296     insnCodeGen::generateMoveFromLR(gen, TOCreg);
3297     insnCodeGen::generateMemAccess64(gen, STDop, STDxop,
3298                                      TOCreg, REG_SP, 3*wordsize);
3299   }
3300                                      
3301   // Use the TOC to generate the destination address
3302   insnCodeGen::loadImmIntoReg(gen, TOCreg, dest);
3303   insnCodeGen::generateMoveToLR(gen, TOCreg);
3304   
3305   // Load the callee TOC
3306   insnCodeGen::loadImmIntoReg(gen, TOCreg, callee_toc);
3307   
3308   instruction branch_insn(BRLraw);
3309   insnCodeGen::generate(gen, branch_insn);
3310
3311   if (!call) {
3312     insnCodeGen::generateMemAccess64(gen, LDop, LDxop,
3313                                      TOCreg, REG_SP, 3*wordsize);
3314     insnCodeGen::generateMoveToLR(gen, TOCreg);
3315   }  
3316
3317   insnCodeGen::loadImmIntoReg(gen, TOCreg, caller_toc);
3318
3319   if (!call) {
3320     instruction ret(BRraw);
3321     insnCodeGen::generate(gen, ret);
3322   }
3323   
3324   return true;
3325 }
3326
3327 // TODO 32/64-bit? 
3328 bool EmitterPOWER64Stat::emitPLTCall(func_instance *callee, codeGen &gen) {
3329   return emitPLTCommon(callee, true, gen);
3330 }
3331
3332 bool EmitterPOWER64Stat::emitPLTJump(func_instance *callee, codeGen &gen) {
3333   return emitPLTCommon(callee, false, gen);
3334 }
3335
3336 bool EmitterPOWER64Stat::emitTOCCall(block_instance *block, codeGen &gen) {
3337   return emitTOCCommon(block, true, gen);
3338 }
3339
3340 bool EmitterPOWER64Stat::emitTOCJump(block_instance *block, codeGen &gen) {
3341   return emitTOCCommon(block, false, gen);
3342 }
3343
3344 bool EmitterPOWER64Stat::emitTOCCommon(block_instance *block, bool call, codeGen &gen) {
3345   // Right now we can only jump to a block if it's the entry of a function
3346   // since it needs a relocation entry, which implies symbols, which implies... a function.
3347   // Theoretically, we could create symbols for this block, if anyone ever cares.
3348   std::vector<func_instance *> funcs;
3349   block->getFuncs(std::back_inserter(funcs));
3350   for (unsigned i = 0; i < funcs.size(); ++i) {
3351     if (block == funcs[i]->entry()) {
3352       return emitPLTCommon(funcs[i], call, gen);
3353     }
3354   }
3355   return false;
3356 }
3357
3358 bool EmitterPOWER64Stat::emitCallInstruction(codeGen &gen,
3359                                              func_instance *callee,
3360                                              bool setTOC, Address) {
3361     // if the TOC changes, generate a PIC call
3362     Address dest =  callee->addr();
3363     if( dest == 0)
3364         dest = getInterModuleFuncAddr(callee, gen);
3365
3366  
3367
3368 //    if (setTOC) {
3369     if (gen.func()->obj() != callee->obj()) {
3370         return emitPLTCall(callee, gen);
3371     }
3372
3373     insnCodeGen::generateCall(gen, gen.currAddr(), dest);
3374     return true;
3375 }
3376
3377 // Generates call instruction sequence for all POWER-based systems
3378 // under dynamic instrumentation.
3379 //
3380 // This should be able to stomp on the link register (LR) and TOC
3381 // register (r2), as they were saved by Emitter::emitCall() as necessary.
3382 bool EmitterPOWER::emitCallInstruction(codeGen &gen, func_instance *callee, bool setTOC, Address toc_anchor) {
3383
3384     //fprintf(stderr, "info: %s:%d: \n", __FILE__, __LINE__); 
3385     bool needLongBranch = false;
3386     if (gen.startAddr() == (Address) -1) { // Unset...
3387         needLongBranch = true;
3388         //fprintf(stderr, "info: %s:%d: \n", __FILE__, __LINE__); 
3389         inst_printf("Unknown generation addr, long call required\n");
3390     }
3391     else {
3392         long displacement = callee->addr() - gen.currAddr();
3393         // Increase the displacement to be conservative. 
3394         // We use fewer than 6 instructions, too. But again,
3395         // conservative.
3396         //fprintf(stderr, "info: %s:%d: %lu\n", __FILE__, __LINE__, displacement); 
3397         if ((ABS(displacement) + 6*instruction::size()) > MAX_BRANCH) {
3398             needLongBranch = true;
3399             //fprintf(stderr, "info: %s:%d: \n", __FILE__, __LINE__); 
3400             inst_printf("Need long call to get from 0x%lx to 0x%lx\n",
3401                     gen.currAddr(), callee->addr());
3402         }
3403     }
3404     bool shouldJumpToCMOD = false;
3405     // Need somewhere to put the destination calculation...
3406     int scratchReg = 0;
3407     if (needLongBranch) {
3408         // Use scratchReg to set destination of the call...
3409         shouldJumpToCMOD = true;
3410         inst_printf("[EmitterPOWER::EmitCallInstruction] needLongBranch, Emitting VLOAD  Callee: 0x%lx, ScratchReg: %u\n",
3411                     callee->addr(), (unsigned) scratchReg);
3412         emitVload(loadConstOp, callee->addr(), scratchReg, scratchReg, gen, false);
3413         //fprintf(stderr, "info: %s:%d: \n", __FILE__, __LINE__); 
3414         insnCodeGen::generateMoveToLR(gen, scratchReg);
3415
3416         inst_printf("Generated LR value in %d\n", scratchReg);
3417     }
3418
3419
3420     // Linux 64
3421     if (setTOC) {
3422         inst_printf("[EmitterPOWER::EmitCallInstruction] Setting TOC anchor, toc_anchor: %lx, register: 2(fixed)\n",
3423                     (uint64_t)toc_anchor);
3424         // Set up the new TOC value
3425         emitVload(loadConstOp, toc_anchor, 2, 2, gen, false);
3426         //fprintf(stderr, "info: %s:%d: \n", __FILE__, __LINE__); 
3427         //inst_printf("toc setup (%d)...");
3428         inst_printf("Set new TOC\n");
3429     }
3430
3431     // ALL dynamic; call instruction generation
3432     if (needLongBranch) {
3433         //insnCodeGen::generateCall(gen, gen.currAddr(), callee->addr());
3434         //fprintf(stderr, "info: %s:%d: \n", __FILE__, __LINE__); 
3435         emitVload(loadConstOp, callee->addr(), 12, 12, gen, false);
3436         instruction brl(BRLraw);
3437         insnCodeGen::generate(gen,brl);
3438         inst_printf("Generated BRL\n");
3439     }
3440     else {
3441         inst_printf("[EmitterPOWER::EmitCallInstruction] Generating Call, curAddress: %lx, calleeAddr: %lx\n",
3442                      gen.currAddr(), callee->addr());
3443         //fprintf(stderr, "info: %s:%d: \n", __FILE__, __LINE__); 
3444         emitVload(loadConstOp, callee->addr(), 12, 12, gen, false);
3445         // if (gen.currAddr() == 0x100000120f80) {
3446         //     fprintf(stderr, "we are here, break now\n");
3447         // } else {
3448         //     emitVload(loadConstOp, callee->addr(), 12, 12, gen, false);
3449         // }
3450         insnCodeGen::generateCall(gen, gen.currAddr(), callee->addr());
3451
3452         inst_printf("Generated short call from 0x%lx to 0x%lx\n",
3453                 gen.currAddr(), callee->addr());
3454     }
3455
3456     return true;
3457 }
3458
3459 void EmitterPOWER::emitLoadShared(opCode op, Register dest, const image_variable* var, bool is_local, int size, codeGen &gen, Address offset)
3460 {
3461    // create or retrieve jump slot
3462    Address addr;
3463    int stackSize = 0;
3464