Add xmm8-xmm15 liveness information/decoding.
[dyninst.git] / dyninstAPI / src / inst-x86.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-x86.C - x86 dependent functions and code generator
34  * $Id: inst-x86.C,v 1.289 2008/09/11 20:14:14 mlam Exp $
35  */
36 #include <iomanip>
37
38 #include <limits.h>
39 #include "common/h/headers.h"
40 #include "common/h/Dictionary.h"
41 #include "dyninstAPI/src/symtab.h"
42 #include "dyninstAPI/src/process.h"
43 #include "dyninstAPI/src/dyn_lwp.h"
44 #include "dyninstAPI/src/inst.h"
45 #include "dyninstAPI/src/instP.h"
46 #include "dyninstAPI/src/ast.h"
47 #include "dyninstAPI/src/util.h"
48 #include "common/h/stats.h"
49 #include "dyninstAPI/src/os.h"
50 #include "dyninstAPI/src/debug.h"
51 #include "dyninstAPI/src/function.h"
52 #include "dyninstAPI/src/codegen.h"
53 #include "dyninstAPI/src/inst-x86.h"
54 #include "dyninstAPI/src/miniTramp.h"
55 #include "dyninstAPI/src/baseTramp.h"
56 #include "dyninstAPI/src/emit-x86.h"
57 #include "dyninstAPI/src/instPoint.h" // includes instPoint-x86.h
58
59 #include "dyninstAPI/src/addressSpace.h"
60 #include "dyninstAPI/src/binaryEdit.h"
61
62 #include "dyninstAPI/src/registerSpace.h"
63
64 #include "dyninstAPI/src/instP.h" // class returnInstance
65 #include "dyninstAPI/src/rpcMgr.h"
66 #include "dyninstAPI/src/dyn_thread.h"
67 #include "mapped_module.h"
68 #include "dyninstAPI/h/BPatch_memoryAccess_NP.h"
69 #include "IAPI_to_AST.h"
70 #include "Expression.h"
71 #include "Instruction.h"
72 #include <sstream>
73 #include <assert.h>
74
75 class ExpandInstruction;
76 class InsertNops;
77
78 extern bool relocateFunction(process *proc, instPoint *&location);
79
80 extern "C" int cpuidCall();
81
82 /****************************************************************************/
83 /****************************************************************************/
84 /****************************************************************************/
85
86
87
88 /****************************************************************************/
89 /****************************************************************************/
90 /****************************************************************************/
91
92 /* A quick model for the "we're done, branch back/ILL" tramp end */
93
94
95 /*
96  * Worst-case scenario for how much room it will take to relocate
97  * an instruction -- used for allocating the new area
98  */
99 unsigned relocatedInstruction::maxSizeRequired() {
100     return insn->spaceToRelocate();
101 }
102
103 void registerSpace::initialize32() {
104     static bool done = false;
105     if (done) return;
106     done = true;
107
108     // On 32-bit x86 we use stack slots as "registers"; therefore we can
109     // create an arbitrary number, and use them. However, this can bite us
110     // if we want to use actual registers. Any ideas?
111     
112     pdvector<registerSlot *> registers;
113
114     // When we use 
115     registerSlot *eax = new registerSlot(REGNUM_EAX,
116                                         "eax",
117                                         false, // Off-limits due to our "stack slot" register mechanism
118                                         registerSlot::liveAlways,
119                                         registerSlot::realReg);
120     registerSlot *ecx = new registerSlot(REGNUM_ECX,
121                                         "ecx",
122                                         false,
123                                         registerSlot::liveAlways,
124                                         registerSlot::realReg);
125     registerSlot *edx = new registerSlot(REGNUM_EDX,
126                                         "edx",
127                                         false,
128                                         registerSlot::liveAlways,
129                                         registerSlot::realReg);
130     registerSlot *ebx = new registerSlot(REGNUM_EBX,
131                                         "ebx",
132                                         false,
133                                         registerSlot::liveAlways,
134                                         registerSlot::realReg);
135     registerSlot *esp = new registerSlot(REGNUM_ESP,
136                                         "esp",
137                                         true, // Off-limits...
138                                         registerSlot::liveAlways,
139                                         registerSlot::realReg); // I'd argue the SP is a special-purpose reg
140     registerSlot *ebp = new registerSlot(REGNUM_EBP,
141                                         "ebp",
142                                         true,
143                                         registerSlot::liveAlways,
144                                         registerSlot::realReg);
145     registerSlot *esi = new registerSlot(REGNUM_ESI,
146                                         "esi",
147                                         false,
148                                         registerSlot::liveAlways,
149                                         registerSlot::realReg);
150     registerSlot *edi = new registerSlot(REGNUM_EDI,
151                                         "edi",
152                                         false,
153                                         registerSlot::liveAlways,
154                                         registerSlot::realReg);
155     
156     registers.push_back(eax);
157     registers.push_back(ecx);
158     registers.push_back(edx);
159     registers.push_back(ebx);
160     registers.push_back(esp);
161     registers.push_back(ebp);
162     registers.push_back(esi);
163     registers.push_back(edi);
164
165     // FPRs...
166
167     // SPRs...
168     
169     // "Virtual" registers
170     for (unsigned i = 1; i <= NUM_VIRTUAL_REGISTERS; i++) {
171                 char buf[128];
172         sprintf(buf, "virtGPR%d", i);
173
174         registerSlot *virt = new registerSlot(i,
175                                               buf,
176                                               false,
177                                               registerSlot::deadAlways,
178                                               registerSlot::GPR);
179         registers.push_back(virt);
180     }
181     // Create a single FPR representation to represent
182     // whether any FPR is live
183     registerSlot *fpr = new registerSlot(IA32_FPR_VIRTUAL_REGISTER,
184                                          "virtFPR",
185                                          true, // off-limits...
186                                          registerSlot::liveAlways, // because we check this via overapproximation and not the
187                                          // regular liveness algorithm, start out *dead* and set live if written
188                                          registerSlot::FPR);
189     registers.push_back(fpr);
190
191     // And a "do we save the flags" "register"
192     registers.push_back(new registerSlot(IA32_FLAG_VIRTUAL_REGISTER,
193                                          "virtFlags",
194                                          true,
195                                          registerSlot::liveAlways,
196                                          registerSlot::SPR));
197     // Create the global register space
198     registerSpace::createRegisterSpace(registers);
199
200     // Define:
201     // callRead
202     // callWritten
203     // Fortunately, both are basically zero...
204     
205     // callRead: no change
206     // callWritten: write to the flags
207     // TODO FIXME
208
209     // Define:
210     // callRead - argument registers
211     // callWritten - RAX
212
213     // Can't use numRegisters here because we're depending
214     // on the REGNUM_FOO numbering
215 #if defined(cap_liveness)
216     returnRead_ = getBitArray();
217     // Return reads no registers
218
219     callRead_ = getBitArray();
220     // CallRead reads no registers
221     // We wish...
222     callRead_[REGNUM_ECX] = true;
223     callRead_[REGNUM_EDX] = true;
224
225     // PLT entries use ebx
226     callRead_[REGNUM_EBX] = true;
227
228     // TODO: Fix this for platform-specific calling conventions
229
230     // Assume calls write flags
231     callWritten_ = callRead_;
232     for (unsigned i = REGNUM_OF; i <= REGNUM_RF; i++) 
233         callWritten_[i] = true;
234
235
236     // And assume a syscall reads or writes _everything_
237     syscallRead_ = getBitArray().set();
238     syscallWritten_ = syscallRead_;
239
240     allRegs_ = getBitArray().set();
241 #endif
242 }
243
244 #if defined(cap_32_64)
245 void registerSpace::initialize64() {
246     static bool done = false;
247     if (done) return;
248     done = true;
249
250     // Create the 64-bit registers
251     // Well, let's just list them....
252
253     // Calling ABI:
254     // rax, rcx, rdx, r8, r9, r10, r11 are not preserved across a call
255     // However, rcx, rdx, r8, and r9 are used for arguments, and therefore
256     // should be assumed live. 
257     // So rax, r10, r11 are dead at a function call.
258
259     registerSlot * rax = new registerSlot(REGNUM_RAX,
260                                           "rax",
261                                           true, // We use it implicitly _everywhere_
262                                           registerSlot::deadABI,
263                                           registerSlot::GPR);
264     registerSlot * rcx = new registerSlot(REGNUM_RCX,
265                                           "rcx",
266                                           false,
267                                           registerSlot::liveAlways,
268                                           registerSlot::GPR);
269     registerSlot * rdx = new registerSlot(REGNUM_RDX,
270                                           "rdx",
271                                           false,
272                                           registerSlot::liveAlways,
273                                           registerSlot::GPR);
274     registerSlot * rbx = new registerSlot(REGNUM_RBX,
275                                           "rbx",
276                                           false,
277                                           registerSlot::liveAlways,
278                                           registerSlot::GPR);
279     registerSlot * rsp = new registerSlot(REGNUM_RSP,
280                                           "rsp",
281                                           true, // Off-limits...
282                                           registerSlot::liveAlways,
283                                           registerSlot::SPR); 
284     registerSlot * rbp = new registerSlot(REGNUM_RBP,
285                                           "rbp",
286                                           true,
287                                           registerSlot::liveAlways,
288                                           registerSlot::SPR);
289     registerSlot * rsi = new registerSlot(REGNUM_RSI,
290                                           "rsi",
291                                           false,
292                                           registerSlot::liveAlways,
293                                           registerSlot::GPR);
294     registerSlot * rdi = new registerSlot(REGNUM_RDI,
295                                           "rdi",
296                                           false,
297                                           registerSlot::liveAlways,
298                                           registerSlot::GPR);
299     registerSlot * r8 = new registerSlot(REGNUM_R8,
300                                          "r8",
301                                          false,
302                                          registerSlot::liveAlways,
303                                          registerSlot::GPR);
304     registerSlot * r9 = new registerSlot(REGNUM_R9,
305                                          "r9",
306                                          false,
307                                          registerSlot::liveAlways,
308                                          registerSlot::GPR);
309     registerSlot * r10 = new registerSlot(REGNUM_R10,
310                                           "r10",
311                                           false,
312                                           registerSlot::deadABI,
313                                           registerSlot::GPR);
314     registerSlot * r11 = new registerSlot(REGNUM_R11,
315                                           "r11",
316                                           false,
317                                           registerSlot::deadABI,
318                                           registerSlot::GPR);
319     registerSlot * r12 = new registerSlot(REGNUM_R12,
320                                           "r12",
321                                           false,
322                                           registerSlot::liveAlways,
323                                           registerSlot::GPR);
324     registerSlot * r13 = new registerSlot(REGNUM_R13,
325                                           "r13",
326                                           false,
327                                           registerSlot::liveAlways,
328                                           registerSlot::GPR);
329     registerSlot * r14 = new registerSlot(REGNUM_R14,
330                                           "r14",
331                                           false,
332                                           registerSlot::liveAlways,
333                                           registerSlot::GPR);
334     registerSlot * r15 = new registerSlot(REGNUM_R15,
335                                           "r15",
336                                           false,
337                                           registerSlot::liveAlways,
338                                           registerSlot::GPR);
339
340     pdvector<registerSlot *> registers;
341     registers.push_back(rax);
342     registers.push_back(rbx);
343     registers.push_back(rsp);
344     registers.push_back(rbp);
345     registers.push_back(r10);
346     registers.push_back(r11);
347     registers.push_back(r12);
348     registers.push_back(r13);
349     registers.push_back(r14);
350     registers.push_back(r15);
351
352     // Put the call parameter registers last so that we are not
353     // likely to allocate them for general purposes
354     registers.push_back(r8);
355     registers.push_back(r9);
356     registers.push_back(rcx);
357     registers.push_back(rdx);
358     registers.push_back(rsi);
359     registers.push_back(rdi);
360
361
362     registers.push_back(new registerSlot(REGNUM_OF,
363                                          "of",
364                                          true,
365                                          registerSlot::liveAlways,
366                                          registerSlot::SPR));
367     registers.push_back(new registerSlot(REGNUM_SF,
368                                          "sf",
369                                          true,
370                                          registerSlot::liveAlways,
371                                          registerSlot::SPR));
372     registers.push_back(new registerSlot(REGNUM_ZF,
373                                          "zf",
374                                          true,
375                                          registerSlot::liveAlways,
376                                          registerSlot::SPR));
377     registers.push_back(new registerSlot(REGNUM_AF,
378                                          "af",
379                                          true,
380                                          registerSlot::liveAlways,
381                                          registerSlot::SPR));
382     registers.push_back(new registerSlot(REGNUM_PF,
383                                          "pf",
384                                          true,
385                                          registerSlot::liveAlways,
386                                          registerSlot::SPR));
387     registers.push_back(new registerSlot(REGNUM_CF,
388                                          "cf",
389                                          true,
390                                          registerSlot::liveAlways,
391                                          registerSlot::SPR));
392     registers.push_back(new registerSlot(REGNUM_TF,
393                                          "tf",
394                                          true,
395                                          registerSlot::liveAlways,
396                                          registerSlot::SPR));
397     registers.push_back(new registerSlot(REGNUM_IF,
398                                          "if",
399                                          true,
400                                          registerSlot::liveAlways,
401                                          registerSlot::SPR));
402     registers.push_back(new registerSlot(REGNUM_DF,
403                                          "df",
404                                          true,
405                                          registerSlot::liveAlways,
406                                          registerSlot::SPR));
407     registers.push_back(new registerSlot(REGNUM_NT,
408                                          "nt",
409                                          true,
410                                          registerSlot::liveAlways,
411                                          registerSlot::SPR));
412     registers.push_back(new registerSlot(REGNUM_RF,
413                                          "rf",
414                                          true,
415                                          registerSlot::liveAlways,
416                                          registerSlot::SPR));
417
418     registers.push_back(new registerSlot(REGNUM_DUMMYFPR,
419                                          "dummyFPR",
420                                          true,
421                                          registerSlot::liveAlways, // because we check this via overapproximation and not the
422                                          // regular liveness algorithm, start out *dead* and set live if written
423                                          registerSlot::FPR));
424     registers.push_back(new registerSlot(REGNUM_MM0,
425                                          "MM0/ST(0)",
426                                          true,
427                                          registerSlot::liveAlways,
428                                          registerSlot::FPR));
429     registers.push_back(new registerSlot(REGNUM_MM1,
430                                          "MM1/ST(1)",
431                                          true,
432                                          registerSlot::liveAlways,
433                                          registerSlot::FPR));
434     registers.push_back(new registerSlot(REGNUM_MM2,
435                                          "MM2/ST(2)",
436                                          true,
437                                          registerSlot::liveAlways,
438                                          registerSlot::FPR));
439     registers.push_back(new registerSlot(REGNUM_MM3,
440                                          "MM3/ST(3)",
441                                          true,
442                                          registerSlot::liveAlways,
443                                          registerSlot::FPR));
444     registers.push_back(new registerSlot(REGNUM_MM4,
445                                          "MM4/ST(4)",
446                                          true,
447                                          registerSlot::liveAlways,
448                                          registerSlot::FPR));
449     registers.push_back(new registerSlot(REGNUM_MM5,
450                                          "MM5/ST(5)",
451                                          true,
452                                          registerSlot::liveAlways,
453                                          registerSlot::FPR));
454     registers.push_back(new registerSlot(REGNUM_MM6,
455                                          "MM6/ST(6)",
456                                          true,
457                                          registerSlot::liveAlways,
458                                          registerSlot::FPR));
459     registers.push_back(new registerSlot(REGNUM_MM7,
460                                          "MM7/ST(7)",
461                                          true,
462                                          registerSlot::liveAlways,
463                                          registerSlot::FPR));
464     registers.push_back(new registerSlot(REGNUM_XMM0,
465                                          "XMM0",
466                                          true,
467                                          registerSlot::liveAlways,
468                                          registerSlot::FPR));
469     registers.push_back(new registerSlot(REGNUM_XMM1,
470                                          "XMM1",
471                                          true,
472                                          registerSlot::liveAlways,
473                                          registerSlot::FPR));
474     registers.push_back(new registerSlot(REGNUM_XMM2,
475                                          "XMM2",
476                                          true,
477                                          registerSlot::liveAlways,
478                                          registerSlot::FPR));
479     registers.push_back(new registerSlot(REGNUM_XMM3,
480                                          "XMM3",
481                                          true,
482                                          registerSlot::liveAlways,
483                                          registerSlot::FPR));
484     registers.push_back(new registerSlot(REGNUM_XMM4,
485                                          "XMM4",
486                                          true,
487                                          registerSlot::liveAlways,
488                                          registerSlot::FPR));
489     registers.push_back(new registerSlot(REGNUM_XMM5,
490                                          "XMM5",
491                                          true,
492                                          registerSlot::liveAlways,
493                                          registerSlot::FPR));
494     registers.push_back(new registerSlot(REGNUM_XMM6,
495                                          "XMM6",
496                                          true,
497                                          registerSlot::liveAlways,
498                                          registerSlot::FPR));
499     registers.push_back(new registerSlot(REGNUM_XMM7,
500                                          "XMM7",
501                                          true,
502                                          registerSlot::liveAlways,
503                                          registerSlot::FPR));
504     registers.push_back(new registerSlot(REGNUM_XMM8,
505                         "XMM8",
506                         true,
507                         registerSlot::liveAlways,
508                         registerSlot::FPR));
509     registers.push_back(new registerSlot(REGNUM_XMM9,
510                         "XMM9",
511                         true,
512                         registerSlot::liveAlways,
513                         registerSlot::FPR));
514     registers.push_back(new registerSlot(REGNUM_XMM10,
515                         "XMM10",
516                         true,
517                         registerSlot::liveAlways,
518                         registerSlot::FPR));
519     registers.push_back(new registerSlot(REGNUM_XMM11,
520                         "XMM11",
521                         true,
522                         registerSlot::liveAlways,
523                         registerSlot::FPR));
524     registers.push_back(new registerSlot(REGNUM_XMM12,
525                         "XMM12",
526                         true,
527                         registerSlot::liveAlways,
528                         registerSlot::FPR));
529     registers.push_back(new registerSlot(REGNUM_XMM13,
530                         "XMM13",
531                         true,
532                         registerSlot::liveAlways,
533                         registerSlot::FPR));
534     registers.push_back(new registerSlot(REGNUM_XMM14,
535                         "XMM14",
536                         true,
537                         registerSlot::liveAlways,
538                         registerSlot::FPR));
539     registers.push_back(new registerSlot(REGNUM_XMM15,
540                         "XMM15",
541                         true,
542                         registerSlot::liveAlways,
543                         registerSlot::FPR));
544
545
546
547
548     // For registers that we really just don't care about.
549     registers.push_back(new registerSlot(REGNUM_IGNORED,
550                                          "ignored",
551                                          true,
552                                          registerSlot::liveAlways,
553                                          registerSlot::SPR));
554
555     registerSpace::createRegisterSpace64(registers);
556
557     // Define:
558     // callRead - argument registers
559     // callWritten - RAX
560
561 #if defined(cap_liveness)
562     returnRead64_ = getBitArray();
563     returnRead64_[REGNUM_RAX] = true;
564     returnRead64_[REGNUM_RCX] = true; //Not correct, temporary
565     // Returns also "read" any callee-saved registers
566     returnRead64_[REGNUM_RBX] = true;
567     returnRead64_[REGNUM_RDX] = true;
568     returnRead64_[REGNUM_R12] = true;
569     returnRead64_[REGNUM_R13] = true;
570     returnRead64_[REGNUM_R14] = true;
571     returnRead64_[REGNUM_R15] = true;
572
573     //returnRead64_[REGNUM_R10] = true;
574     
575
576     callRead64_ = getBitArray();
577     callRead64_[REGNUM_RCX] = true;
578     callRead64_[REGNUM_RDX] = true;
579     callRead64_[REGNUM_R8] = true;
580     callRead64_[REGNUM_R9] = true;
581     callRead64_[REGNUM_RDI] = true;
582     callRead64_[REGNUM_RSI] = true;
583
584     // Anything in those four is not preserved across a call...
585     // So we copy this as a shorthand then augment it
586     callWritten64_ = callRead64_;
587
588     // As well as RAX, R10, R11
589     callWritten64_[REGNUM_RAX] = true;
590     callWritten64_[REGNUM_R10] = true;
591     callWritten64_[REGNUM_R11] = true;
592     // And flags
593     for (unsigned i = REGNUM_OF; i <= REGNUM_RF; i++) 
594         callWritten64_[i] = true;
595
596     // What about floating point?
597
598     // And assume a syscall reads or writes _everything_
599     syscallRead64_ = getBitArray().set();
600     syscallWritten64_ = syscallRead_;
601
602     allRegs64_ = getBitArray().set();
603 #endif
604
605 }
606 #endif
607
608 void registerSpace::initialize()
609 {
610     static bool inited = false;
611     
612     if (inited) return;
613     inited = true;
614     if(xmmCapable())
615     {
616       hasXMM = true;
617     }
618     
619
620     initialize32();
621 #if defined(cap_32_64)
622     initialize64();
623 #endif
624 }
625
626 /* This makes a call to the cpuid instruction, which returns an int where each bit is 
627    a feature.  Bit 24 contains whether fxsave is possible, meaning that xmm registers
628    are saved. */
629 #if defined(os_windows)
630 int cpuidCall() {
631     DWORD result;
632     _asm {
633         xor eax, eax
634         cpuid
635         mov result, eax
636     }
637     return result;
638 }
639 #endif
640 #if !defined(x86_64_unknown_linux2_4) && !(defined(os_freebsd) && defined(arch_x86_64))
641 bool xmmCapable()
642 {
643   int features = cpuidCall();
644   char * ptr = (char *)&features;
645   ptr += 3;
646   if (0x1 & (*ptr))
647     return true;
648   else
649     return false;
650 }
651 #else
652 bool xmmCapable()
653 {
654   return true;
655 }
656 #endif
657
658 bool baseTramp::generateSaves(codeGen& gen, registerSpace*, baseTrampInstance *inst) {
659    return gen.codeEmitter()->emitBTSaves(this, inst, gen);
660 }
661
662 bool baseTramp::generateRestores(codeGen &gen, registerSpace*, baseTrampInstance *inst) {
663
664    return gen.codeEmitter()->emitBTRestores(this, inst, gen);
665 }
666
667 /****************************************************************************/
668 /****************************************************************************/
669 /****************************************************************************/
670
671 void emitJccR8(int condition_code, char jump_offset,
672                codeGen &gen) {
673     GET_PTR(insn, gen);
674     *insn++ = static_cast<unsigned char>(condition_code);
675     *insn++ = jump_offset;
676     SET_PTR(insn, gen);
677 }
678
679 // VG(8/15/02): nicer jcc: condition is the tttn field.
680 // Because we generate jumps twice, once with bogus 0
681 // offset, and then with the right offset, the instruction
682 // may be longer (and overwrite something else) the 2nd time.
683 // So willRegen defaults to true and always generates jcc near
684 // (the longer form)
685
686 // TODO: generate JEXCZ as well
687 void emitJcc(int condition, int offset,
688              codeGen &gen, bool willRegen) /* = true */
689 {
690    unsigned char opcode;
691    GET_PTR(insn, gen);
692    
693    assert(condition >= 0 && condition <= 0x0F);
694    
695    if(!willRegen && (offset >= -128 && offset <= 127)) { // jcc rel8
696       opcode = 0x70 | (unsigned char)condition;
697       *insn++ = opcode;
698       *insn++ = (unsigned char) (offset & 0xFF);
699    }
700    else { // jcc near rel32
701       opcode = 0x80 | (unsigned char)condition;
702       *insn++ = 0x0F;
703       *insn++ = opcode;
704       *((int*)insn) = offset;
705       insn += sizeof(int);
706    }
707    SET_PTR(insn, gen);
708 }
709
710 /****************************************************************************/
711 /****************************************************************************/
712 /****************************************************************************/
713
714
715 /****************************************************************************/
716 /****************************************************************************/
717 /****************************************************************************/
718
719 /**
720  * tramp_pre_frame_size is the amount of space the base trampoline allocates
721  * on the stack before setting up a stack frame.  It's needed to stack
722  * walk out of base tramps.  Should be treated as a constant, but the
723  * C++ scoping rules for const are stupid.
724  **/
725
726 int tramp_pre_frame_size_32 = 36; //Stack space allocated by 'pushf; pusha'
727
728 int tramp_pre_frame_size_64 = 8 + 16 * 8 + STACK_PAD_CONSTANT; // stack space allocated by pushing flags and 16 GPRs
729                                                 // and skipping the 128-byte red zone
730
731 bool can_do_relocation(process *proc,
732                        const pdvector<pdvector<Frame> > &stackWalks,
733                        int_function *instrumented_func)
734 {
735    bool can_do_reloc = true;
736
737    // for every vectors of frame, ie. thread stack walk, make sure can do
738    // relocation
739    Address begAddr = instrumented_func->getAddress();
740    for (unsigned walk_itr = 0; walk_itr < stackWalks.size(); walk_itr++) {
741      pdvector<int_function *> stack_funcs =
742        proc->pcsToFuncs(stackWalks[walk_itr]);
743      
744      // for every frame in thread stack walk
745      for(unsigned i=0; i<stack_funcs.size(); i++) {
746        int_function *stack_func = stack_funcs[i];
747        Address pc = stackWalks[walk_itr][i].getPC();
748        
749        if( stack_func == instrumented_func ) {
750          // Catchup doesn't occur on instPoinst in relocated function when
751          // the original function is on the stack.  This leads to the
752          // timer never being called for timer metrics.  A solution still
753          // needs to be worked out.
754          if(pc >= begAddr && pc <= begAddr+JUMP_REL32_SZ) {
755            // can't relocate since within first five bytes
756            can_do_reloc = false;
757          } else {
758              // Need to check whether each entry point has enough room
759              // to patch in a jump; technically, this is only needed
760              // if we're _in_ the function as control may transfer to
761              // the middle of the jump(s) out.
762
763              assert(0);
764          }
765          break;
766        }
767      }
768    }
769    
770    return can_do_reloc;
771 }
772
773 /**************************************************************
774  *
775  *  code generator for x86
776  *
777  **************************************************************/
778
779
780
781
782 #define MAX_BRANCH      (0x1<<31)
783
784 Address getMaxBranch() {
785   return (Address)MAX_BRANCH;
786 }
787
788
789 bool doNotOverflow(int)
790 {
791    //
792    // this should be changed by the correct code. If there isn't any case to
793    // be checked here, then the function should return TRUE. If there isn't
794    // any immediate code to be generated, then it should return FALSE - naim
795    //
796    // any int value can be an immediate on the pentium
797     return(true);
798 }
799
800
801
802 /* build the MOD/RM byte of an instruction */
803 static inline unsigned char makeModRMbyte(unsigned Mod, unsigned Reg,
804                                           unsigned RM)
805 {
806    return static_cast<unsigned char>(((Mod & 0x3) << 6) + ((Reg & 0x7) << 3) + (RM & 0x7));
807 }
808
809 // VG(7/30/02): Build the SIB byte of an instruction */
810 static inline unsigned char makeSIBbyte(unsigned Scale, unsigned Index,
811                                         unsigned Base)
812 {
813    return static_cast<unsigned char>(((Scale & 0x3) << 6) + ((Index & 0x7) << 3) + (Base & 0x7));
814 }
815
816 /* 
817    Emit the ModRM byte and displacement for addressing modes.
818    base is a register (EAX, ECX, REGNUM_EDX, EBX, EBP, REGNUM_ESI, REGNUM_EDI)
819    disp is a displacement
820    reg_opcode is either a register or an opcode
821 */
822 void emitAddressingMode(unsigned base, RegValue disp,
823                         unsigned reg_opcode, codeGen &gen)
824 {
825    // MT linux uses ESP+4
826    // we need an SIB in that case
827    if (base == REGNUM_ESP) {
828       emitAddressingMode(REGNUM_ESP, Null_Register, 0, disp, reg_opcode, gen);
829       return;
830    }
831    GET_PTR(insn, gen);
832    if (base == Null_Register) {
833       *insn++ = makeModRMbyte(0, reg_opcode, 5);
834       *((int *)insn) = disp;
835       insn += sizeof(int);
836    } else if (disp == 0 && base != REGNUM_EBP) {
837       *insn++ = makeModRMbyte(0, reg_opcode, base);
838    } else if (disp >= -128 && disp <= 127) {
839       *insn++ = makeModRMbyte(1, reg_opcode, base);
840       *((char *)insn++) = (char) disp;
841    } else {
842       *insn++ = makeModRMbyte(2, reg_opcode, base);
843       *((int *)insn) = disp;
844       insn += sizeof(int);
845    }
846    SET_PTR(insn, gen);
847 }
848
849 // VG(7/30/02): emit a fully fledged addressing mode: base+index<<scale+disp
850 void emitAddressingMode(unsigned base, unsigned index,
851                         unsigned int scale, RegValue disp,
852                         int reg_opcode, codeGen &gen)
853 {
854    bool needSIB = (base == REGNUM_ESP) || (index != Null_Register);
855
856    if(!needSIB) {
857       emitAddressingMode(base, disp, reg_opcode, gen);
858       return;
859    }
860    
861    assert(index != REGNUM_ESP);
862    
863    if(index == Null_Register) {
864       assert(base == REGNUM_ESP); // not necessary, but sane
865       index = 4;           // (==REGNUM_ESP) which actually means no index in SIB
866    }
867
868    GET_PTR(insn, gen);
869    
870    if(base == Null_Register) { // we have to emit [index<<scale+disp32]
871       *insn++ = makeModRMbyte(0, reg_opcode, 4);
872       *insn++ = makeSIBbyte(scale, index, 5);
873       *((int *)insn) = disp;
874       insn += sizeof(int);
875    }
876    else if(disp == 0 && base != REGNUM_EBP) { // EBP must have 0 disp8; emit [base+index<<scale]
877        *insn++ = makeModRMbyte(0, reg_opcode, 4);
878        *insn++ = makeSIBbyte(scale, index, base);
879    }
880    else if (disp >= -128 && disp <= 127) { // emit [base+index<<scale+disp8]
881       *insn++ = makeModRMbyte(1, reg_opcode, 4);
882       *insn++ = makeSIBbyte(scale, index, base);
883       *((char *)insn++) = (char) disp;
884    }
885    else { // emit [base+index<<scale+disp32]
886       *insn++ = makeModRMbyte(2, reg_opcode, 4);
887       *insn++ = makeSIBbyte(scale, index, base);
888       *((int *)insn) = disp;
889       insn += sizeof(int);
890    }
891
892    SET_PTR(insn, gen);
893 }
894
895
896 /* emit a simple one-byte instruction */
897 void emitSimpleInsn(unsigned op, codeGen &gen) {
898     GET_PTR(insn, gen);
899     *insn++ = static_cast<unsigned char>(op);
900     SET_PTR(insn, gen);
901 }
902
903 void emitPushImm(unsigned int imm, codeGen &gen)
904 {
905     GET_PTR(insn, gen);
906     *insn++ = 0x68;
907     *((unsigned int *)insn) = imm;
908     insn += sizeof(unsigned int);
909     SET_PTR(insn, gen);
910     if (gen.rs())
911        gen.rs()->incStack(gen.addrSpace()->getAddressWidth());
912 }
913
914 // emit a simple register to register instruction: OP dest, src
915 // opcode is one or two byte
916 void emitOpRegReg(unsigned opcode, RealRegister dest, RealRegister src,
917                   codeGen &gen)
918 {
919     GET_PTR(insn, gen);
920     if (opcode <= 0xFF)
921        *insn++ = static_cast<unsigned char>(opcode);
922     else {
923        *insn++ = static_cast<unsigned char>(opcode >> 8);
924        *insn++ = static_cast<unsigned char>(opcode & 0xFF);
925     }
926     // ModRM byte define the operands: Mod = 3, Reg = dest, RM = src
927     *insn++ = makeModRMbyte(3, dest.reg(), src.reg());
928     SET_PTR(insn, gen);
929 }
930
931 void emitOpRegImm(int opcode, RealRegister dest, int imm,
932                   codeGen &gen) {
933    GET_PTR(insn, gen);
934    *insn++ = 0x81;
935    *insn++ = makeModRMbyte(3, opcode, dest.reg());
936    *((int *)insn) = imm;
937    insn+= sizeof(int);
938    SET_PTR(insn, gen);
939 }
940
941 // emit OP reg, r/m
942 void emitOpRegRM(unsigned opcode, RealRegister dest, RealRegister base,
943                  int disp, codeGen &gen)
944 {
945     GET_PTR(insn, gen);
946     if (opcode <= 0xff) {
947        *insn++ = static_cast<unsigned char>(opcode);
948     } else {
949        *insn++ = static_cast<unsigned char>(opcode >> 8);
950        *insn++ = static_cast<unsigned char>(opcode & 0xff);
951     }
952     SET_PTR(insn, gen);
953     emitAddressingMode(base.reg(), disp, dest.reg(), gen);
954 }
955
956 // emit OP r/m, reg
957 void emitOpRMReg(unsigned opcode, RealRegister base, int disp,
958                  RealRegister src, codeGen &gen) {
959    GET_PTR(insn, gen);
960    *insn++ = static_cast<unsigned char>(opcode);
961    SET_PTR(insn, gen);
962    emitAddressingMode(base.reg(), disp, src.reg(), gen);
963 }
964
965 // emit OP reg, imm32
966 void emitOpExtRegImm(int opcode, int ext, RealRegister dest, int imm,
967                      codeGen &gen) 
968 {
969    GET_PTR(insn, gen);
970    *insn++ = opcode;
971    *insn++ = makeModRMbyte(3, (char) ext, dest.reg());
972    *((int *)insn) = imm;
973    insn+= sizeof(int);
974    SET_PTR(insn, gen);
975 }
976
977 void emitOpExtRegImm8(int opcode, char ext, RealRegister dest, unsigned char imm,
978                      codeGen &gen) 
979 {
980    GET_PTR(insn, gen);
981    *insn++ = opcode;
982    *insn++ = makeModRMbyte(3, ext, dest.reg());
983    *((unsigned char *)insn) = imm;
984    insn+= sizeof(unsigned char);
985    SET_PTR(insn, gen);
986 }
987
988 void emitOpExtReg(unsigned opcode, unsigned char ext, RealRegister reg, codeGen &gen)
989 {
990    GET_PTR(insn, gen);
991    *insn++ = opcode;
992    *insn++ = makeModRMbyte(3, ext, reg.reg());
993    SET_PTR(insn, gen);
994 }
995
996 void emitMovRegToReg(RealRegister dest, RealRegister src, codeGen &gen)
997 {
998    GET_PTR(insn, gen);
999    *insn++ = 0x8B;
1000    *insn++ = makeModRMbyte(3, dest.reg(), src.reg());
1001    SET_PTR(insn, gen);
1002 }
1003
1004 void emitOpRegRegImm(unsigned opcode, RealRegister dest, RealRegister src, unsigned imm, codeGen &gen)
1005 {
1006    GET_PTR(insn, gen);
1007    *insn++ = opcode;
1008    *insn++ = makeModRMbyte(3, dest.reg(), src.reg());
1009    *((int *)insn) = imm;
1010    insn += sizeof(int);
1011    SET_PTR(insn, gen);
1012 }
1013
1014 // emit MOV reg, (reg)
1015 void emitMovIRegToReg(RealRegister dest, RealRegister src,
1016                       codeGen &gen) {
1017     GET_PTR(insn, gen);
1018     *insn++ = 0x8B;
1019     *insn++ = makeModRMbyte(0, dest.reg(), src.reg());
1020     SET_PTR(insn, gen);
1021     gen.markRegDefined(dest.reg());
1022 }
1023
1024 // VG(07/30/02): Emit a lea dest, [base + index * scale + disp]; dest is a
1025 // real GPR
1026 void emitLEA(RealRegister base, RealRegister index, unsigned int scale,
1027              RegValue disp, RealRegister dest, codeGen &gen)
1028 {
1029    if (dest.reg() != REGNUM_ESP)
1030       gen.markRegDefined(dest.reg());
1031    GET_PTR(insn, gen);
1032    *insn++ = 0x8D;
1033    SET_PTR(insn, gen);
1034    emitAddressingMode(base.reg(), index.reg(), scale, disp, (int)dest.reg(), gen);
1035 }
1036
1037 void emitLEA(RealRegister base, unsigned displacement, RealRegister dest, 
1038              codeGen &gen)
1039 {
1040    gen.markRegDefined(dest.reg());
1041    GET_PTR(insn, gen);
1042    *insn++ = 0x8D;
1043    *insn++ = makeModRMbyte(2, dest.reg(), base.reg());
1044    *((unsigned *) insn) = displacement;
1045    insn += sizeof(unsigned);
1046    SET_PTR(insn, gen);
1047 }
1048
1049 // emit MOV reg, (offset(%eip))
1050 void emitMovPCRMToReg(RealRegister dest, int offset, codeGen &gen, bool deref_result)
1051 {
1052     // call next instruction (relative 0x0) and pop PC (EIP) into register
1053    GET_PTR(insn, gen);
1054
1055    if (!gen.addrSpace()->needsPIC())
1056    {
1057       Address target = gen.currAddr() + offset;
1058       if (deref_result) {
1059          emitMovMToReg(dest, target, gen);
1060       }
1061       else {
1062          emitMovImmToReg(dest, target, gen);
1063       }
1064       return;
1065    }
1066
1067    int used = gen.used();
1068    RealRegister pc_reg(0);
1069    if (gen.rs()->pc_rel_offset() == -1) {
1070       //assert(!gen.rs()->pc_rel_use_count);
1071       if (gen.getPCRelUseCount() == 1) {
1072          //We know there's only one getPC instruction.  We won't setup
1073          // a stored register for the PC.  Just use dest since we're
1074          // about to write to it anyways.
1075          pc_reg = dest;
1076       }
1077       else {
1078          gen.rs()->pc_rel_reg = gen.rs()->allocateRegister(gen, true);
1079          pc_reg = gen.rs()->loadVirtualForWrite(gen.rs()->pc_rel_reg, gen);
1080       }
1081       gen.rs()->pc_rel_offset() = used + 5;
1082       *insn++ = 0xE8;
1083       *insn++ = 0x00;
1084       *insn++ = 0x00;
1085       *insn++ = 0x00;
1086       *insn++ = 0x00;
1087       *insn++ = static_cast<unsigned char>(0x58 + pc_reg.reg());
1088       SET_PTR(insn, gen);
1089    }
1090    else {
1091       pc_reg = gen.rs()->loadVirtual(gen.rs()->pc_rel_reg, gen);   
1092    }
1093    gen.rs()->pc_rel_use_count++;
1094
1095    offset += used - gen.rs()->pc_rel_offset();
1096    if (deref_result) {
1097       emitMovRMToReg(dest, pc_reg, offset, gen);
1098    }
1099    else {
1100       emitLEA(pc_reg, offset, dest, gen);
1101    }   
1102
1103    if (gen.getPCRelUseCount() > 1 && 
1104        gen.rs()->pc_rel_use_count == gen.getPCRelUseCount())
1105    {
1106       //We've made the last use of getPC.  Free the register that stores the PC
1107       //Don't do if getPCRelUseCount() is 0, because we don't know how many uses
1108       // there are.
1109       //Don't do if getPCRelUseCount() is 1, because it was special cased above
1110       gen.rs()->freeRegister(gen.rs()->pc_rel_reg);
1111       gen.rs()->pc_rel_reg = Null_Register;
1112       gen.rs()->pc_rel_offset() = -1;
1113    }
1114 }
1115
1116 // emit MOV reg, r/m
1117 void emitMovRMToReg(RealRegister dest, RealRegister base, int disp,
1118                     codeGen &gen) 
1119 {
1120    GET_PTR(insn, gen);
1121    *insn++ = 0x8B;
1122    SET_PTR(insn, gen);
1123    emitAddressingMode(base.reg(), disp, dest.reg(), gen);
1124 }
1125
1126 // emit MOV r/m, reg
1127 void emitMovRegToRM(RealRegister base, int disp, RealRegister src,
1128                     codeGen &gen) 
1129 {
1130    GET_PTR(insn, gen);
1131    *insn++ = 0x89;
1132    SET_PTR(insn, gen);
1133    emitAddressingMode(base.reg(), disp, src.reg(), gen);
1134 }
1135
1136 // emit MOV m, reg
1137 void emitMovRegToM(int disp, RealRegister src, codeGen &gen)
1138 {
1139    GET_PTR(insn, gen);
1140    *insn++ = 0x89;
1141    SET_PTR(insn, gen);
1142    emitAddressingMode(Null_Register, disp, src.reg(), gen);
1143 }
1144
1145 // emit MOV m, reg
1146 void emitMovRegToMB(int disp, RealRegister src, codeGen &gen)
1147 {
1148    GET_PTR(insn, gen);
1149    *insn++ = 0x88;
1150    *insn++ = makeModRMbyte(0, src.reg(), 5);
1151    *((int *) insn) = disp;
1152    insn += sizeof(int);
1153    SET_PTR(insn, gen);
1154 }
1155
1156 // emit MOV m, reg
1157 void emitMovRegToMW(int disp, RealRegister src, codeGen &gen)
1158 {
1159    GET_PTR(insn, gen);
1160    *insn++ = 0x66;
1161    *insn++ = 0x88;
1162    *insn++ = makeModRMbyte(0, src.reg(), 5);
1163    *((int *) insn) = disp;
1164    insn += sizeof(int);
1165    SET_PTR(insn, gen);
1166 }
1167
1168 // emit MOV reg, m
1169 void emitMovMToReg(RealRegister dest, int disp, codeGen &gen)
1170 {
1171    gen.markRegDefined(dest.reg());
1172    GET_PTR(insn, gen);
1173    *insn++ = 0x8B;
1174    SET_PTR(insn, gen);
1175    emitAddressingMode(Null_Register, disp, dest.reg(), gen);
1176 }
1177
1178 // emit MOVSBL reg, m
1179 void emitMovMBToReg(RealRegister dest, int disp, codeGen &gen)
1180 {
1181    gen.markRegDefined(dest.reg());
1182    GET_PTR(insn, gen);
1183    *insn++ = 0x0F;
1184    *insn++ = 0xBE;
1185    SET_PTR(insn, gen);
1186    emitAddressingMode(Null_Register, disp, dest.reg(), gen);
1187 }
1188
1189 // emit MOVSWL reg, m
1190 void emitMovMWToReg(RealRegister dest, int disp, codeGen &gen)
1191 {
1192    gen.markRegDefined(dest.reg());
1193    GET_PTR(insn, gen);
1194    *insn++ = 0x0F;
1195    *insn++ = 0xBF;
1196    SET_PTR(insn, gen);
1197    emitAddressingMode(Null_Register, disp, dest.reg(), gen);
1198 }
1199
1200 // emit MOV reg, imm32
1201 void emitMovImmToReg(RealRegister dest, int imm, codeGen &gen)
1202 {
1203    GET_PTR(insn, gen);
1204    *insn++ = static_cast<unsigned char>(0xB8 + dest.reg());
1205    *((int *)insn) = imm;
1206    insn += sizeof(int);
1207    SET_PTR(insn, gen);
1208 }
1209
1210 // emit MOV r/m32, imm32
1211 void emitMovImmToRM(RealRegister base, int disp, int imm,
1212                     codeGen &gen) {
1213    GET_PTR(insn, gen);
1214    *insn++ = 0xC7;
1215    SET_PTR(insn, gen);
1216    emitAddressingMode(base.reg(), disp, 0, gen);
1217    REGET_PTR(insn, gen);
1218    *((int*)insn) = imm;
1219    insn += sizeof(int);
1220     SET_PTR(insn, gen);
1221 }
1222
1223 // emit MOV mem32, imm32
1224 void emitMovImmToMem(Address maddr, int imm,
1225                                    codeGen &gen) {
1226     // In x86_64, the meaning of the ModRM byte for disp32 has changed.
1227     // Now, it implies an [RIP] + disp32 address.  To get an absolute
1228     // address operand (in both x86 and x86_64), the full ModRM + SIB
1229     // syntax must be used.
1230     GET_PTR(insn, gen);
1231     *insn++ = 0xC7;
1232
1233     // FIXME: To adhere strictly to the x86 and x86_64 ISAs, we specify an
1234     // absolute (32-bit) address by emitting a ModRM and SIB byte of the
1235     // following form:
1236     //     Mod = 00b, Reg = (doesn't matter?), R/M = 100b
1237     //     base = 101b, index = 100b, scale = (doesn't matter?)
1238     // Current forms of emitAddressingMode() do not allow for this, and so
1239     // we do it manually here.  emitAddressingMode() should be made more
1240     // robust.
1241     *insn++ = makeModRMbyte(0, 0, 4);
1242     *insn++ = makeSIBbyte(0, 4, 5);
1243     *((int *)insn) = maddr;
1244     insn += sizeof(unsigned);
1245
1246     *((int*)insn) = imm;
1247     insn += sizeof(int);
1248     SET_PTR(insn, gen);
1249 }
1250
1251 // emit Add dword ptr DS:[addr], imm
1252 void emitAddMemImm32(Address addr, int imm, codeGen &gen)
1253 {
1254     GET_PTR(insn, gen);
1255    *insn++ = 0x81;
1256    *insn++ = 0x05;
1257    *((unsigned *)insn) = addr;
1258    insn += sizeof(unsigned);
1259    *((int *)insn) = imm;
1260    insn += sizeof(int);
1261     SET_PTR(insn, gen);
1262 }
1263
1264 // emit Add reg, imm32
1265 void emitAddRegImm32(RealRegister reg, int imm, codeGen &gen)
1266 {
1267    GET_PTR(insn, gen);
1268    if (imm >= -128 && imm <= 127) {
1269       *insn++ = 0x83;
1270       *insn++ = makeModRMbyte(3, 0, reg.reg());
1271       *((char *)insn) = (char) imm;
1272       insn += sizeof(char);
1273    }
1274    else {
1275       *insn++ = 0x81;
1276       *insn++ = makeModRMbyte(3, 0, reg.reg());
1277       *((int *)insn) = imm;
1278       insn += sizeof(int);
1279    }
1280    SET_PTR(insn, gen);
1281 }
1282
1283 // emit Sub reg, reg
1284 void emitSubRegReg(RealRegister dest, RealRegister src, codeGen &gen)
1285 {
1286    gen.markRegDefined(dest.reg());
1287    GET_PTR(insn, gen);
1288    *insn++ = 0x2B;
1289    *insn++ = makeModRMbyte(3, dest.reg(), src.reg());
1290    SET_PTR(insn, gen);
1291 }
1292
1293 unsigned char cmovOpcodeFromRelOp(unsigned op)
1294 {
1295    switch (op) {
1296       case eqOp: return 0x44; //cmove
1297       case neOp: return 0x45; //cmovne
1298       case lessOp: return 0x4c; //cmovl
1299       case leOp: return 0x4e; //cmovle
1300       case greaterOp: return 0x4f; //cmovg
1301       case geOp: return 0x4d; //cmovge
1302      default: assert(0);
1303    }
1304    return 0x0;
1305 }
1306 // help function to select appropriate jcc opcode for a relOp
1307 unsigned char jccOpcodeFromRelOp(unsigned op)
1308 {
1309    switch (op) {
1310      case eqOp: return JNE_R8;
1311      case neOp: return JE_R8;
1312      case lessOp: return JGE_R8;
1313      case leOp: return JG_R8;
1314      case greaterOp: return JLE_R8;
1315      case geOp: return JL_R8;
1316      default: assert(0);
1317    }
1318    return 0x0;
1319 }
1320
1321 static inline void emitEnter(short imm16, codeGen &gen) {
1322     GET_PTR(insn, gen);
1323    *insn++ = 0xC8;
1324    *((short*)insn) = imm16;
1325    insn += sizeof(short);
1326    *insn++ = 0;
1327     SET_PTR(insn, gen);
1328 }
1329
1330 Register emitFuncCall(opCode, codeGen &, pdvector<AstNodePtr> &, bool, Address) {
1331         assert(0);
1332         return 0;
1333 }
1334
1335 // this function just multiplexes between the 32-bit and 64-bit versions
1336 Register emitFuncCall(opCode op, 
1337                       codeGen &gen,
1338                       pdvector<AstNodePtr> &operands, 
1339                       bool noCost,
1340                       int_function *callee)
1341 {
1342     Register reg = gen.codeEmitter()->emitCall(op, gen, operands, noCost, callee);
1343     return reg;
1344 }
1345
1346
1347
1348 /* Recursive function that goes to where our instrumentation is calling
1349 to figure out what registers are clobbered there, and in any function
1350 that it calls, to a certain depth ... at which point we clobber everything
1351
1352 Update-12/06, njr, since we're going to a cached system we are just going to 
1353 look at the first level and not do recursive, since we would have to also
1354 store and reexamine every call out instead of doing it on the fly like before*/
1355
1356 // Should be a member of the registerSpace class?
1357
1358 bool EmitterIA32::clobberAllFuncCall( registerSpace *rs,
1359                                       int_function *callee)
1360                    
1361 {
1362   if (callee == NULL) return false;
1363
1364   /* This will calculate the values if the first time around, otherwise
1365      will check preparsed, stored values.
1366      True - FP Writes are present
1367      False - No FP Writes
1368   */
1369
1370   stats_codegen.startTimer(CODEGEN_LIVENESS_TIMER);  
1371   if (callee->ifunc()->writesFPRs()) {
1372       for (unsigned i = 0; i < rs->FPRs().size(); i++) {
1373           rs->FPRs()[i]->beenUsed = true;
1374       }
1375   }
1376   stats_codegen.stopTimer(CODEGEN_LIVENESS_TIMER);
1377   return true;
1378 }
1379
1380
1381 void EmitterIA32::setFPSaveOrNot(const int * liveFPReg,bool saveOrNot)
1382 {
1383    if (liveFPReg != NULL)
1384    {
1385       if (liveFPReg[0] == 0 && saveOrNot)
1386       {
1387          int * temp = const_cast<int *>(liveFPReg);
1388          temp[0] = 1;
1389       }
1390    }
1391 }
1392
1393
1394 Register EmitterIA32::emitCall(opCode op, 
1395                                codeGen &gen,
1396                                const pdvector<AstNodePtr> &operands, 
1397                                bool noCost, int_function *callee) {
1398     bool inInstrumentation = true;
1399     if (gen.obj() &&
1400         dynamic_cast<replacedInstruction *>(gen.obj())) {
1401         // We're replacing an instruction - so don't do anything
1402         // that requires a base tramp.
1403         inInstrumentation = false;
1404     }
1405
1406
1407     assert(op == callOp);
1408     pdvector <Register> srcs;
1409     int param_size;
1410     pdvector<Register> saves;
1411     
1412     //  Sanity check for NULL address arg
1413     if (!callee) {
1414         char msg[256];
1415         sprintf(msg, "%s[%d]:  internal error:  emitFuncCall called w/out"
1416                 "callee argument", __FILE__, __LINE__);
1417         showErrorCallback(80, msg);
1418         assert(0);
1419     }
1420
1421    param_size = emitCallParams(gen, operands, callee, saves, noCost);
1422
1423    Register ret = gen.rs()->allocateRegister(gen, noCost);
1424
1425    emitCallInstruction(gen, callee, ret);
1426
1427    emitCallCleanup(gen, callee, param_size, saves);
1428
1429    if (!inInstrumentation) return REG_NULL;
1430
1431    // allocate a (virtual) register to store the return value
1432    // Virtual register
1433
1434    return ret;
1435 }
1436
1437 /*
1438  * emit code for op(src1,src2, dest)
1439  * ibuf is an instruction buffer where instructions are generated
1440  * base is the next free position on ibuf where code is to be generated
1441  */
1442
1443 codeBufIndex_t emitA(opCode op, Register src1, Register /*src2*/, Register dest,
1444                      codeGen &gen, RegControl rc, bool /*noCost*/)
1445 {
1446    //bperr("emitA(op=%d,src1=%d,src2=XX,dest=%d)\n",op,src1,dest);
1447    
1448    // retval is the address of the jump (if one is created). 
1449    // It's always the _start_ of the jump, which means that if we need
1450    // to offset (like x86 (to - (from + insnsize))) we do it later.
1451    codeBufIndex_t retval = 0;
1452    
1453    switch (op) {
1454       case ifOp: {
1455          // if src1 == 0 jump to dest
1456          // src1 is a temporary
1457          // dest is a target address
1458          retval = gen.codeEmitter()->emitIf(src1, dest, rc, gen);
1459          break;
1460       }
1461       case branchOp: {
1462          // dest is the displacement from the current value of insn
1463          // this will need to work for both 32-bits and 64-bits
1464          // (since there is no JMP rel64)
1465          insnCodeGen::generateBranch(gen, dest);
1466          retval = gen.getIndex();
1467          break;
1468       }
1469       case trampPreamble: {
1470          break;
1471       }
1472       default:
1473          abort();        // unexpected op for this emit!
1474    }
1475    
1476    return retval;
1477 }
1478
1479 Register emitR(opCode op, Register src1, Register src2, Register dest,
1480                codeGen &gen, bool noCost,
1481                const instPoint *location, bool /*for_multithreaded*/)
1482 {
1483     //bperr("emitR(op=%d,src1=%d,src2=XX,dest=%d)\n",op,src1,dest);
1484
1485    bool get_addr_of = (src2 != Null_Register);
1486    switch (op) {
1487        case getRetValOp:
1488           // dest is a register where we can store the value
1489           // the return value is in the saved EAX
1490           gen.codeEmitter()->emitGetRetVal(dest, get_addr_of, gen);
1491           if (!get_addr_of)
1492              return dest;
1493           break;
1494        case getParamOp:
1495           // src1 is the number of the argument
1496           // dest is a register where we can store the value
1497           gen.codeEmitter()->emitGetParam(dest, src1, location->getPointType(), 
1498                                           get_addr_of, gen);
1499           if (!get_addr_of)
1500              return dest;
1501           break;
1502        case loadRegOp:
1503           assert(src1 == 0);
1504           assert(0);
1505           return dest;
1506        default:
1507           abort();                  // unexpected op for this emit!
1508     }
1509     assert(get_addr_of);
1510     emitV(storeIndirOp, src2, 0, dest, gen, noCost, gen.rs(), 
1511           gen.addrSpace()->getAddressWidth(), gen.point(), gen.addrSpace());
1512     return(dest);
1513 }
1514
1515 void emitSHL(RealRegister dest, unsigned char pos, codeGen &gen)
1516 {
1517   //bperr( "Emiting SHL\n");
1518    gen.markRegDefined(dest.reg());
1519    GET_PTR(insn, gen);
1520    *insn++ = 0xC1;
1521    *insn++ = makeModRMbyte(3 /* rm gives register */,
1522                            4 /* opcode ext. */, dest.reg());
1523    *insn++ = pos;
1524    SET_PTR(insn, gen);
1525 }
1526
1527 void EmitterIA32::emitPushFlags(codeGen &gen) {
1528     // These crank the saves forward
1529     emitSimpleInsn(PUSHFD, gen);
1530 }
1531
1532 void EmitterIA32::emitRestoreFlags(codeGen &, unsigned )
1533 {
1534     assert(!"never use this!");
1535     return;
1536 //   emitOpRMReg(PUSH_RM_OPC1, RealRegister(REGNUM_ESP), offset*4, RealRegister(PUSH_RM_OPC2), gen);
1537 //    emitSimpleInsn(POPFD, gen); // popfd
1538 }
1539
1540 void EmitterIA32::emitRestoreFlagsFromStackSlot(codeGen &gen)
1541 {
1542     // if the flags aren't on the stack, they're already restored...
1543     if((*gen.rs())[IA32_FLAG_VIRTUAL_REGISTER]->liveState == registerSlot::spilled)
1544     {
1545         stackItemLocation loc = getHeightOf(stackItem(RealRegister(IA32_FLAG_VIRTUAL_REGISTER)), gen);
1546         assert(loc.offset % 4 == 0);
1547         ::emitPush(RealRegister(REGNUM_EAX), gen);
1548         emitMovRMToReg(RealRegister(REGNUM_EAX), loc.reg, loc.offset, gen);
1549         emitRestoreO(gen);
1550         emitSimpleInsn(0x9E, gen); // SAHF
1551         ::emitPop(RealRegister(REGNUM_EAX), gen);
1552     }
1553 }
1554
1555 // VG(8/15/02): Emit the jcc over a conditional snippet
1556 void emitJmpMC(int condition, int offset, codeGen &gen)
1557 {
1558     // What we want: 
1559     //   mov eax, [original EFLAGS]
1560     //   push eax
1561     //   popfd
1562     //   jCC target   ; CC = !condition (we jump on the negated condition)
1563     
1564     assert(condition >= 0 && condition <= 0x0F);
1565     
1566     //bperr("OC: %x, NC: %x\n", condition, condition ^ 0x01);
1567     condition ^= 0x01; // flip last bit to negate the tttn condition
1568     
1569     gen.codeEmitter()->emitRestoreFlagsFromStackSlot(gen);
1570     emitJcc(condition, offset, gen);
1571 }
1572
1573 stackItemLocation getHeightOf(stackItem sitem, codeGen &gen)
1574 {
1575    int offset = 0;
1576    RealRegister reg;
1577
1578    int addr_width = gen.addrSpace()->getAddressWidth();
1579    RealRegister plat_bp(addr_width == 4 ? REGNUM_EBP : REGNUM_RBP);
1580    RealRegister plat_sp(addr_width == 4 ? REGNUM_ESP : REGNUM_RSP); 
1581
1582    if (sitem.item == stackItem::reg_item && sitem.reg.reg() == plat_sp.reg())
1583    {
1584       sitem.item = stackItem::stacktop;
1585    }
1586
1587    switch (sitem.item)
1588    {
1589       case stackItem::reg_item:
1590       {
1591          registerSlot *r = NULL;
1592          pdvector<registerSlot *> &regs = gen.rs()->trampRegs();
1593          for (unsigned i=0; i<regs.size(); i++) {
1594             if (regs[i]->number == (unsigned) sitem.reg.reg()) {
1595                r = regs[i];
1596                break;
1597             }
1598          }
1599          if((unsigned)sitem.reg.reg() == IA32_FLAG_VIRTUAL_REGISTER)
1600          {
1601              r = (*gen.rs())[sitem.reg.reg()];
1602          }
1603          if (!r && addr_width == 8) {
1604             r = (*gen.rs())[sitem.reg.reg()];
1605          }
1606          assert(r);
1607          offset = r->saveOffset * addr_width;
1608          if (gen.bti()->hasStackFrame()) {
1609             reg = plat_bp;
1610             return stackItemLocation(plat_bp, offset);
1611          }
1612          if (gen.bti()->hasLocalSpace()) {
1613             offset += TRAMP_FRAME_SIZE;
1614          }
1615          offset += gen.rs()->getStackHeight();
1616          return stackItemLocation(plat_sp, offset);
1617       }
1618       case stackItem::stacktop:
1619       {
1620          if (addr_width == 8)
1621             offset += STACK_PAD_CONSTANT;
1622          if (!gen.bti() || gen.bti()->flagsSaved())
1623             offset += addr_width;
1624          int regs_saved = 0;
1625          pdvector<registerSlot *> &regs = gen.rs()->trampRegs();
1626          for (unsigned i=0; i<regs.size(); i++) {
1627             registerSlot *reg = regs[i];
1628             if (reg->spilledState == registerSlot::unspilled) 
1629                continue;
1630             offset += addr_width;
1631             regs_saved++;
1632          }
1633          offset += (gen.bti()->funcJumpSlotSize() * addr_width);
1634          if (gen.bti()->hasStackFrame()) 
1635          {
1636             //Count the return address and frame save
1637             offset += addr_width*2;
1638             //We mis-counted the save of ebp above, it's not part of the regular
1639             // register saves.  We should only count it it was saved by a pusha
1640             if (addr_width == 4 && regs_saved != 8) {
1641                offset -= addr_width;                
1642             }
1643             return stackItemLocation(plat_bp, offset);
1644          }
1645          if (gen.bti()->hasLocalSpace()) {
1646             offset += TRAMP_FRAME_SIZE;
1647          }
1648          offset += gen.rs()->getStackHeight();
1649          return stackItemLocation(plat_sp, offset);
1650       }
1651       case stackItem::framebase: {
1652          if (!gen.bti() || gen.bti()->hasStackFrame()) {
1653             return stackItemLocation(plat_bp, 0);
1654          }
1655          offset = gen.rs()->getStackHeight();
1656          if (gen.bti()->hasLocalSpace()) {
1657             offset += TRAMP_FRAME_SIZE;
1658          }
1659          return stackItemLocation(plat_sp, offset);
1660       }
1661    }
1662    assert(0);
1663    return stackItemLocation(RealRegister(REG_NULL), 0);
1664 }
1665
1666 // Restore mutatee value of GPR reg to dest (real) GPR
1667 Register restoreGPRtoReg(RealRegister reg, codeGen &gen, RealRegister *dest_to_use)
1668 {
1669    Register dest = REG_NULL;
1670    RealRegister dest_r(-1);
1671    if (dest_to_use) {
1672       dest_r = *dest_to_use;
1673    }
1674    else {
1675       dest = gen.rs()->getScratchRegister(gen);
1676    }
1677    
1678    if (reg.reg() == REGNUM_EBP) {
1679       //Special handling for EBP with and without instr stack frame
1680       if (dest_r.reg() == -1)
1681          dest_r = gen.rs()->loadVirtualForWrite(dest, gen);
1682       if (gen.bti()->hasStackFrame()) {
1683          emitMovRMToReg(dest_r, RealRegister(REGNUM_EBP), 0, gen);
1684       }
1685       else {
1686          if (reg.reg() != dest_r.reg()) {
1687             //TODO: Future optimization here, allow ebp to be used
1688             // though not allocated
1689             emitMovRegToReg(dest_r, reg, gen);
1690          }
1691       }
1692       return dest;
1693    }
1694
1695    if (reg.reg() == REGNUM_ESP) {
1696       //Special handling for ESP 
1697       if (dest_r.reg() == -1)
1698          dest_r = gen.rs()->loadVirtualForWrite(dest, gen);
1699       stackItemLocation loc = getHeightOf(stackItem(stackItem::stacktop), gen);
1700       if (loc.reg.reg() == REGNUM_EBP) {
1701          emitLEA(RealRegister(REGNUM_EBP), loc.offset, dest_r, gen);
1702       }
1703       else {
1704          emitLEA(RealRegister(REGNUM_ESP), RealRegister(Null_Register), 0, 
1705                  loc.offset, dest_r, gen);
1706       }
1707       return dest;
1708    }
1709
1710    registerSlot *r = gen.rs()->trampRegs()[reg.reg()];
1711    if (r->spilledState == registerSlot::unspilled ||
1712        !gen.isRegDefined(reg.reg())) 
1713    {
1714       //Register is still in its pristine state from app, leave it.
1715       if (dest_r.reg() == -1)
1716          gen.rs()->noteVirtualInReal(dest, reg);
1717       else if (dest_r.reg() != reg.reg())
1718          emitMovRegToReg(dest_r, reg, gen);
1719       return dest;
1720    }
1721
1722    //Load register from its saved location
1723    stackItemLocation loc = getHeightOf(stackItem(reg), gen);
1724    if(dest_r.reg() == -1)
1725    {
1726        dest_r = gen.rs()->loadVirtualForWrite(dest, gen);
1727    }
1728    emitMovRMToReg(dest_r, loc.reg, loc.offset, gen);
1729    return dest;
1730 }
1731
1732 void restoreGPRtoGPR(RealRegister src, RealRegister dest, codeGen &gen)
1733 {
1734    restoreGPRtoReg(src, gen, &dest);
1735 }
1736
1737 // VG(11/07/01): Load in destination the effective address given
1738 // by the address descriptor. Used for memory access stuff.
1739 void emitASload(const BPatch_addrSpec_NP *as, Register dest, codeGen &gen, bool /* noCost */)
1740 {
1741     // TODO 16-bit registers, rep hacks
1742     long imm = as->getImm();
1743     int ra  = as->getReg(0);
1744     int rb  = as->getReg(1);
1745     int sc  = as->getScale();
1746
1747     gen.codeEmitter()->emitASload(ra, rb, sc, imm, dest, gen);
1748 }
1749
1750 void EmitterIA32::emitASload(int ra, int rb, int sc, long imm, Register dest, codeGen &gen)
1751 {
1752     bool havera = ra > -1, haverb = rb > -1;
1753    
1754    // assuming 32-bit addressing (for now)
1755    
1756    if (ra == REGNUM_ESP && !haverb && sc == 0 && gen.bti()) {
1757       //Optimization, common for push/pop
1758       RealRegister dest_r = gen.rs()->loadVirtualForWrite(dest, gen);
1759       stackItemLocation loc = getHeightOf(stackItem(stackItem::stacktop), gen);
1760       if (loc.reg.reg() == REGNUM_EBP) {
1761          emitLEA(RealRegister(REGNUM_EBP), loc.offset + imm, dest_r, gen);
1762       }
1763       else {
1764          emitLEA(RealRegister(REGNUM_ESP), RealRegister(Null_Register), 0, 
1765                  loc.offset + imm, dest_r, gen);
1766       }
1767       return;
1768    }
1769
1770    RealRegister src1_r(-1);
1771    Register src1 = REG_NULL;
1772    if (havera) {
1773       src1 = restoreGPRtoReg(RealRegister(ra), gen);
1774       src1_r = gen.rs()->loadVirtual(src1, gen);
1775       gen.rs()->markKeptRegister(src1);
1776    }
1777
1778    RealRegister src2_r(-1);
1779    Register src2 = REG_NULL;
1780    if (haverb) {
1781       if (ra == rb) {
1782          src2_r = src1_r;
1783       }
1784       else {
1785          src2 = restoreGPRtoReg(RealRegister(rb), gen);
1786          src2_r = gen.rs()->loadVirtual(src2, gen);
1787          gen.rs()->markKeptRegister(src2);
1788       }
1789    }
1790    
1791    if (havera && !haverb && !sc && !imm) {
1792       //Optimized case, just use the existing src1_r
1793        gen.rs()->unKeepRegister(src1);
1794        gen.rs()->freeRegister(src1);
1795       gen.rs()->noteVirtualInReal(dest, src1_r);
1796       return;
1797    }
1798
1799    // Emit the lea to do the math for us:
1800    // e.g. lea eax, [eax + edx * sc + imm] if both ra and rb had to be
1801    // restored
1802    RealRegister dest_r = gen.rs()->loadVirtualForWrite(dest, gen);
1803    emitLEA(src1_r, src2_r, sc, (long) imm, dest_r, gen);
1804
1805    if (src1 != REG_NULL) {
1806        gen.rs()->unKeepRegister(src1);
1807        gen.rs()->freeRegister(src1);
1808    }
1809    if (src2 != REG_NULL) {
1810        gen.rs()->unKeepRegister(src2);
1811        gen.rs()->freeRegister(src2);
1812    }
1813 }
1814
1815 void emitCSload(const BPatch_countSpec_NP *as, Register dest,
1816                 codeGen &gen, bool /* noCost */ )
1817 {
1818    // VG(7/30/02): different from ASload on this platform, no LEA business
1819
1820    long imm = as->getImm();
1821    int ra  = as->getReg(0);
1822    int rb  = as->getReg(1);
1823    int sc  = as->getScale();
1824
1825    gen.codeEmitter()->emitCSload(ra, rb, sc, imm, dest, gen);
1826 }
1827
1828 void EmitterIA32::emitCSload(int ra, int rb, int sc, long imm, Register dest, codeGen &gen)
1829 {
1830    // count is at most 1 register or constant or hack (aka pseudoregister)
1831    assert((ra == -1) &&
1832           ((rb == -1) ||
1833             ((imm == 0) && (rb == 1 /*REGNUM_ECX */ || rb >= IA32_EMULATE))));
1834
1835    if(rb >= IA32_EMULATE) {
1836       bool neg = false;
1837       //bperr( "!!!In case rb >= IA32_EMULATE!!!\n");
1838       switch(rb) {
1839         case IA32_NESCAS:
1840            neg = true;
1841         case IA32_ESCAS: {
1842            // plan: restore flags, edi, eax, ecx; do rep(n)e scas(b/w);
1843            // compute (saved_ecx - ecx) << sc;
1844
1845            gen.rs()->makeRegisterAvail(RealRegister(REGNUM_EAX), gen);
1846            gen.rs()->makeRegisterAvail(RealRegister(REGNUM_ECX), gen);
1847            gen.rs()->makeRegisterAvail(RealRegister(REGNUM_EDI), gen);
1848            
1849            // mov eax<-offset[ebp]
1850            emitRestoreFlagsFromStackSlot(gen);
1851            restoreGPRtoGPR(RealRegister(REGNUM_EAX), RealRegister(REGNUM_EAX), gen);
1852            restoreGPRtoGPR(RealRegister(REGNUM_ECX), RealRegister(REGNUM_ECX), gen);
1853            restoreGPRtoGPR(RealRegister(REGNUM_EDI), RealRegister(REGNUM_EDI), gen);
1854            gen.markRegDefined(REGNUM_EAX);
1855            gen.markRegDefined(REGNUM_ECX);
1856            gen.markRegDefined(REGNUM_EDI);
1857            emitSimpleInsn(neg ? 0xF2 : 0xF3, gen); // rep(n)e
1858            switch(sc) {
1859              case 0:
1860                 emitSimpleInsn(0xAE, gen); // scasb
1861                 break;
1862              case 1:
1863                 emitSimpleInsn(0x66, gen); // operand size override for scasw;
1864              case 2:
1865                 emitSimpleInsn(0xAF, gen); // scasw/d
1866                 break;
1867              default:
1868                 assert(!"Wrong scale!");
1869            }
1870            restoreGPRtoGPR(RealRegister(REGNUM_ECX), RealRegister(REGNUM_EAX), gen); // old ecx -> eax
1871            emitSubRegReg(RealRegister(REGNUM_EAX), RealRegister(REGNUM_ECX), gen); // eax = eax - ecx
1872            gen.markRegDefined(REGNUM_EAX);
1873            if(sc > 0)
1874               emitSHL(RealRegister(REGNUM_EAX), static_cast<unsigned char>(sc), gen); // shl eax, scale
1875            RealRegister dest_r = gen.rs()->loadVirtualForWrite(dest, gen);
1876            emitMovRegToReg(dest_r, RealRegister(REGNUM_EAX), gen);
1877            break;
1878         }
1879         case IA32_NECMPS:
1880            neg = true;
1881         case IA32_ECMPS: {
1882            // plan: restore flags, esi, edi, ecx; do rep(n)e cmps(b/w);
1883            // compute (saved_ecx - ecx) << sc;
1884
1885            gen.rs()->makeRegisterAvail(RealRegister(REGNUM_EAX), gen);
1886            gen.rs()->makeRegisterAvail(RealRegister(REGNUM_ESI), gen);
1887            gen.rs()->makeRegisterAvail(RealRegister(REGNUM_EDI), gen);
1888            gen.rs()->makeRegisterAvail(RealRegister(REGNUM_ECX), gen);
1889            
1890            // mov eax<-offset[ebp]
1891            emitRestoreFlagsFromStackSlot(gen);
1892            restoreGPRtoGPR(RealRegister(REGNUM_ECX), RealRegister(REGNUM_ECX), gen);
1893            gen.markRegDefined(REGNUM_ECX);
1894            restoreGPRtoGPR(RealRegister(REGNUM_ESI), RealRegister(REGNUM_ESI), gen);
1895            gen.markRegDefined(REGNUM_ESI);
1896            restoreGPRtoGPR(RealRegister(REGNUM_EDI), RealRegister(REGNUM_EDI), gen);
1897            gen.markRegDefined(REGNUM_EDI);
1898            emitSimpleInsn(neg ? 0xF2 : 0xF3, gen); // rep(n)e
1899            switch(sc) {
1900              case 0:
1901                 emitSimpleInsn(0xA6, gen); // cmpsb
1902                 break;
1903              case 1:
1904                 emitSimpleInsn(0x66, gen); // operand size override for cmpsw;
1905              case 2:
1906                 emitSimpleInsn(0xA7, gen); // cmpsw/d
1907                 break;
1908              default:
1909                 assert(!"Wrong scale!");
1910            }
1911            restoreGPRtoGPR(RealRegister(REGNUM_ECX), RealRegister(REGNUM_EAX), gen); // old ecx -> eax
1912            emitSubRegReg(RealRegister(REGNUM_EAX), RealRegister(REGNUM_ECX), gen); // eax = eax - ecx
1913            if(sc > 0)
1914               emitSHL(RealRegister(REGNUM_EAX), static_cast<unsigned char>(sc), gen); // shl eax, scale
1915            RealRegister dest_r = gen.rs()->loadVirtualForWrite(dest, gen);
1916            emitMovRegToReg(dest_r, RealRegister(REGNUM_EAX), gen);
1917
1918            break;
1919         }
1920         default:
1921            assert(!"Wrong emulation!");
1922       }
1923    }
1924    else if(rb > -1) {
1925       //bperr( "!!!In case rb > -1!!!\n");
1926       // TODO: 16-bit pseudoregisters
1927       assert(rb < 8); 
1928       RealRegister dest_r = gen.rs()->loadVirtualForWrite(dest, gen);
1929       restoreGPRtoGPR(RealRegister(rb), dest_r, gen); // mov dest, [saved_rb]
1930       if(sc > 0)
1931          emitSHL(dest_r, static_cast<unsigned char>(sc), gen); // shl eax, scale
1932    }
1933    else {
1934       RealRegister dest_r = gen.rs()->loadVirtualForWrite(dest, gen);
1935       emitMovImmToReg(dest_r, imm, gen);
1936    }
1937 }
1938
1939 void emitVload(opCode op, Address src1, Register src2, Register dest, 
1940                codeGen &gen, bool /*noCost*/, 
1941                registerSpace * /*rs*/, int size,
1942                const instPoint * /* location */, AddressSpace * /* proc */)
1943 {
1944    if (op == loadConstOp) {
1945       // dest is a temporary
1946       // src1 is an immediate value 
1947       // dest = src1:imm32
1948        gen.codeEmitter()->emitLoadConst(dest, src1, gen);
1949       return;
1950    } else if (op ==  loadOp) {
1951       // dest is a temporary
1952       // src1 is the address of the operand
1953       // dest = [src1]
1954        gen.codeEmitter()->emitLoad(dest, src1, size, gen);
1955       return;
1956    } else if (op == loadFrameRelativeOp) {
1957       // dest is a temporary
1958       // src1 is the offset of the from the frame of the variable
1959        gen.codeEmitter()->emitLoadOrigFrameRelative(dest, src1, gen);
1960        return;
1961    } else if (op == loadRegRelativeOp) {
1962       // dest is a temporary
1963       // src2 is the register 
1964       // src1 is the offset from the address in src2
1965       gen.codeEmitter()->emitLoadOrigRegRelative(dest, src1, src2, gen, true);
1966       return;
1967    } else if (op == loadRegRelativeAddr) {
1968       // dest is a temporary
1969       // src2 is the register 
1970       // src1 is the offset from the address in src2
1971       gen.codeEmitter()->emitLoadOrigRegRelative(dest, src1, src2, gen, false);
1972       return;
1973    } else if (op == loadFrameAddr) {
1974        gen.codeEmitter()->emitLoadFrameAddr(dest, src1, gen);
1975        return;
1976    } else {
1977       abort();                // unexpected op for this emit!
1978    }
1979 }
1980
1981 void emitVstore(opCode op, Register src1, Register src2, Address dest,
1982                 codeGen &gen, bool /*noCost*/, registerSpace * /*rs*/, 
1983                 int size,
1984                 const instPoint * /* location */, AddressSpace * /* proc */)
1985 {
1986    if (op ==  storeOp) {
1987       // [dest] = src1
1988       // dest has the address where src1 is to be stored
1989       // src1 is a temporary
1990       // src2 is a "scratch" register, we don't need it in this architecture
1991        gen.codeEmitter()->emitStore(dest, src1, size, gen);
1992       return;
1993    } else if (op == storeFrameRelativeOp) {
1994        // src1 is a temporary
1995        // src2 is a "scratch" register, we don't need it in this architecture
1996        // dest is the frame offset 
1997        gen.codeEmitter()->emitStoreFrameRelative(dest, src1, src2, size, gen);
1998        return;
1999    } else {
2000        abort();                // unexpected op for this emit!
2001    }
2002 }
2003
2004 void emitV(opCode op, Register src1, Register src2, Register dest, 
2005            codeGen &gen, bool /*noCost*/, 
2006            registerSpace * /*rs*/, int size,
2007            const instPoint * /* location */, AddressSpace * /* proc */)
2008 {
2009     //bperr( "emitV(op=%d,src1=%d,src2=%d,dest=%d)\n", op, src1,
2010     //        src2, dest);
2011     
2012     assert ((op!=branchOp) && (op!=ifOp) &&
2013             (op!=trampPreamble));         // !emitA
2014     assert ((op!=getRetValOp) && (op!=getParamOp));             // !emitR
2015     assert ((op!=loadOp) && (op!=loadConstOp));                 // !emitVload
2016     assert ((op!=storeOp));                                     // !emitVstore
2017     assert ((op!=updateCostOp));                                // !emitVupdate
2018     
2019     if (op ==  loadIndirOp) {
2020         // same as loadOp, but the value to load is already in a register
2021        gen.codeEmitter()->emitLoadIndir(dest, src1, size, gen);
2022     } 
2023     else if (op ==  storeIndirOp) {
2024         // same as storeOp, but the address where to store is already in a
2025         // register
2026        gen.codeEmitter()->emitStoreIndir(dest, src1, size, gen);
2027     } else if (op == noOp) {
2028         emitSimpleInsn(NOP, gen); // nop
2029     } else if (op == saveRegOp) {
2030         // Push....
2031         assert(src2 == 0);
2032         assert(dest == 0);
2033         gen.codeEmitter()->emitPush(gen, src1);
2034     } else if (op == loadRegOp) {
2035         assert(src1 == 0);
2036         assert(src2 == 0);
2037         gen.codeEmitter()->emitPop(gen, dest);
2038     } else {
2039         unsigned opcode = 0;//initialize to placate gcc warnings
2040         switch (op) {
2041             // integer ops
2042         case plusOp:
2043             // dest = src1 + src2
2044             // mv eax, src1
2045             // add eax, src2
2046             // mov dest, eax
2047             opcode = 0x03; // ADD
2048             break;
2049             
2050         case minusOp:
2051             opcode = 0x2B; // SUB
2052             break;
2053             
2054         case timesOp:
2055             opcode = 0x0FAF; // IMUL
2056             break;
2057
2058         case divOp: {
2059            // dest = src1 div src2
2060            gen.codeEmitter()->emitDiv(dest, src1, src2, gen);
2061            return;
2062            break;
2063         }
2064            // Bool ops
2065         case orOp:
2066            opcode = 0x0B; // OR 
2067            break;
2068
2069         case andOp:
2070            opcode = 0x23; // AND
2071            break;
2072
2073            // rel ops
2074            // dest = src1 relop src2
2075         case eqOp:
2076         case neOp:
2077         case lessOp:
2078         case leOp:
2079         case greaterOp:
2080         case geOp: {
2081             gen.codeEmitter()->emitRelOp(op, dest, src1, src2, gen);
2082             return;
2083             break;
2084         }
2085         default:
2086             abort();
2087             break;
2088         }
2089         gen.codeEmitter()->emitOp(opcode, dest, src1, src2, gen);
2090     }
2091     return;
2092 }
2093
2094 void emitImm(opCode op, Register src1, RegValue src2imm, Register dest, 
2095              codeGen &gen, bool, registerSpace *)
2096 {
2097    if (op ==  storeOp) {
2098        // this doesn't seem to ever be called from ast.C (or anywhere) - gq
2099
2100       // [dest] = src1
2101       // dest has the address where src1 is to be stored
2102       // src1 is an immediate value
2103       // src2 is a "scratch" register, we don't need it in this architecture
2104       emitMovImmToReg(RealRegister(REGNUM_EAX), dest, gen);
2105       emitMovImmToRM(RealRegister(REGNUM_EAX), 0, src1, gen);
2106    } else {
2107       unsigned opcode1;
2108       unsigned opcode2;
2109       switch (op) {
2110          // integer ops
2111          case plusOp:
2112             opcode1 = 0x81;
2113             opcode2 = 0x0; // ADD
2114             break;            
2115          case minusOp:
2116             opcode1 = 0x81;
2117             opcode2 = 0x5; // SUB
2118             break;            
2119          case timesOp:
2120             gen.codeEmitter()->emitTimesImm(dest, src1, src2imm, gen);
2121             return;
2122          case divOp:
2123             gen.codeEmitter()->emitDivImm(dest, src1, src2imm, gen);
2124             return;
2125          // Bool ops
2126          case orOp:
2127             opcode1 = 0x81;
2128             opcode2 = 0x1; // OR 
2129             break;            
2130          case andOp:
2131            opcode1 = 0x81;
2132            opcode2 = 0x4; // AND
2133            break;
2134          // rel ops
2135          // dest = src1 relop src2
2136          case eqOp:
2137          case neOp:
2138          case lessOp:
2139          case leOp:
2140          case greaterOp:
2141          case geOp:
2142             gen.codeEmitter()->emitRelOpImm(op, dest, src1, src2imm, gen);
2143             return;
2144          default:
2145           abort();
2146           break;
2147       }
2148       gen.codeEmitter()->emitOpImm(opcode1, opcode2, dest, src1, src2imm, gen);
2149    }
2150    return;
2151 }
2152
2153
2154 // TODO: mux this between x86 and AMD64
2155 int getInsnCost(opCode op)
2156 {
2157    if (op == loadConstOp) {
2158       return(1);
2159    } else if (op ==  loadOp) {
2160       return(1+1);
2161    } else if (op ==  loadIndirOp) {
2162       return(3);
2163    } else if (op ==  storeOp) {
2164       return(1+1); 
2165    } else if (op ==  storeIndirOp) {
2166       return(3);
2167    } else if (op ==  ifOp) {
2168       return(1+2+1);
2169    } else if (op ==  ifMCOp) { // VG(8/15/02): No clue if this is right or not
2170       return(1+2+1);
2171    } else if (op ==  whileOp) {
2172       return(1+2+1+1); /* Need to find out about this */
2173    } else if (op == branchOp) {
2174       return(1);        /* XXX Need to find out what value this should be. */
2175    } else if (op ==  callOp) {
2176       // cost of call only
2177       return(1+2+1+1);
2178    } else if (op == funcJumpOp) {
2179       // copy callOp
2180       return(1+2+1+1);
2181    } else if (op == updateCostOp) {
2182       return(3);
2183    } else if (op ==  trampPreamble) {
2184       return(0);
2185    } else if (op == noOp) {
2186       return(1);
2187    } else if (op == getRetValOp) {
2188       return (1+1);
2189    } else if (op == getParamOp) {
2190       return(1+1);
2191    } else {
2192       switch (op) {
2193          // rel ops
2194         case eqOp:
2195         case neOp:
2196         case lessOp:
2197         case leOp:
2198         case greaterOp:
2199         case geOp:
2200                 return(1+1+2+1+1+1);
2201                 break;
2202         case divOp:
2203            return(1+2+46+1);
2204         case timesOp:
2205            return(1+10+1);
2206         case plusOp:
2207         case minusOp:
2208         case orOp:
2209         case andOp:
2210            return(1+2+1);
2211         case getAddrOp:
2212            return(0);   // doesn't add anything to operand
2213         default:
2214            assert(0);
2215            return 0;
2216            break;
2217       }
2218    }
2219    return 0;
2220 }
2221
2222
2223 //
2224 // return cost in cycles of executing at this point.  This is the cost
2225 //   of the base tramp if it is the first at this point or 0 otherwise.
2226 //
2227 // We now have multiple versions of instrumentation... so, how does this work?
2228 // We look for a local maximum.
2229 int instPoint::getPointCost()
2230 {
2231   unsigned worstCost = 0;
2232   for (unsigned i = 0; i < instances.size(); i++) {
2233       if (instances[i]->multi()) {
2234           if (instances[i]->multi()->usesTrap()) {
2235               // Stop right here
2236               // Actually, probably don't want this if the "always
2237               // delivered" instrumentation happens
2238               return 9000; // Estimated trap cost
2239           }
2240           else {
2241               // Base tramp cost if we're first at point, otherwise
2242               // free (someone else paid)
2243               // Which makes no sense, since we're talking an entire instPoint.
2244               // So if there is a multitramp hooked up we use the base tramp cost.
2245               worstCost = 83; // Magic constant from before time
2246           }
2247       }
2248       else {
2249           // No multiTramp, so still free (we're not instrumenting here).
2250       }
2251   }
2252   return worstCost;
2253 }
2254
2255 unsigned baseTramp::getBTCost() {
2256     // Check this...
2257     return 83;
2258 }
2259
2260 // Emit code to jump to function CALLEE without linking.  (I.e., when
2261 // CALLEE returns, it returns to the current caller.)
2262 void emitFuncJump(opCode op, 
2263                   codeGen &gen,
2264                   int_function *callee, AddressSpace *,
2265                   const instPoint *loc, bool)
2266 {
2267    // This must mimic the generateRestores baseTramp method. 
2268     assert(op == funcJumpOp || op == funcCallOp);
2269
2270     instPointType_t ptType = loc->getPointType();
2271     gen.codeEmitter()->emitFuncJump(callee, ptType, (op == funcCallOp), gen);
2272 }
2273
2274 #define MAX_SINT ((signed int) (0x7fffffff))
2275 #define MIN_SINT ((signed int) (0x80000000))
2276 void EmitterIA32::emitFuncJump(int_function *f, instPointType_t /*ptType*/, bool callOp,
2277                                codeGen &gen)
2278 {       
2279     assert(gen.bti());
2280     Address addr = f->getAddress();
2281     signed int disp = addr - (gen.currAddr()+5);
2282
2283     if (callOp) {
2284        //Set up a slot on the stack for the return address
2285
2286        //Get the current PC.
2287        Register dest = gen.rs()->getScratchRegister(gen);
2288        RealRegister dest_r = gen.rs()->loadVirtualForWrite(dest, gen);
2289        GET_PTR(patch_start, gen);
2290        emitMovPCRMToReg(dest_r, 0, gen, false);
2291        
2292        //Add the distance from the current PC to the end if this
2293        // baseTramp (which isn't known yet).
2294        GET_PTR(insn, gen);
2295        *insn++ = 0x81;
2296        *insn++ = makeModRMbyte(3, 0, dest_r.reg());
2297        void *patch_loc = (void *) insn;
2298        *((int *)insn) = 0x0;
2299        insn += sizeof(int);
2300        SET_PTR(insn, gen);
2301
2302        //Store the computed return address into the stack slot.
2303        stackItemLocation loc = getHeightOf(stackItem::stacktop, gen);
2304        emitMovRegToRM(loc.reg, loc.offset-4, dest_r, gen);
2305        gen.rs()->freeRegister(dest);
2306
2307        //Create a patch to fill in the end of the baseTramp to the above
2308        // instruction when it becomes known.
2309        generatedCodeObject *nextobj = gen.bti()->nextObj()->nextObj();
2310        assert(nextobj);
2311        int offset = ((unsigned long) patch_start) - ((unsigned long) gen.start_ptr());
2312        relocPatch newPatch(patch_loc, nextobj, relocPatch::pcrel, &gen, 
2313                            offset, sizeof(int));
2314        gen.addPatch(newPatch);
2315     }
2316
2317     if (f->proc() == gen.addrSpace() &&
2318         gen.startAddr() &&
2319        disp < MAX_SINT &&
2320        disp > MIN_SINT)
2321     {
2322        //Same module or dynamic instrumentation and address and within
2323        // jump distance.
2324        cfjRet_t tmp = gen.bti()->hasFuncJump();
2325        gen.bti()->setHasFuncJump(cfj_jump);
2326        emitBTRestores(gen.bti()->baseT, gen.bti(), gen);
2327        gen.bti()->setHasFuncJump(tmp);
2328
2329        int disp = addr - (gen.currAddr()+5);
2330        emitJump(disp, gen);
2331     }
2332     else if (dynamic_cast<process *>(gen.addrSpace())) {
2333        //Dynamic instrumentation, emit an absolute jump (push/ret combo)
2334        cfjRet_t tmp = gen.bti()->hasFuncJump();
2335        gen.bti()->setHasFuncJump(cfj_jump);
2336        emitBTRestores(gen.bti()->baseT, gen.bti(), gen);
2337        gen.bti()->setHasFuncJump(tmp);
2338
2339        GET_PTR(insn, gen);
2340        *insn++ = 0x68; /* push 32 bit immediate */
2341        *((int *)insn) = addr; /* the immediate */
2342        insn += 4;
2343        *insn++ = 0xc3; /* ret */
2344        SET_PTR(insn, gen);
2345     }
2346     else if (dynamic_cast<BinaryEdit *>(gen.addrSpace())) {
2347        //Static instrumentation, calculate and store the target 
2348        // value to the top of our instrumentation stack and return to it.
2349        assert(gen.bti() && gen.bti()->hasFuncJump());
2350
2351        //Get address of target into realr
2352        Register reg = gen.rs()->getScratchRegister(gen);
2353        RealRegister realr = gen.rs()->loadVirtualForWrite(reg, gen);
2354        Address dest = getInterModuleFuncAddr(f, gen);
2355        emitMovPCRMToReg(realr, dest-gen.currAddr(), gen);
2356        //Mov realr to stack slot
2357        stackItemLocation loc = getHeightOf(stackItem::stacktop, gen);
2358        int top_offset = callOp ? -8 : -4;
2359        emitMovRegToRM(loc.reg, loc.offset+top_offset, realr, gen);
2360
2361        //Temporarily unset the hasFuncJump so that when we restore the BT
2362        // the funcJump slot is not cleaned.
2363        cfjRet_t tmp = gen.bti()->hasFuncJump();
2364        gen.bti()->setHasFuncJump(cfj_none);
2365        emitBTRestores(gen.bti()->baseT, gen.bti(), gen);
2366        gen.bti()->setHasFuncJump(tmp);
2367
2368        //The address should be left on the stack.  Just return now.
2369        GET_PTR(insn, gen);
2370        *insn++ = 0xc3;
2371        SET_PTR(insn, gen);
2372     }
2373
2374     insnCodeGen::generateIllegal(gen);
2375 }
2376
2377 bool EmitterIA32::emitPush(codeGen &gen, Register reg) {
2378     RealRegister real_reg = gen.rs()->loadVirtual(reg, gen);
2379     return ::emitPush(real_reg, gen);
2380 }
2381
2382 bool EmitterIA32::emitPop(codeGen &gen, Register reg) {
2383     RealRegister real_reg = gen.rs()->loadVirtual(reg, gen);
2384     return ::emitPop(real_reg, gen);
2385 }
2386
2387 bool emitPush(RealRegister reg, codeGen &gen) {
2388     GET_PTR(insn, gen);
2389     int r = reg.reg();
2390     assert(r < 8);
2391
2392     *insn++ = static_cast<unsigned char>(0x50 + r); // 0x50 is push EAX, and it increases from there.
2393
2394     SET_PTR(insn, gen);
2395     gen.rs()->incStack(4);
2396     return true;
2397 }
2398
2399 bool emitPop(RealRegister reg, codeGen &gen) {
2400     GET_PTR(insn, gen);
2401     int r = reg.reg();
2402     assert(r < 8);
2403     *insn++ = static_cast<unsigned char>(0x58 + r);    
2404     SET_PTR(insn, gen);
2405     gen.rs()->incStack(-4);
2406     return true;
2407 }
2408
2409 bool EmitterIA32::emitAdjustStackPointer(int index, codeGen &gen) {
2410         // The index will be positive for "needs popped" and negative
2411         // for "needs pushed". However, positive + SP works, so don't
2412         // invert.
2413         int popVal = index * gen.addrSpace()->getAddressWidth();
2414         emitOpExtRegImm(0x81, EXTENDED_0x81_ADD, RealRegister(REGNUM_ESP), popVal, gen);
2415    gen.rs()->incStack(-1 * popVal);
2416         return true;
2417 }
2418
2419
2420 void emitLoadPreviousStackFrameRegister(Address register_num,
2421                                         Register dest,
2422                                         codeGen &gen,
2423                                         int,
2424                                         bool){
2425     gen.codeEmitter()->emitLoadOrigRegister(register_num, dest, gen);
2426 }
2427
2428 void emitStorePreviousStackFrameRegister(Address register_num,
2429                                         Register src,
2430                                         codeGen &gen,
2431                                         int,
2432                                         bool) {
2433     gen.codeEmitter()->emitStoreOrigRegister(register_num, src, gen);
2434 }
2435
2436 // First AST node: target of the call
2437 // Second AST node: source of the call
2438 // This can handle indirect control transfers as well 
2439 bool AddressSpace::getDynamicCallSiteArgs(instPoint *callSite,
2440                                           pdvector<AstNodePtr> &args)
2441 {
2442    using namespace Dyninst::InstructionAPI;        
2443    Expression::Ptr cft = callSite->insn()->getControlFlowTarget();
2444    ASTFactory f;
2445    cft->apply(&f);
2446    assert(f.m_stack.size() == 1);
2447    args.push_back(f.m_stack[0]);
2448    args.push_back(AstNode::operandNode(AstNode::Constant,
2449                                        (void *) callSite->addr()));
2450    inst_printf("%s[%d]:  Inserting dynamic call site instrumentation for %s\n",
2451                FILE__, __LINE__, cft->format().c_str());
2452    return true;
2453 }
2454
2455 /****************************************************************************/
2456 /****************************************************************************/
2457
2458 int getMaxJumpSize()
2459 {
2460   return JUMP_REL32_SZ;
2461 }
2462
2463 // TODO: fix this so we don't screw future instrumentation of this
2464 // function. It's a cute little hack, but jeez.
2465 bool int_function::setReturnValue(int val)
2466 {
2467     codeGen gen(16);
2468
2469     Address addr = getAddress();
2470     emitMovImmToReg(RealRegister(REGNUM_EAX), val, gen);
2471     emitSimpleInsn(0xc3, gen); //ret
2472     
2473     return proc()->writeTextSpace((void *) addr, gen.used(), gen.start_ptr());
2474 }
2475
2476 unsigned saveRestoreRegistersInBaseTramp(process * /*proc*/, 
2477                                          baseTramp * /*bt*/,
2478                                          registerSpace * /*rs*/)
2479 {
2480   return 0;
2481 }
2482
2483 /**
2484  * Fills in an indirect function pointer at 'addr' to point to 'f'.
2485  **/
2486 bool writeFunctionPtr(AddressSpace *p, Address addr, int_function *f)
2487 {
2488    Address val_to_write = f->getAddress();
2489    return p->writeDataSpace((void *) addr, sizeof(Address), &val_to_write);   
2490 }
2491
2492 int instPoint::liveRegSize()
2493 {
2494   return maxGPR;
2495 }
2496
2497 bool emitStoreConst(Address addr, int imm, codeGen &gen, bool noCost) {
2498    gen.codeEmitter()->emitStoreImm(addr, imm, gen, noCost);
2499    return true;
2500 }
2501
2502 bool emitAddSignedImm(Address addr, long int imm, codeGen &gen, bool noCost) {
2503    gen.codeEmitter()->emitAddSignedImm(addr, imm, gen, noCost);
2504    return true;
2505 }
2506
2507 bool emitSubSignedImm(Address addr, long int imm, codeGen &gen, bool noCost) {
2508    gen.codeEmitter()->emitAddSignedImm(addr, imm * -1, gen, noCost);
2509    return true;
2510 }
2511
2512 Emitter *AddressSpace::getEmitter() 
2513 {
2514    static EmitterIA32Dyn emitter32Dyn;
2515    static EmitterIA32Stat emitter32Stat;
2516
2517 #if defined(arch_x86_64)
2518    static EmitterAMD64Dyn emitter64Dyn;
2519    static EmitterAMD64Stat emitter64Stat;
2520
2521    if (getAddressWidth() == 8) {
2522        if (proc()) {
2523            return &emitter64Dyn;
2524        }
2525        else {
2526            assert(edit());
2527            return &emitter64Stat;
2528        }
2529    }
2530 #endif
2531    if (proc()) {
2532        return &emitter32Dyn;
2533    }
2534    else {
2535        assert(edit());
2536        return &emitter32Stat;
2537    }
2538 }
2539
2540 #if defined(arch_x86_64)
2541 int registerSpace::framePointer() { 
2542    return addr_width == 8 ? REGNUM_RBP : REGNUM_EBP; 
2543 }
2544 #elif defined(arch_x86)
2545 int registerSpace::framePointer() { 
2546    return REGNUM_EBP; 
2547 }
2548 #endif
2549
2550 void registerSpace::initRealRegSpace()
2551 {
2552    for (unsigned i=0; i<regStateStack.size(); i++) {
2553       if (regStateStack[i])
2554          delete regStateStack[i];
2555    }
2556    regStateStack.clear();
2557
2558    regState_t *new_regState = new regState_t();
2559    regStateStack.push_back(new_regState);
2560    regs_been_spilled.clear();
2561    
2562    pc_rel_reg = Null_Register;
2563    pc_rel_use_count = 0;
2564 }
2565
2566 void registerSpace::movRegToReg(RealRegister dest, RealRegister src, codeGen &gen)
2567 {
2568    gen.markRegDefined(dest.reg());
2569    emitMovRegToReg(dest, src, gen);
2570 }
2571
2572 void registerSpace::spillToVReg(RealRegister reg, registerSlot *v_reg, codeGen &gen)
2573 {
2574    stackItemLocation loc = getHeightOf(stackItem::framebase, gen);
2575    loc.offset += -4*v_reg->encoding();
2576    emitMovRegToRM(loc.reg, loc.offset, reg, gen);
2577 }
2578
2579 void registerSpace::movVRegToReal(registerSlot *v_reg, RealRegister r, codeGen &gen)
2580 {
2581    stackItemLocation loc = getHeightOf(stackItem::framebase, gen);
2582    loc.offset += -4*v_reg->encoding();
2583    gen.markRegDefined(r.reg());
2584    emitMovRMToReg(r, loc.reg, loc.offset, gen);
2585 }
2586
2587 void emitBTRegRestores32(baseTrampInstance *bti, codeGen &gen)
2588 {
2589    int numRegsUsed = bti ? bti->numDefinedRegs() : -1;
2590    if (numRegsUsed == -1 || 
2591        numRegsUsed > X86_REGS_SAVE_LIMIT) {
2592       emitSimpleInsn(POPAD, gen);
2593    }
2594    else {
2595       registerSlot *reg;
2596       pdvector<registerSlot *> &regs = gen.rs()->trampRegs();
2597       for (int i=regs.size()-1; i>=0; i--) {
2598          reg = regs[i];          
2599          if (reg->encoding() != REGNUM_ESP && 
2600              reg->encoding() != REGNUM_EBP &&
2601              reg->spilledState != registerSlot::unspilled)
2602          {
2603             emitPop(RealRegister(reg->encoding()), gen);
2604          }
2605       }
2606    }
2607    
2608    gen.rs()->restoreVolatileRegisters(gen);
2609 }
2610
2611 regState_t::regState_t() : 
2612    pc_rel_offset(-1), 
2613    timeline(0), 
2614    stack_height(0) 
2615 {
2616    for (unsigned i=0; i<8; i++) {
2617       RealRegsState r;
2618       r.is_allocatable = (i != REGNUM_ESP && i != REGNUM_EBP);
2619       r.been_used = false;
2620       r.last_used = 0;
2621       r.contains = NULL;
2622       registerStates.push_back(r);
2623    }
2624 }
2625
2626 void emitSaveO(codeGen &gen)
2627 {
2628    GET_PTR(insn, gen);
2629    *insn++ = 0x0f;
2630    *insn++ = 0x90;
2631    *insn++ = 0xC0;
2632    SET_PTR(insn, gen);
2633 }
2634
2635 void emitRestoreO(codeGen &gen)
2636 {
2637    GET_PTR(insn, gen);
2638    *insn++ = 0x80;
2639    *insn++ = 0xC0;
2640    *insn++ = 0x7f;
2641    SET_PTR(insn, gen);
2642 }
2643
2644 void emitCallRel32(unsigned disp32, codeGen &gen)
2645 {
2646    GET_PTR(insn, gen);
2647    *insn++ = 0xE8;
2648    *((int *) insn) = disp32;
2649    insn += sizeof(int);
2650    SET_PTR(insn, gen);
2651 }
2652
2653 void emitJump(unsigned disp32, codeGen &gen)
2654 {
2655    GET_PTR(insn, gen);
2656    *insn++ = 0xE9;
2657    *((int *) insn) = disp32;
2658    insn += sizeof(int);
2659    SET_PTR(insn, gen);
2660 }
2661
2662 #if defined(os_linux) || defined(os_freebsd)
2663
2664 // These functions were factored from linux-x86.C because
2665 // they are identical on Linux and FreeBSD
2666
2667 int EmitterIA32::emitCallParams(codeGen &gen, 
2668                               const pdvector<AstNodePtr> &operands,
2669                               int_function */*target*/, 
2670                               pdvector<Register> &/*extra_saves*/, 
2671                               bool noCost)
2672 {
2673     pdvector <Register> srcs;
2674     unsigned frame_size = 0;
2675     unsigned u;
2676     for (u = 0; u < operands.size(); u++) {
2677         Address unused = ADDR_NULL;
2678         Register reg = REG_NULL;
2679         if (!operands[u]->generateCode_phase2(gen,
2680                                               noCost,
2681                                               unused,
2682                                               reg)) assert(0); // ARGH....
2683         assert (reg != REG_NULL); // Give me a real return path!
2684         srcs.push_back(reg);
2685     }
2686     
2687     // push arguments in reverse order, last argument first
2688     // must use int instead of unsigned to avoid nasty underflow problem:
2689     for (int i=srcs.size() - 1; i >= 0; i--) {
2690        RealRegister r = gen.rs()->loadVirtual(srcs[i], gen);
2691        ::emitPush(r, gen);
2692        frame_size += 4;
2693        if (operands[i]->decRefCount())
2694           gen.rs()->freeRegister(srcs[i]);
2695     }
2696     return frame_size;
2697 }
2698
2699 bool EmitterIA32::emitCallCleanup(codeGen &gen,
2700                                 int_function * /*target*/, 
2701                                 int frame_size, 
2702                                 pdvector<Register> &/*extra_saves*/)
2703 {
2704    if (frame_size)
2705       emitOpRegImm(0, RealRegister(REGNUM_ESP), frame_size, gen); // add esp, frame_size
2706    gen.rs()->incStack(-1 * frame_size);
2707    return true;
2708 }
2709
2710 #endif