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