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