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