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