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