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