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