Define cap_stack_mods and properly limit stack mods to x86,x86_64
[dyninst.git] / dyninstAPI / src / ast.C
1 /*
2  * See the dyninst/COPYRIGHT file for copyright information.
3  * 
4  * We provide the Paradyn Tools (below described as "Paradyn")
5  * on an AS IS basis, and do not warrant its validity or performance.
6  * We reserve the right to update, modify, or discontinue this
7  * software at any time.  We shall have no obligation to supply such
8  * updates or modifications or any other form of support to you.
9  * 
10  * By your use of Paradyn, you understand and agree that we (or any
11  * other person or entity with proprietary rights in Paradyn) are
12  * under no obligation to provide either maintenance services,
13  * update services, notices of latent defects, or correction of
14  * defects for Paradyn.
15  * 
16  * This library is free software; you can redistribute it and/or
17  * modify it under the terms of the GNU Lesser General Public
18  * License as published by the Free Software Foundation; either
19  * version 2.1 of the License, or (at your option) any later version.
20  * 
21  * This library is distributed in the hope that it will be useful,
22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
24  * Lesser General Public License for more details.
25  * 
26  * You should have received a copy of the GNU Lesser General Public
27  * License along with this library; if not, write to the Free Software
28  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
29  */
30
31 // $Id: ast.C,v 1.209 2008/09/15 18:37:49 jaw Exp $
32
33 #include "dyninstAPI/src/image.h"
34 #include "function.h"
35 #include "inst.h"
36 #include "instP.h"
37 #include "instPoint.h"
38 #include "ast.h"
39 #include "util.h"
40 #include "debug.h"
41
42 extern int dyn_debug_ast;
43
44
45
46 #include "Instruction.h"
47 using namespace Dyninst::InstructionAPI;
48
49 #include "dyninstAPI/h/BPatch.h"
50 #include "BPatch_collections.h"
51 #include "dyninstAPI/h/BPatch_type.h"
52 #include "BPatch_libInfo.h" // For instPoint->BPatch_point mapping
53 #include "BPatch_function.h"
54 #include "dyninstAPI/h/BPatch_point.h"
55 #include "dyninstAPI/h/BPatch_memoryAccess_NP.h"
56 #include "dyninstAPI/h/BPatch_type.h"
57 #include "dyninstAPI/src/RegisterConversion.h"
58
59 #include "addressSpace.h"
60 #include "binaryEdit.h"
61
62 #if defined(arch_power)
63 #include "inst-power.h"
64 #elif defined(arch_x86) || defined (arch_x86_64)
65 #include "inst-x86.h"
66 #include "emit-x86.h"
67 extern int tramp_pre_frame_size_32;
68 extern int tramp_pre_frame_size_64;
69 #else
70 #error "Unknown architecture in ast.h"
71 #endif
72
73 #include "emitter.h"
74
75 #include "registerSpace.h"
76 #include "mapped_module.h"
77
78 #include "legacy-instruction.h"
79 #include "mapped_object.h"
80 #include "Buffer.h"
81
82 using namespace Dyninst;
83 using PatchAPI::Point;
84
85 extern bool doNotOverflow(int value);
86
87 AstNodePtr AstNode::originalAddrNode_ = AstNodePtr();
88 AstNodePtr AstNode::actualAddrNode_ = AstNodePtr();
89 AstNodePtr AstNode::dynamicTargetNode_ = AstNodePtr();
90
91 AstNode::AstNode() {
92 #if defined(ASTDEBUG)
93    ASTcounter();
94 #endif
95
96 //   dyn_debug_ast = 0;
97    referenceCount = 0;
98    useCount = 0;
99    // "operands" is left as an empty vector
100    size = 4;
101    bptype = NULL;
102    doTypeCheck = true;
103    lineNum = 0;
104    columnNum = 0;
105    snippetName = NULL;
106    lineInfoSet = false;
107    columnInfoSet = false;
108    snippetNameSet = false;
109 }
110
111 //The following methods are for error reporting in dynC_API
112
113 // Returns the line number at which the ast was declared
114 int AstNode::getLineNum(){
115    return lineNum;
116 }
117
118 // Sets the line number at which the ast was declared
119 void AstNode::setLineNum(int ln){
120    lineInfoSet = true;
121    lineNum = ln;
122 }
123
124 // Returns the column number at which the ast was declared
125 int AstNode::getColumnNum(){
126    return columnNum;
127 }
128
129 // Sets the column number at which the ast was declared
130 void AstNode::setColumnNum(int cn){
131    columnInfoSet = true;
132    columnNum = cn;
133 }
134
135 char * AstNode::getSnippetName(){
136    return snippetName;
137 }
138
139 void AstNode::setSnippetName(char *n){
140    if(n != NULL){
141 //      printf(":::%s\n", n);
142       snippetName = n;
143       snippetNameSet = true;
144    }
145 }
146
147 bool AstNode::hasLineInfo(){
148    return lineInfoSet;
149 }
150
151
152 bool AstNode::hasColumnInfo(){
153    return columnInfoSet;
154 }
155
156 bool AstNode::hasNameInfo(){
157    return snippetNameSet;
158 }
159
160 //////////////////////////////////////////////////////
161
162 AstNodePtr AstNode::nullNode() {
163     return AstNodePtr(new AstNullNode());
164 }
165
166 AstNodePtr AstNode::stackInsertNode(int size, long dispFromRSP, MSpecialType type) {
167     return AstNodePtr(new AstStackInsertNode(size, dispFromRSP, type));
168 }
169
170 AstNodePtr AstNode::stackRemoveNode(int size, MSpecialType type) {
171     return AstNodePtr(new AstStackRemoveNode(size, type));
172 }
173
174 AstNodePtr AstNode::stackRemoveNode(int size, MSpecialType type, func_instance* func, bool canaryAfterPrologue, long canaryHeight) {
175     return AstNodePtr(new AstStackRemoveNode(size, type, func, canaryAfterPrologue, canaryHeight));
176 }
177
178 AstNodePtr AstNode::stackGenericNode() {
179     return AstNodePtr(new AstStackGenericNode());
180 }
181
182 AstNodePtr AstNode::labelNode(std::string &label) {
183     return AstNodePtr (new AstLabelNode(label));
184 }
185
186 AstNodePtr AstNode::operandNode(operandType ot, void *arg) {
187     return AstNodePtr(new AstOperandNode(ot, arg));
188 }
189
190 // TODO: this is an indirect load; should be an operator.
191 AstNodePtr AstNode::operandNode(operandType ot, AstNodePtr ast) {
192     return AstNodePtr(new AstOperandNode(ot, ast));
193 }
194
195 AstNodePtr AstNode::operandNode(operandType ot, const image_variable* iv) {
196     return AstNodePtr(new AstOperandNode(ot, iv));
197 }
198
199 AstNodePtr AstNode::sequenceNode(pdvector<AstNodePtr > &sequence) {
200 //    assert(sequence.size());
201     return AstNodePtr(new AstSequenceNode(sequence));
202 }
203
204 AstNodePtr AstNode::variableNode(vector<AstNodePtr> &ast_wrappers, 
205                                  vector<pair<Offset, Offset> >*ranges) {
206     return AstNodePtr(new AstVariableNode(ast_wrappers, ranges));
207 }
208
209 AstNodePtr AstNode::operatorNode(opCode ot, AstNodePtr l, AstNodePtr r, AstNodePtr e) {
210     return AstNodePtr(new AstOperatorNode(ot, l, r, e));
211 }
212
213 AstNodePtr AstNode::funcCallNode(const std::string &func, pdvector<AstNodePtr > &args,
214       AddressSpace *addrSpace) 
215 {
216    if (addrSpace) 
217    {
218       func_instance *ifunc = addrSpace->findOnlyOneFunction(func.c_str());
219
220       if (ifunc == NULL) 
221       {
222          fprintf(stderr, "Bitch whine moan\n"); 
223          fprintf(stderr, "%s[%d]: Can't find function %s\n", FILE__, __LINE__, func.c_str());
224          return AstNodePtr();
225       }
226
227       return AstNodePtr(new AstCallNode(ifunc, args));
228    }
229    else
230       return AstNodePtr(new AstCallNode(func, args));
231 }
232
233 AstNodePtr AstNode::funcCallNode(func_instance *func, pdvector<AstNodePtr > &args) {
234     if (func == NULL) return AstNodePtr();
235     return AstNodePtr(new AstCallNode(func, args));
236 }
237
238 AstNodePtr AstNode::funcCallNode(func_instance *func) {
239     if (func == NULL) return AstNodePtr();
240     return AstNodePtr(new AstCallNode(func));
241 }
242
243 AstNodePtr AstNode::funcCallNode(Address addr, pdvector<AstNodePtr > &args) {
244     return AstNodePtr(new AstCallNode(addr, args));
245 }
246
247 AstNodePtr AstNode::memoryNode(memoryType ma, int which) {
248     return AstNodePtr(new AstMemoryNode(ma, which));
249 }
250
251 AstNodePtr AstNode::miniTrampNode(AstNodePtr tramp) {
252     if (tramp == NULL) return AstNodePtr();
253     return AstNodePtr(new AstMiniTrampNode(tramp));
254 }
255
256 AstNodePtr AstNode::insnNode(BPatch_instruction *insn) {
257     // Figure out what kind of instruction we've got...
258     if (dynamic_cast<BPatch_memoryAccess *>(insn)) {
259         return AstNodePtr(new AstInsnMemoryNode(insn->insn()->insn(), (Address) insn->getAddress()));
260     } 
261     
262     return AstNodePtr(new AstInsnNode(insn->insn()->insn(), (Address) insn->getAddress()));
263 }
264
265 AstNodePtr AstNode::originalAddrNode() {
266     if (originalAddrNode_ == NULL) {
267         originalAddrNode_ = AstNodePtr(new AstOriginalAddrNode());
268     }
269     return originalAddrNode_;
270 }
271
272 AstNodePtr AstNode::actualAddrNode() {
273     if (actualAddrNode_ == NULL) {
274         actualAddrNode_ = AstNodePtr(new AstActualAddrNode());
275     }
276     return actualAddrNode_;
277 }
278
279 AstNodePtr AstNode::dynamicTargetNode() {
280     if (dynamicTargetNode_ == NULL) {
281         dynamicTargetNode_ = AstNodePtr(new AstDynamicTargetNode());
282     }
283     return dynamicTargetNode_;
284 }
285
286 AstNodePtr AstNode::snippetNode(Dyninst::PatchAPI::SnippetPtr snip) {
287    return AstNodePtr(new AstSnippetNode(snip));
288 }
289
290 AstNodePtr AstNode::scrambleRegistersNode(){
291     return AstNodePtr(new AstScrambleRegistersNode());
292 }
293
294 bool isPowerOf2(int value, int &result)
295 {
296   if (value<=0) return(false);
297   if (value==1) {
298     result=0;
299     return(true);
300   }
301   if ((value%2)!=0) return(false);
302   if (isPowerOf2(value/2,result)) {
303     result++;
304     return(true);
305   }
306   else return(false);
307 }
308
309 BPatch_type *AstNode::getType() { return bptype; }
310
311 void AstNode::setType(BPatch_type *t) { 
312     bptype = t;
313     if (t != NULL) { 
314         size = t->getSize(); 
315     }
316 }
317
318 AstOperatorNode::AstOperatorNode(opCode opC, AstNodePtr l, AstNodePtr r, AstNodePtr e) :
319     AstNode(),
320     op(opC),
321     loperand(l),
322     roperand(r),
323     eoperand(e)
324 {
325     // Optimization pass...
326     
327     if (op == plusOp) {
328         if (loperand->getoType() == Constant) {
329             // Swap left and right...
330             AstNodePtr temp = loperand;
331             loperand = roperand;
332             roperand = temp;
333         }
334     }
335     if (op == timesOp) {
336         if (roperand->getoType() == undefOperandType) {
337             // ...
338        }
339         else if (roperand->getoType() != Constant) {
340             AstNodePtr temp = roperand;
341             roperand = loperand;
342             loperand = temp;
343         }
344         else {
345             int result;
346             if (!isPowerOf2((Address)roperand->getOValue(),result) &&
347                 isPowerOf2((Address)loperand->getOValue(),result)) {
348                 AstNodePtr temp = roperand;
349                 roperand = loperand;
350                 loperand = temp;
351             }
352         }
353     }
354     if (l != AstNodePtr())
355     {
356        //Unfortunate hack.  storeOp with a loperand of DataIndir
357        // don't actually reference their loperand--they reference
358        // the child of the loperand.  Handle that here to keep
359        // reference counts sane.
360        if (op == storeOp && loperand->getoType() == DataIndir)
361           l->operand()->referenceCount++;
362        else
363           l->referenceCount++;
364     }
365     if (r != AstNodePtr())
366        r->referenceCount++;
367     if (e != AstNodePtr())
368        e->referenceCount++;
369 };
370
371     // Direct operand
372 AstOperandNode::AstOperandNode(operandType ot, void *arg) :
373     AstNode(),
374     oType(ot),
375     oVar(NULL),
376     operand_()
377 {
378     
379     if (ot == ConstantString)
380         oValue = (void *)P_strdup((char *)arg);
381     else
382         oValue = (void *) arg;
383 }
384
385 // And an indirect (say, a load)
386 AstOperandNode::AstOperandNode(operandType ot, AstNodePtr l) :
387     AstNode(),
388     oType(ot),
389     oValue(NULL),
390     oVar(NULL),
391     operand_(l)
392 {
393    l->referenceCount++;
394 }
395
396 AstOperandNode::AstOperandNode(operandType ot, const image_variable* iv) :
397   AstNode(),
398   oType(ot),
399   oValue(NULL),
400   oVar(iv),
401   operand_()
402 {
403   assert(oVar);
404 }
405
406
407 AstCallNode::AstCallNode(func_instance *func,
408                          pdvector<AstNodePtr > &args) :
409     AstNode(),
410     func_addr_(0),
411     func_(func),
412     callReplace_(false),
413     constFunc_(false)
414 {
415     for (unsigned i = 0; i < args.size(); i++) {
416         args[i]->referenceCount++; 
417         args_.push_back(args[i]);
418     }
419 }
420
421 AstCallNode::AstCallNode(func_instance *func) :
422     AstNode(),
423     func_addr_(0),
424     func_(func),
425     callReplace_(true),
426     constFunc_(false)
427 {
428 }
429
430 AstCallNode::AstCallNode(const std::string &func,
431                          pdvector<AstNodePtr > &args) :
432     AstNode(),
433     func_name_(func),
434     func_addr_(0),
435     func_(NULL),
436     callReplace_(false),
437     constFunc_(false)
438 {
439     for (unsigned i = 0; i < args.size(); i++) {
440         args[i]->referenceCount++; 
441         args_.push_back(args[i]);
442     }
443 }
444
445 AstCallNode::AstCallNode(Address addr,
446                          pdvector<AstNodePtr > &args) :
447     AstNode(),
448     func_addr_(addr),
449     func_(NULL),
450     callReplace_(false),
451     constFunc_(false)
452 {
453     for (unsigned i = 0; i < args.size(); i++) {
454         args[i]->referenceCount++; 
455         args_.push_back(args[i]);
456     }
457 }
458  
459 AstSequenceNode::AstSequenceNode(pdvector<AstNodePtr > &sequence) :
460     AstNode()
461 {
462     for (unsigned i = 0; i < sequence.size(); i++) {
463         sequence[i]->referenceCount++;
464         sequence_.push_back(sequence[i]);
465     }
466 }
467
468 AstVariableNode::AstVariableNode(vector<AstNodePtr>&ast_wrappers, vector<pair<Offset, Offset> > *ranges) :
469     ast_wrappers_(ast_wrappers), ranges_(ranges), index(0)
470 {
471    vector<AstNodePtr>::iterator i;
472    assert(!ast_wrappers_.empty());
473
474    for (i = ast_wrappers.begin(); i != ast_wrappers.end(); i++) {
475       (*i)->referenceCount++;
476    }
477 }
478
479 AstInsnNode::AstInsnNode(instruction *insn, Address addr) :
480     AstNode(),
481     insn_(insn),
482     origAddr_(addr) {
483 }
484
485 AstMemoryNode::AstMemoryNode(memoryType mem,
486                              unsigned which) :
487     AstNode(),
488     mem_(mem),
489     which_(which) {
490     
491     assert(BPatch::bpatch != NULL);
492     assert(BPatch::bpatch->stdTypes != NULL);
493
494     
495     switch(mem_) {
496     case EffectiveAddr:
497         bptype = BPatch::bpatch->stdTypes->findType("void *");
498         break;
499     case BytesAccessed:
500         bptype = BPatch::bpatch->stdTypes->findType("int");
501         break;
502     default:
503         assert(!"Naah...");
504     }
505     size = bptype->getSize();
506     doTypeCheck = BPatch::bpatch->isTypeChecked();
507 };
508
509
510 AstNodePtr AstNode::threadIndexNode() {
511     // We use one of these across all platforms, since it
512     // devolves into a process-specific function node. 
513     // However, this lets us delay that until code generation
514     // when we have the process pointer.
515     static AstNodePtr indexNode_;
516
517     // Since we only ever have one, keep a static copy around. If
518     // we get multiples, we'll screw up our pointer-based common subexpression
519     // elimination.
520
521     if (indexNode_ != AstNodePtr()) return indexNode_;
522     pdvector<AstNodePtr > args;
523     // By not including a process we'll specialize at code generation.
524     indexNode_ = AstNode::funcCallNode("DYNINSTthreadIndex", args);
525     assert(indexNode_);
526     indexNode_->setConstFunc(true);
527
528     return indexNode_;
529 }
530
531
532 #if defined(ASTDEBUG)
533 #define AST_PRINT
534 #endif
535
536 #if defined(AST_PRINT)
537 void AstNode::printRC()
538 {
539     sprintf(errorLine,"RC referenceCount=%d\n",referenceCount);
540     logLine(errorLine);
541     if (loperand) {
542       logLine("RC loperand\n");
543       loperand->printRC();
544     }
545     if (roperand) {
546       logLine("RC roperand\n");
547       roperand->printRC();
548     }
549     if (eoperand) {
550       logLine("RC eoperand\n");
551       eoperand->printRC();
552     }
553 }
554 #endif
555
556 AstNode::~AstNode() {
557     //printf("at ~AstNode()  count=%d\n", referenceCount);
558 }
559
560 Address AstMiniTrampNode::generateTramp(codeGen &gen,
561                                         int &trampCost, 
562                                         bool noCost) {
563     static AstNodePtr costAst;
564     static AstNodePtr preamble;
565
566     if (costAst == AstNodePtr())
567         costAst = AstNode::operandNode(AstNode::Constant, (void *)0);
568
569     if (preamble == AstNodePtr())
570         preamble = AstNode::operatorNode(trampPreamble, costAst);
571
572     // private constructor; assumes NULL for right child
573     
574     // we only want to use the cost of the minimum statements that will
575     // be executed.  Statements, such as the body of an if statement,
576     // will have their costs added to the observed cost global variable
577     // only if they are indeed called.  The code to do this in the minitramp
578     // right after the body of the if.
579     trampCost = preamble->maxCost() + minCost();
580
581     costAst->setOValue((void *) (long) trampCost);
582    
583     if (!preamble->generateCode(gen, noCost)) {
584         fprintf(stderr, "[%s:%d] WARNING: failure to generate miniTramp preamble\n", __FILE__, __LINE__);
585     }
586     
587     if (!ast_->generateCode(gen, noCost)) {
588         fprintf(stderr, "[%s:%d] WARNING: failure to generate miniTramp body\n", __FILE__, __LINE__);
589     }
590
591     return 0;
592 }
593
594 // This name is a bit of a misnomer. It's not the strict use count; it's the
595 // use count modified by whether a node can be kept or not. We can treat
596 // un-keepable nodes (AKA those that don't strictly depend on their AST inputs)
597 // as multiple different nodes that happen to have the same children; keepable
598 // nodes are the "same". If that makes any sense. 
599 //
600 // In any case, we use the following algorithm to set use counts:
601 //
602 //DFS through the AST graph. 
603 //If an AST can be kept:
604 //  Increase its use count;
605 //  Return.
606 //If an AST cannot be kept:
607 //  Recurse to each child;
608 //  Return
609 //
610 // The result is all nodes having counts of 0, 1, or >1. These mean:
611 // 0: node cannot be kept, or is only reached via a keepable node.
612 // 1: Node can be kept, but doesn't matter as it's only used once.
613 // >1: keep result in a register.
614
615 void AstNode::setUseCount() 
616 {
617         if (useCount) {
618                 // If the useCount is 1, then it means this node can
619                 // be shared, and there is a copy. In that case, we assume
620                 // that when this particular incarnation is generated, the
621                 // result will already be calculated and sitting in a register.
622                 // Since that's the case, just up the useCount so we know when
623                 // we can free said register.
624                 useCount++;
625                 return; 
626         }
627         if (canBeKept()) {
628                 useCount++;
629                 // We purposefully fall through... if our use count
630                 // is 1, we'll have to calculate this node instead of
631                 // keeping it around. In that case, see if any of the 
632                 // children are shared (because we can reuse them when
633                 // calculating this guy)
634         }
635         // We can't be kept, but maybe our children can.
636         pdvector<AstNodePtr> children;
637         getChildren(children);
638         for (unsigned i=0; i<children.size(); i++) {
639             children[i]->setUseCount();
640     }
641 }
642
643 void AstNode::cleanUseCount(void)
644 {
645     useCount = 0;
646
647     pdvector<AstNodePtr> children;
648     getChildren(children);
649     for (unsigned i=0; i<children.size(); i++) {
650                 children[i]->cleanUseCount();
651     }
652 }
653
654 // Allocate a register and make it available for sharing if our
655 // node is shared
656 Register AstNode::allocateAndKeep(codeGen &gen, bool noCost)
657 {
658     ast_printf("Allocating register for node %p, useCount %d\n", this, useCount);
659     // Allocate a register
660     Register dest = gen.rs()->allocateRegister(gen, noCost);
661
662     ast_printf("Allocator returned %d\n", dest);
663     assert(dest != REG_NULL);
664
665     if (useCount > 1) {
666         ast_printf("Adding kept register %d for node %p: useCount %d\n", dest, this, useCount);
667         // If use count is 0 or 1, we don't want to keep
668         // it around. If it's > 1, then we can keep the node
669         // (by construction) and want to since there's another
670         // use later.
671         gen.tracker()->addKeptRegister(gen, this, dest);
672     }
673     return dest;
674 }
675
676 //
677 // This procedure generates code for an AST DAG. If there is a sub-graph
678 // being shared between more than 1 node, then the code is generated only
679 // once for this sub-graph and the register where the return value of the
680 // sub-graph is stored, is kept allocated until the last node sharing the
681 // sub-graph has used it (freeing it afterwards). A count called "useCount"
682 // is used to determine whether a particular node or sub-graph is being
683 // shared. At the end of the call to generate code, this count must be 0
684 // for every node. Another important issue to notice is that we have to make
685 // sure that if a node is not calling generate code recursively for either
686 // its left or right operands, we then need to make sure that we update the
687 // "useCount" for these nodes (otherwise we might be keeping registers
688 // allocated without reason). 
689 //
690 // This code was modified in order to set the proper "useCount" for every
691 // node in the DAG before calling the original generateCode procedure (now
692 // generateCode_phase2). This means that we are traversing the DAG twice,
693 // but with the advantage of potencially generating more efficient code.
694 //
695 // Note: a complex Ast DAG might require more registers than the ones 
696 // currently available. In order to fix this problem, we will need to 
697 // implement a "virtual" register allocator - naim 11/06/96
698 //
699 bool AstNode::generateCode(codeGen &gen, 
700                            bool noCost, 
701                            Address &retAddr,
702                            Register &retReg) {
703     static bool entered = false;
704
705
706     bool ret = true;
707
708     bool top_level;
709     if (entered) {
710         top_level = false;
711     }
712     else {
713         entered = true;
714         top_level = true;
715         stats_codegen.startTimer(CODEGEN_AST_TIMER);
716         stats_codegen.incrementCounter(CODEGEN_AST_COUNTER);
717     }
718
719     entered = true;
720
721     cleanUseCount();
722     setUseCount();
723     setVariableAST(gen);
724     ast_printf("====== Code Generation Start ===== \n");
725     ast_cerr << format("");
726     ast_printf("\n\n");
727
728     // We can enter this guy recursively... inst-ia64 goes through
729     // emitV and calls generateCode on the frame pointer AST. Now, it
730     // really shouldn't, but them's the breaks. So we only want
731     // to build a regTracker if there isn't one already...
732     if (top_level) {
733         gen.setRegTracker(new regTracker_t);
734     }
735     
736     // note: this could return the value "(Address)(-1)" -- csserra
737     if (!generateCode_phase2(gen, noCost, retAddr, retReg)) {
738         fprintf(stderr, "WARNING: failed in generateCode internals!\n");
739         ret = false;
740     }
741     
742     if (top_level) {
743       delete gen.tracker();
744       gen.setRegTracker(NULL);
745     }
746
747     if (top_level) {
748         entered = false;
749         stats_codegen.stopTimer(CODEGEN_AST_TIMER);
750     }
751     return ret;
752 }
753
754 bool AstNode::generateCode(codeGen &gen, 
755                            bool noCost) {
756     Address unused = ADDR_NULL;
757     Register unusedReg = REG_NULL;
758     bool ret = generateCode(gen, noCost, unused, unusedReg);
759     gen.rs()->freeRegister(unusedReg);
760
761     return ret;
762 }
763
764 bool AstNode::previousComputationValid(Register &reg,
765                                        codeGen &gen) {
766         Register keptReg = gen.tracker()->hasKeptRegister(this);
767         if (keptReg != REG_NULL) {
768                 reg = keptReg;
769                 ast_printf("Returning previously used register %d for node %p\n", reg, this);
770                 return true;
771         }
772    return false;
773 }
774
775 // We're going to use this fragment over and over and over...
776 #define RETURN_KEPT_REG(r) { if (previousComputationValid(r, gen)) { decUseCount(gen); gen.rs()->incRefCount(r); return true;} }
777 #define ERROR_RETURN { fprintf(stderr, "[%s:%d] ERROR: failure to generate operand\n", __FILE__, __LINE__); return false; }
778 #define REGISTER_CHECK(r) if (r == REG_NULL) { fprintf(stderr, "[%s: %d] ERROR: returned register invalid\n", __FILE__, __LINE__); return false; }
779
780
781 bool AstNode::initRegisters(codeGen &g) {
782     bool ret = true;
783     pdvector<AstNodePtr> kids;
784     getChildren(kids);
785     for (unsigned i = 0; i < kids.size(); i++) {
786         if (!kids[i]->initRegisters(g))
787             ret = false;
788     }
789     return ret;
790 }
791
792
793 bool AstNode::generateCode_phase2(codeGen &, bool,
794                                   Address &,
795                                   Register &) {
796     fprintf(stderr, "ERROR: call to AstNode generateCode_phase2; should be handled by subclass\n");
797     fprintf(stderr, "Undefined phase2 for:\n");
798     if (dynamic_cast<AstNullNode *>(this)) fprintf(stderr, "nullNode\n");
799     if (dynamic_cast<AstStackInsertNode *>(this)) fprintf(stderr, "stackInsertNode\n");
800     if (dynamic_cast<AstStackRemoveNode *>(this)) fprintf(stderr, "stackRemoveNode\n");
801     if (dynamic_cast<AstStackGenericNode *>(this)) fprintf(stderr, "stackMoveNode\n");
802     if (dynamic_cast<AstOperatorNode *>(this)) fprintf(stderr, "operatorNode\n");
803     if (dynamic_cast<AstOperandNode *>(this)) fprintf(stderr, "operandNode\n");
804     if (dynamic_cast<AstCallNode *>(this)) fprintf(stderr, "callNode\n");
805     if (dynamic_cast<AstSequenceNode *>(this)) fprintf(stderr, "seqNode\n");
806     if (dynamic_cast<AstVariableNode *>(this)) fprintf(stderr, "varNode\n");
807     if (dynamic_cast<AstInsnNode *>(this)) fprintf(stderr, "insnNode\n");
808     if (dynamic_cast<AstMiniTrampNode *>(this)) fprintf(stderr, "miniTrampNode\n");
809     if (dynamic_cast<AstMemoryNode *>(this)) fprintf(stderr, "memoryNode\n");
810     assert(0);
811         return 0;
812 }
813
814
815 bool AstNullNode::generateCode_phase2(codeGen &gen, bool,
816                                       Address &retAddr,
817                                       Register &retReg) {
818     retAddr = ADDR_NULL;
819     retReg = REG_NULL;
820
821     decUseCount(gen);
822    
823     return true;
824 }
825
826 bool AstNode::allocateCanaryRegister(codeGen& gen,
827         bool noCost,
828         Register& reg,
829         bool& needSaveAndRestore)
830 {
831     // Let's see if we can find a dead register to use!
832     instPoint* point = gen.point();
833
834     // Try to get a scratch register from the register space
835     registerSpace* regSpace = registerSpace::actualRegSpace(point);
836     bool realReg = true;
837     Register tmpReg = regSpace->getScratchRegister(gen, noCost, realReg);
838     if (tmpReg != REG_NULL) {
839         reg = tmpReg;
840         needSaveAndRestore = false;
841         if (gen.getArch() == Arch_x86) {
842             gen.rs()->noteVirtualInReal(reg, RealRegister(reg));
843         }
844         return true;
845     }
846
847     // Couldn't find a dead register to use :-(
848     registerSpace* deadRegSpace = registerSpace::optimisticRegSpace(gen.addrSpace());
849     reg = deadRegSpace->getScratchRegister(gen, noCost, realReg);
850     if (reg == REG_NULL) {
851         fprintf(stderr, "WARNING: using default allocateAndKeep in allocateCanaryRegister\n");
852         reg = allocateAndKeep(gen, noCost);
853     }
854     needSaveAndRestore = true;
855     fprintf(stderr, "allocateCanaryRegister will require save&restore at 0x%lx\n", gen.point()->addr());
856
857     return true;
858 }
859
860
861 #if defined(cap_stack_mods)
862 bool AstStackInsertNode::generateCode_phase2(codeGen &gen, bool noCost,
863         Address &,
864         Register &)
865 {
866     // Turn off default basetramp instrumentation saves & restores
867     gen.setInsertNaked(true);
868     gen.setModifiedStackFrame(true);
869
870     bool ignored;
871     Register reg_sp = convertRegID(MachRegister::getStackPointer(gen.getArch()), ignored);
872
873     if (type == GENERIC_AST) {
874         /* We're going to use a MOV to insert the new value, and a LEA to update the SP
875          * This is instead of using a push, which requires a free register */
876
877         /* Move stack pointer to accomodate new value */
878         if (gen.getArch() == Arch_x86) {
879             gen.codeEmitter()->emitLEA(reg_sp, Null_Register, 0, -size, reg_sp, gen);
880         } else if (gen.getArch() == Arch_x86_64) {
881             gen.codeEmitter()->emitLEA(reg_sp, Null_Register, 0, -size, reg_sp, gen);
882         }
883
884     } else if (type == CANARY_AST){
885 //        gen.setCanary(true);
886
887         // Find a register to use
888         Register canaryReg = Null_Register;
889         bool needSaveAndRestore = true;
890
891         // 64-bit requires stack alignment
892         // We'll do this BEFORE we push the canary for two reasons:
893         // 1. Easier to pop the canary in the check at the end of the function
894         // 2. Ensures that the canary will get overwritten (rather than empty alignment space) in case of an overflow
895         if (gen.getArch() == Arch_x86_64) {
896             allocateCanaryRegister(gen, noCost, canaryReg, needSaveAndRestore);
897
898             int canarySize = 8;
899             int off = AMD64_STACK_ALIGNMENT - canarySize; // canary
900             gen.codeEmitter()->emitLEA(reg_sp, Null_Register, 0, -off, reg_sp, gen);
901         } else {
902             canaryReg = REGNUM_EAX;
903             needSaveAndRestore = true;
904         }
905
906         // Save canaryReg value if necessary
907         if (needSaveAndRestore) {
908             if (gen.getArch() == Arch_x86) {
909                 int disp = 4;
910                 gen.codeEmitter()->emitLEA(reg_sp, Null_Register, 0, -disp, reg_sp, gen);
911                 gen.codeEmitter()->emitPush(gen, canaryReg);
912                 gen.codeEmitter()->emitLEA(reg_sp, Null_Register, 0, 2*disp, reg_sp, gen);
913             } else if (gen.getArch() == Arch_x86_64) {
914                 int disp = 8;
915                 gen.codeEmitter()->emitLEA(reg_sp, Null_Register, 0, -disp, reg_sp, gen);
916                 gen.codeEmitter()->emitPush(gen, canaryReg);
917                 gen.codeEmitter()->emitLEA(reg_sp, Null_Register, 0, 2*disp, reg_sp, gen);
918             }
919         }
920
921         // Set up canary value
922         // CURRENT USES GLIBC-PROVIDED VALUE;
923         // from gcc/config/i386/gnu-user64.h:
924         //  #ifdef TARGET_LIBC_PROVIDES_SSP
925         //  /* i386 glibc provides __stack_chk_guard in %gs:0x14,
926         //      x32 glibc provides it in %fs:0x18.
927         //      x86_64 glibc provides it in %fs:0x28.  */
928         //  #define TARGET_THREAD_SSP_OFFSET (TARGET_64BIT ? (TARGET_X32 ? 0x18 : 0x28) : 0x14))) */
929
930         // goal:
931         //      x86:    mov %fs:0x14, canaryReg
932         //      x86_64: mov %gs:0x28, canaryReg
933         if (gen.getArch() == Arch_x86) {
934             gen.codeEmitter()->emitLoadRelativeSegReg(canaryReg, 0x14, REGNUM_GS, 4, gen);
935         } else if (gen.getArch() == Arch_x86_64) {
936             gen.codeEmitter()->emitLoadRelativeSegReg(canaryReg, 0x28, REGNUM_FS, 8, gen);
937         }
938
939         // Push the canary value
940         gen.codeEmitter()->emitPush(gen, canaryReg);
941
942         // Clear canary register to prevent info leaking
943         gen.codeEmitter()->emitXorRegReg(canaryReg, canaryReg, gen);
944
945         // Restore canaryReg value if necessary
946         if (needSaveAndRestore) {
947             if (gen.getArch() == Arch_x86) {
948                 int disp = 4;
949                 gen.codeEmitter()->emitLEA(reg_sp, Null_Register, 0, -disp, reg_sp, gen);
950                 gen.codeEmitter()->emitPop(gen, canaryReg);
951             } else if (gen.getArch() == Arch_x86_64) {
952                 int disp = 8;
953                 gen.codeEmitter()->emitLEA(reg_sp, Null_Register, 0, -disp, reg_sp, gen);
954                 gen.codeEmitter()->emitPop(gen, canaryReg);
955             }
956         }
957
958         // C&P from nullNode
959         decUseCount(gen);
960     }
961
962     return true;
963 }
964
965 bool AstStackRemoveNode::generateCode_phase2(codeGen &gen, bool noCost,
966         Address &,
967         Register &)
968 {
969     // Turn off default basetramp instrumentation saves & restores
970     gen.setInsertNaked(true);
971     gen.setModifiedStackFrame(true);
972     
973     bool ignored;
974     Register reg_sp = convertRegID(MachRegister::getStackPointer(gen.getArch()), ignored);
975
976     if (type == GENERIC_AST) {
977         /* Adjust stack pointer by size */
978         int disp = size;
979         if (gen.getArch() == Arch_x86) {
980             gen.codeEmitter()->emitLEA(reg_sp, Null_Register, 0, disp, reg_sp, gen);
981         } else if (gen.getArch() == Arch_x86_64) {
982             gen.codeEmitter()->emitLEA(reg_sp, Null_Register, 0, disp, reg_sp, gen);
983         }
984     } else if (type == CANARY_AST) {
985 //        gen.setCanary(true);
986
987         // Find a register to use
988         Register canaryReg = Null_Register;
989         bool needSaveAndRestore = true;
990         if (gen.getArch() == Arch_x86_64) {
991             allocateCanaryRegister(gen, noCost, canaryReg, needSaveAndRestore);
992         }
993         else {
994             canaryReg = REGNUM_EDX;
995             gen.rs()->noteVirtualInReal(canaryReg, RealRegister(canaryReg));
996             needSaveAndRestore = true;
997         }
998         // Save canaryReg value if necessary
999         if (needSaveAndRestore) {
1000             if (gen.getArch() == Arch_x86) {
1001                 int disp = 4;
1002                 gen.codeEmitter()->emitPush(gen, canaryReg);
1003                 gen.codeEmitter()->emitLEA(reg_sp, Null_Register, 0, disp, reg_sp, gen);
1004             } else if (gen.getArch() == Arch_x86_64) {
1005                 int disp = 8;
1006                 gen.codeEmitter()->emitLEA(reg_sp, Null_Register, 0, disp, reg_sp, gen);
1007             }
1008         }
1009
1010         // Retrieve canary value and verify its integrity
1011         if (!canaryAfterPrologue_) {
1012             gen.codeEmitter()->emitPop(gen, canaryReg);
1013         } else {
1014             Address canaryOffset = -1*(Address)(canaryHeight_);
1015             if (gen.getArch() == Arch_x86) {
1016                 Register destReg = reg_sp;
1017                 RealRegister canaryReg_r = gen.rs()->loadVirtualForWrite(canaryReg, gen);
1018                 emitMovRMToReg(canaryReg_r, RealRegister(destReg), canaryOffset, gen);
1019             } else if (gen.getArch() == Arch_x86_64) {
1020                 Register destReg = reg_sp;
1021                 gen.codeEmitter()->emitLoadRelative(canaryReg, canaryOffset, destReg, 0, gen);
1022             }
1023         }
1024
1025         // CURRENTLY USES GLIBC-PROVIDED VALUE;
1026         //  /* i386 glibc provides __stack_chk_guard in %gs:0x14,
1027         //      x32 glibc provides it in %fs:0x18.
1028         //      x86_64 glibc provides it in %fs:0x28.  */
1029         // goal:
1030         //      x86: xor %fs:0x14, canaryReg
1031         //      x86_64: xor %gs:0x28, canaryReg
1032         if (gen.getArch() == Arch_x86) {
1033             gen.codeEmitter()->emitXorRegSegReg(canaryReg, REGNUM_GS, 0x14, gen);
1034         } else if (gen.getArch() == Arch_x86_64) {
1035             gen.codeEmitter()->emitXorRegSegReg(canaryReg, REGNUM_FS, 0x28, gen);
1036         }
1037
1038         // Restore canaryReg if necessary
1039         if (needSaveAndRestore) {
1040             if (gen.getArch() == Arch_x86) {
1041                 int disp = 4;
1042                 gen.codeEmitter()->emitLEA(reg_sp, Null_Register, 0, -disp, reg_sp, gen);
1043                 gen.codeEmitter()->emitPop(gen, canaryReg);
1044             } else if (gen.getArch() == Arch_x86_64) {
1045                 int disp = 8;
1046                 gen.codeEmitter()->emitLEA(reg_sp, Null_Register, 0, -disp, reg_sp, gen);
1047                 gen.codeEmitter()->emitPop(gen, canaryReg);
1048             }
1049        }
1050
1051         // Fix up the stack in the canaryAfterPrologue case
1052         if (canaryAfterPrologue_) {
1053             if (gen.getArch() == Arch_x86) {
1054                 int disp = 4;
1055                 gen.codeEmitter()->emitLEA(reg_sp, Null_Register, 0, -1*canaryHeight_ + disp, reg_sp, gen);
1056             } else if (gen.getArch() == Arch_x86_64) {
1057                 int disp = 8;
1058                 gen.codeEmitter()->emitLEA(reg_sp, Null_Register, 0, -1*canaryHeight_ + disp, reg_sp, gen);
1059             }
1060         }
1061
1062         // Re-align the stack
1063         if (gen.getArch() == Arch_x86_64) {
1064             // 64-bit requires stack alignment (this will include canary cleanup)
1065             int canarySize = 8;
1066             int off = AMD64_STACK_ALIGNMENT - canarySize;
1067             gen.codeEmitter()->emitLEA(reg_sp, Null_Register, 0, off, reg_sp, gen);
1068         }
1069
1070         // If the canary value is valid, jmp to next expected instruction
1071         int condition = 0x4;
1072         int offset = 1; // This is just the placeholder
1073         bool willRegen = true; // This gets the longer form of the jcc, so we can patch it up
1074         codeBufIndex_t jccIndex = gen.getIndex();
1075         emitJcc(condition, offset, gen, willRegen);
1076
1077         // Otherwise, call specified failure function
1078         // NOTE: Skipping saving live registers that will be clobbered by the call because this will be non-returning
1079         pdvector<AstNodePtr> operands;
1080         func_instance* func = func_; // c&p'd from AstCallNode
1081         codeBufIndex_t preCallIndex = gen.getIndex();
1082         gen.codeEmitter()->emitCallInstruction(gen, func, canaryReg);
1083         codeBufIndex_t postCallIndex = gen.getIndex();
1084
1085         // Fix-up the jcc
1086         offset = postCallIndex - preCallIndex;
1087         gen.setIndex(jccIndex);
1088         emitJcc(condition, offset, gen, willRegen);
1089         gen.setIndex(postCallIndex);
1090
1091         decUseCount(gen);
1092     }
1093
1094     return true;
1095 }
1096
1097 bool AstStackGenericNode::generateCode_phase2(codeGen& gen, bool, Address&, Register&)
1098 {
1099     gen.setInsertNaked(true);
1100     gen.setModifiedStackFrame(true);
1101
1102     // No code generation necessary
1103
1104     return true;
1105 }
1106 #else
1107 bool AstStackInsertNode::generateCode_phase2(codeGen&, bool,
1108         Address &,
1109         Register &) {
1110     return false;
1111 }
1112
1113 bool AstStackRemoveNode::generateCode_phase2(codeGen&, bool,
1114         Address &,
1115         Register &)
1116 {
1117     return false;
1118 }
1119
1120 bool AstStackGenericNode::generateCode_phase2(codeGen&, bool, Address&, Register&)
1121 {
1122     return false;
1123 }
1124 #endif
1125
1126 bool AstLabelNode::generateCode_phase2(codeGen &gen, bool,
1127                                        Address &retAddr,
1128                                        Register &retReg) {
1129         assert(generatedAddr_ == 0);
1130     // Pick up the address we were added at
1131     generatedAddr_ = gen.currAddr();
1132
1133     retAddr = ADDR_NULL;
1134     retReg = REG_NULL;
1135
1136         decUseCount(gen);
1137
1138     return true;
1139 }
1140
1141 bool AstOperatorNode::initRegisters(codeGen &g) {
1142     bool ret = true;
1143     pdvector<AstNodePtr> kids;
1144     getChildren(kids);
1145     for (unsigned i = 0; i < kids.size(); i++) {
1146         if (!kids[i]->initRegisters(g))
1147             ret = false;
1148     }
1149
1150 #if !defined(arch_x86)
1151     // Override: if we're trying to save to an original
1152     // register, make sure it's saved on the stack.
1153     if (op == storeOp) {
1154         if (loperand->getoType() == origRegister) {
1155             Address origReg = (Address) loperand->getOValue();
1156             // Mark that register as live so we are sure to save it.
1157             registerSlot *r = (*(g.rs()))[origReg];
1158             r->liveState = registerSlot::live;
1159         }
1160     }
1161 #endif
1162     return ret;
1163 }
1164
1165
1166 #if defined(arch_x86) || defined(arch_x86_64)
1167 bool AstOperatorNode::generateOptimizedAssignment(codeGen &gen, int size, bool noCost) 
1168 {
1169    //Recognize the common case of 'a = a op constant' and try to 
1170    // generate optimized code for this case.
1171    Address laddr;
1172   
1173    if (loperand->getoType() == DataAddr)
1174    {
1175       laddr = (Address) loperand->getOValue();
1176    }
1177    else
1178    {
1179       if(loperand->getoType() == variableValue)
1180       {
1181          boost::shared_ptr<AstOperandNode> lnode = 
1182             boost::dynamic_pointer_cast<AstOperandNode>(loperand);
1183        
1184          int_variable* var = lnode->lookUpVar(gen.addrSpace());
1185          if (!var || gen.addrSpace()->needsPIC(var))
1186             return false;
1187          laddr = var->getAddress();
1188       }
1189       else
1190       {
1191          //Deal with global writes for now.
1192          return false;
1193       }
1194      
1195    }
1196
1197    if (roperand->getoType() == Constant) {
1198       //Looks like 'global = constant'
1199 #if defined(arch_x86_64)
1200      if (laddr >> 32 || ((Address) roperand->getOValue()) >> 32 || size == 8) {
1201        // Make sure value and address are 32-bit values.
1202        return false;
1203      }
1204      
1205      
1206 #endif
1207       int imm = (int) (long) roperand->getOValue();
1208       emitStoreConst(laddr, (int) imm, gen, noCost);
1209       loperand->decUseCount(gen);
1210       roperand->decUseCount(gen);
1211       return true;
1212    }
1213
1214    AstOperatorNode *roper = dynamic_cast<AstOperatorNode *>(roperand.get());
1215    if (!roper)
1216       return false;
1217    
1218    if (roper->op != plusOp && roper->op != minusOp)
1219       return false;
1220    
1221    AstOperandNode *arithl = dynamic_cast<AstOperandNode *>(roper->loperand.get());
1222    AstOperandNode *arithr = dynamic_cast<AstOperandNode *>(roper->roperand.get());
1223    if (!arithl || !arithr)
1224       return false;
1225    
1226    AstNode *const_oper = NULL;
1227    if (arithl->getoType() == DataAddr && arithr->getoType() == Constant &&
1228        laddr == (Address) arithl->getOValue())
1229    {
1230       const_oper = arithr;
1231    }
1232    else if (arithl->getoType() == variableValue && arithr->getoType() == Constant)
1233    {
1234       Address addr = 0;
1235       int_variable* var = arithl->lookUpVar(gen.addrSpace());
1236       if (!var || gen.addrSpace()->needsPIC(var))
1237          return false;
1238       addr = var->getAddress();
1239       if (addr == laddr) {
1240          const_oper = arithr;
1241       }
1242    }
1243    else if (arithr->getoType() == DataAddr && arithl->getoType() == Constant &&
1244             laddr == (Address) arithr->getOValue() && roper->op == plusOp)
1245    {
1246       const_oper = arithl;
1247    }
1248    else if (arithl->getoType() == variableValue && arithr->getoType() == Constant)
1249    {
1250       Address addr = 0;
1251       int_variable* var = arithl->lookUpVar(gen.addrSpace());
1252       if(!var || gen.addrSpace()->needsPIC(var))
1253          return false;
1254       addr = var->getAddress();
1255       if (addr == laddr) {
1256          const_oper = arithl;
1257       }
1258    }
1259    else
1260    {
1261       return false;
1262    }
1263
1264    long int imm = (long int) const_oper->getOValue();
1265    if (roper->op == plusOp) {
1266       emitAddSignedImm(laddr, imm, gen, noCost);
1267    }
1268    else {
1269       emitSubSignedImm(laddr, imm, gen, noCost);
1270    }
1271    
1272    loperand->decUseCount(gen);
1273    roper->roperand->decUseCount(gen);
1274    roper->loperand->decUseCount(gen);
1275    roper->decUseCount(gen);
1276
1277    return true;
1278 }
1279 #else
1280 bool AstOperatorNode::generateOptimizedAssignment(codeGen &, int, bool) 
1281 {
1282    return false;   
1283 }
1284 #endif
1285
1286 bool AstOperatorNode::generateCode_phase2(codeGen &gen, bool noCost,
1287                                           Address &retAddr,
1288                                           Register &retReg) {
1289
1290    retAddr = ADDR_NULL; // We won't be setting this...
1291    // retReg may have a value or be the (register) equivalent of NULL.
1292    // In either case, we don't touch it...
1293
1294         RETURN_KEPT_REG(retReg);
1295
1296     
1297    Address addr = ADDR_NULL;
1298  
1299    Register src1 = Null_Register;
1300    Register src2 = Null_Register;
1301
1302    Register right_dest = Null_Register;
1303    Register tmp = Null_Register;
1304     
1305    switch(op) {
1306       case branchOp: {
1307          assert(loperand->getoType() == Constant);
1308          unsigned offset = (Register) (long) loperand->getOValue();
1309          // We are not calling loperand->generateCode_phase2,
1310          // so we decrement its useCount by hand.
1311          // Would be nice to allow register branches...
1312          loperand->decUseCount(gen);
1313          (void)emitA(branchOp, 0, 0, (Register)offset, gen, rc_no_control, noCost);
1314          retReg = REG_NULL; // No return register
1315          break;
1316       }
1317       case ifOp: {
1318          // This ast cannot be shared because it doesn't return a register
1319         
1320          if (!loperand->generateCode_phase2(gen, noCost, addr, src1)) ERROR_RETURN;
1321          REGISTER_CHECK(src1);
1322          codeBufIndex_t ifIndex= gen.getIndex();
1323
1324          size_t preif_patches_size = gen.allPatches().size();
1325          codeBufIndex_t thenSkipStart = emitA(op, src1, 0, 0, gen, rc_before_jump, noCost);
1326
1327          size_t postif_patches_size = gen.allPatches().size();
1328
1329          // We can reuse src1 for the body of the conditional; however, keep the value here
1330          // so that we can use it for the branch fix below. 
1331          Register src1_copy = src1;
1332          if (loperand->decRefCount())
1333             gen.rs()->freeRegister(src1);
1334         
1335          // The flow of control forks. We need to add the forked node to 
1336          // the path
1337          gen.tracker()->increaseConditionalLevel();
1338          if (!roperand->generateCode_phase2(gen, noCost, addr, src2)) ERROR_RETURN;
1339          if (roperand->decRefCount())
1340             gen.rs()->freeRegister(src2);
1341          gen.tracker()->decreaseAndClean(gen);
1342          gen.rs()->unifyTopRegStates(gen); //Join the registerState for the if
1343         
1344          // Is there an else clause?  If yes, generate branch over it
1345          codeBufIndex_t elseSkipStart = 0;
1346          codeBufIndex_t elseSkipIndex = gen.getIndex();
1347          size_t preelse_patches_size = 0, postelse_patches_size = 0;
1348          if (eoperand) {
1349             gen.rs()->pushNewRegState(); //Create registerState for else
1350             preelse_patches_size = gen.allPatches().size();
1351             elseSkipStart = emitA(branchOp, 0, 0, 0,
1352                                   gen, rc_no_control, noCost);
1353             postelse_patches_size = gen.allPatches().size();
1354          }
1355
1356          // Now that we've generated the "then" section, rewrite the if
1357          // conditional branch.
1358          codeBufIndex_t elseStartIndex = gen.getIndex();
1359
1360          if (preif_patches_size != postif_patches_size) {
1361             assert(postif_patches_size > preif_patches_size);
1362             ifTargetPatch if_targ(elseStartIndex + gen.startAddr());
1363             for (unsigned i=preif_patches_size; i < postif_patches_size; i++) {
1364                gen.allPatches()[i].setTarget(&if_targ);
1365             }
1366             for (unsigned i=preif_patches_size; i < postif_patches_size; i++) {
1367                gen.allPatches()[i].applyPatch();
1368             }
1369          }
1370          else {
1371             gen.setIndex(ifIndex);
1372             // call emit again now with correct offset.
1373             // This backtracks over current code.
1374             // If/when we vectorize, we can do this in a two-pass arrangement
1375             (void) emitA(op, src1_copy, 0, 
1376                          (Register) codeGen::getDisplacement(thenSkipStart, elseStartIndex),
1377                          gen, rc_no_control, noCost);
1378             // Now we can free the register
1379             // Register has already been freed; we're just re-using it.
1380             //gen.rs()->freeRegister(src1);
1381         
1382             gen.setIndex(elseStartIndex);
1383          }
1384
1385          if (eoperand) {
1386             // If there's an else clause, we need to generate code for it.
1387             gen.tracker()->increaseConditionalLevel();
1388             if (!eoperand->generateCode_phase2(gen,
1389                                                noCost, 
1390                                                addr,
1391                                                src2)) ERROR_RETURN;
1392             if (eoperand->decRefCount())
1393                gen.rs()->freeRegister(src2);
1394             gen.tracker()->decreaseAndClean(gen);
1395             gen.rs()->unifyTopRegStates(gen); //Join the registerState for the else
1396             
1397             // We also need to fix up the branch at the end of the "true"
1398             // clause to jump around the "else" clause.
1399             codeBufIndex_t endIndex = gen.getIndex();
1400             if (preelse_patches_size != postelse_patches_size) {
1401                assert(postif_patches_size > preif_patches_size);
1402                ifTargetPatch else_targ(endIndex + gen.startAddr());
1403                for (unsigned i=preelse_patches_size; i < postelse_patches_size; i++) {
1404                   gen.allPatches()[i].setTarget(&else_targ);
1405                }
1406                for (unsigned i=preelse_patches_size; i < postelse_patches_size; i++) {
1407                   gen.allPatches()[i].applyPatch();
1408                }
1409             }
1410             else {        
1411                gen.setIndex(elseSkipIndex);
1412                emitA(branchOp, 0, 0, 
1413                      (Register) codeGen::getDisplacement(elseSkipStart, endIndex),
1414                      gen, rc_no_control, noCost);
1415                gen.setIndex(endIndex);
1416             }
1417          }
1418          retReg = REG_NULL; 
1419          break;
1420       }
1421       case ifMCOp: {
1422          assert(gen.point());
1423         
1424          // TODO: Right now we get the condition from the memory access info,
1425          // because scanning for memory accesses is the only way to detect these
1426          // conditional instructions. The right way(TM) would be to attach that
1427          // info directly to the point...
1428          // Okay. The info we need is stored in the BPatch_point. We have the instPoint. 
1429          // Yay.
1430         
1431          BPatch_addressSpace *bproc = (BPatch_addressSpace *) gen.addrSpace()->up_ptr();
1432          BPatch_point *bpoint = bproc->findOrCreateBPPoint(NULL, gen.point(), BPatch_point::convertInstPointType_t(gen.point()->type()));
1433         
1434          const BPatch_memoryAccess* ma = bpoint->getMemoryAccess();
1435          assert(ma);
1436          int cond = ma->conditionCode_NP();
1437          if(cond > -1) {
1438             codeBufIndex_t startIndex = gen.getIndex();
1439             emitJmpMC(cond, 0 /* target, changed later */, gen);
1440             codeBufIndex_t fromIndex = gen.getIndex();
1441             // Add the snippet to the tracker, as AM has indicated...
1442             gen.tracker()->increaseConditionalLevel();
1443             // generate code with the right path
1444             if (!loperand->generateCode_phase2(gen,
1445                                                noCost,
1446                                                addr,
1447                                                src1)) ERROR_RETURN;
1448             if (loperand->decRefCount())
1449                gen.rs()->freeRegister(src1);
1450             gen.tracker()->decreaseAndClean(gen);
1451             codeBufIndex_t endIndex = gen.getIndex();
1452             // call emit again now with correct offset.
1453             gen.setIndex(startIndex);
1454             emitJmpMC(cond, codeGen::getDisplacement(fromIndex, endIndex), gen);
1455             gen.setIndex(endIndex);
1456          }
1457          else {
1458             if (!loperand->generateCode_phase2(gen,
1459                                                noCost,
1460                                                addr, 
1461                                                src1)) ERROR_RETURN;
1462             if (loperand->decRefCount())
1463                gen.rs()->freeRegister(src1);
1464          }
1465
1466          break;
1467       }
1468       case whileOp: {
1469          codeBufIndex_t top = gen.getIndex();
1470
1471          if (!loperand->generateCode_phase2(gen, noCost, addr, src1)) ERROR_RETURN;
1472          REGISTER_CHECK(src1);
1473
1474          codeBufIndex_t startIndex = gen.getIndex();
1475
1476          size_t preif_patches_size = gen.allPatches().size();
1477          codeBufIndex_t fromIndex = emitA(ifOp, src1, 0, 0, gen, rc_before_jump, noCost);
1478          size_t postif_patches_size = gen.allPatches().size();
1479
1480          // See comment in ifOp
1481          Register src1_copy = src1;
1482
1483          if (loperand->decRefCount())
1484             gen.rs()->freeRegister(src1);
1485
1486          if (roperand) {
1487            // The flow of control forks. We need to add the forked node to 
1488            // the path
1489            gen.tracker()->increaseConditionalLevel();
1490            if (!roperand->generateCode_phase2(gen, noCost, addr, src2)) ERROR_RETURN;
1491            if (roperand->decRefCount())
1492              gen.rs()->freeRegister(src2);
1493          }
1494         
1495          gen.tracker()->decreaseAndClean(gen);
1496          gen.rs()->unifyTopRegStates(gen); //Join the registerState for the if
1497
1498          //jump back
1499          (void) emitA(branchOp, 0, 0, codeGen::getDisplacement(gen.getIndex(), top),
1500                       gen, rc_no_control, noCost);
1501
1502          if (preif_patches_size != postif_patches_size) {                                     
1503             assert(postif_patches_size > preif_patches_size);                                 
1504             ifTargetPatch if_targ(gen.getIndex() + gen.startAddr());                          
1505             for (unsigned i=preif_patches_size; i < postif_patches_size; i++) {               
1506                gen.allPatches()[i].setTarget(&if_targ);                                       
1507             }                                                                                 
1508             for (unsigned i=preif_patches_size; i < postif_patches_size; i++) {               
1509                gen.allPatches()[i].applyPatch();                                              
1510             }                                                                                 
1511          }                                                                                    
1512          else {                                                                               
1513             gen.setIndex(startIndex);                                  
1514             codeBufIndex_t endIndex = gen.getIndex();
1515             // call emit again now with correct offset.                                       
1516             // This backtracks over current code.                                             
1517             // If/when we vectorize, we can do this in a two-pass arrangement                 
1518             (void) emitA(op, src1_copy, 0,                                                    
1519                          (Register) codeGen::getDisplacement(fromIndex, endIndex),  
1520                          gen, rc_no_control, noCost);                                         
1521             // Now we can free the register                                                   
1522             // Register has already been freed; we're just re-using it.                       
1523             //gen.rs()->freeRegister(src1);                                                   
1524                                                                                               
1525             gen.setIndex(endIndex);
1526          }                                                                               
1527          break;
1528       }
1529       case doOp: {
1530          fprintf(stderr, "[%s:%d] WARNING: do AST node unimplemented!\n", __FILE__, __LINE__);
1531          return false;
1532       }
1533       case getAddrOp: {
1534          switch(loperand->getoType()) {
1535             case variableAddr:
1536                if (retReg == REG_NULL) {
1537                   retReg = allocateAndKeep(gen, noCost);
1538                }
1539                assert (loperand->getOVar());
1540                loperand->emitVariableLoad(loadConstOp, retReg, retReg, gen, noCost, gen.rs(), size,
1541                                           gen.point(), gen.addrSpace());
1542                break;
1543             case variableValue:
1544                if (retReg == REG_NULL) {
1545                   retReg = allocateAndKeep(gen, noCost);
1546                }
1547                assert (loperand->getOVar());
1548                loperand->emitVariableLoad(loadOp, retReg, retReg, gen, noCost, gen.rs(), size,
1549                                           gen.point(), gen.addrSpace());
1550                break;
1551             case DataAddr:
1552                {
1553                   addr = reinterpret_cast<Address>(loperand->getOValue());
1554                   if (retReg == REG_NULL) {
1555                      retReg = allocateAndKeep(gen, noCost);
1556                   }
1557                   assert(!loperand->getOVar());
1558                   emitVload(loadConstOp, addr, retReg, retReg, gen,
1559                             noCost, gen.rs(), size, gen.point(), gen.addrSpace());
1560                }
1561                break;
1562             case FrameAddr: {
1563                // load the address fp + addr into dest
1564                if (retReg == REG_NULL)
1565                   retReg = allocateAndKeep(gen, noCost);
1566                Register temp = gen.rs()->getScratchRegister(gen, noCost);
1567                addr = (Address) loperand->getOValue();
1568                emitVload(loadFrameAddr, addr, temp, retReg, gen,
1569                          noCost, gen.rs(), size, gen.point(), gen.addrSpace());
1570                break;
1571             }
1572             case RegOffset: {
1573                assert(loperand);
1574                assert(loperand->operand());
1575             
1576                // load the address reg + addr into dest
1577                if (retReg == REG_NULL) {
1578                   retReg = allocateAndKeep(gen, noCost);
1579                }
1580                addr = (Address) loperand->operand()->getOValue();
1581             
1582                emitVload(loadRegRelativeAddr, addr, (long)loperand->getOValue(), retReg, gen,
1583                          noCost, gen.rs(), size, gen.point(), gen.addrSpace());
1584                break;
1585             }
1586             case DataIndir:
1587                // taking address of pointer de-ref returns the original
1588                //    expression, so we simple generate the left child's 
1589                //    code to get the address 
1590                if (!loperand->operand()->generateCode_phase2(gen,
1591                                                              noCost, 
1592                                                              addr,
1593                                                              retReg)) ERROR_RETURN;
1594                // Broken refCounts?
1595                break;
1596             case origRegister:
1597                // Added 2NOV11 Bernat - some variables live in original registers,
1598                // and so we need to be able to dereference their contents. 
1599                if (!loperand->generateCode_phase2(gen, noCost, addr, retReg)) ERROR_RETURN;
1600                break;
1601             default:
1602                cerr << "Uh oh, unknown loperand type in getAddrOp: " << loperand->getoType() << endl;
1603                cerr << "\t Generating ast " << hex << this << dec << endl;
1604                assert(0);
1605          }
1606          break;
1607       }
1608       case storeOp: {
1609         bool result = generateOptimizedAssignment(gen, size, noCost);
1610          if (result)
1611             break;
1612        
1613          // This ast cannot be shared because it doesn't return a register
1614          if (!roperand->generateCode_phase2(gen,
1615                                             noCost,
1616                                             addr,
1617                                             src1))  { 
1618             fprintf(stderr, "ERROR: failure generating roperand\n"); 
1619             ERROR_RETURN; 
1620          }
1621          REGISTER_CHECK(src1);
1622          // We will access loperand's children directly. They do not expect
1623          // it, so we need to bump up their useCounts
1624          loperand->fixChildrenCounts();
1625
1626          src2 = gen.rs()->allocateRegister(gen, noCost);
1627          switch (loperand->getoType()) {
1628             case variableValue:
1629                loperand->emitVariableStore(storeOp, src1, src2, gen,
1630                                            noCost, gen.rs(), size, gen.point(), gen.addrSpace());
1631                loperand->decUseCount(gen);
1632                break;
1633             case DataAddr:
1634                addr = (Address) loperand->getOValue();
1635                assert(loperand->getOVar() == NULL);
1636                emitVstore(storeOp, src1, src2, addr, gen,
1637                           noCost, gen.rs(), size, gen.point(), gen.addrSpace());
1638                // We are not calling generateCode for the left branch,
1639                // so need to decrement the refcount by hand
1640                loperand->decUseCount(gen);
1641                break;
1642             case FrameAddr:
1643                addr = (Address) loperand->getOValue();
1644                emitVstore(storeFrameRelativeOp, src1, src2, addr, gen, 
1645                           noCost, gen.rs(), size, gen.point(), gen.addrSpace());
1646                loperand->decUseCount(gen);
1647                break;
1648             case RegOffset: {
1649                assert(loperand->operand());
1650                addr = (Address) loperand->operand()->getOValue();
1651             
1652                // This is cheating, but I need to pass 4 data values into emitVstore, and
1653                // it only allows for 3.  Prepare the dest address in scratch register src2.
1654             
1655                emitVload(loadRegRelativeAddr, addr, (long)loperand->getOValue(), src2,
1656                          gen, noCost, gen.rs(), size, gen.point(), gen.addrSpace());
1657             
1658                // Same as DataIndir at this point.
1659                emitV(storeIndirOp, src1, 0, src2, gen, noCost, gen.rs(), size, gen.point(), gen.addrSpace());
1660                loperand->decUseCount(gen);
1661                break;
1662             }
1663             case DataIndir: {
1664                // store to a an expression (e.g. an array or field use)
1665                // *(+ base offset) = src1
1666                if (!loperand->operand()->generateCode_phase2(gen,
1667                                                              noCost,
1668                                                              addr,
1669                                                              tmp)) ERROR_RETURN;
1670                REGISTER_CHECK(tmp);
1671
1672                // tmp now contains address to store into
1673                emitV(storeIndirOp, src1, 0, tmp, gen, noCost, gen.rs(), size, gen.point(), gen.addrSpace());
1674                if (loperand->operand()->decRefCount())
1675                   gen.rs()->freeRegister(tmp);
1676                loperand->decUseCount(gen);
1677                break;
1678             }
1679             case origRegister:
1680                gen.rs()->writeProgramRegister(gen, (Register)(long)loperand->getOValue(),
1681                                               src1, getSize());
1682                //emitStorePreviousStackFrameRegister((Address) loperand->getOValue(),
1683                //src1, gen, getSize(), noCost);
1684                loperand->decUseCount(gen);
1685                break;
1686             case Param: 
1687             case ParamAtCall: 
1688             case ParamAtEntry: {
1689                boost::shared_ptr<AstOperandNode> lnode = 
1690                   boost::dynamic_pointer_cast<AstOperandNode>(loperand);
1691                emitR(getParamOp, (Address)lnode->oValue,
1692                      src1, src2, gen, noCost, gen.point(),
1693                      gen.addrSpace()->multithread_capable());
1694                loperand->decUseCount(gen);
1695                break;
1696             }
1697             case ReturnVal:
1698                emitR(getRetValOp, Null_Register,
1699                      src1, src2, gen, noCost, gen.point(),
1700                      gen.addrSpace()->multithread_capable());
1701                loperand->decUseCount(gen);
1702                break;
1703             case ReturnAddr:
1704                 emitR(getRetAddrOp, Null_Register,
1705                       src1, src2, gen, noCost, gen.point(), 
1706                       gen.addrSpace()->multithread_capable());
1707             default: {
1708                // Could be an error, could be an attempt to load based on an arithmetic expression
1709                // Generate the left hand side, store the right to that address
1710                if (!loperand->generateCode_phase2(gen, noCost, addr, tmp)) ERROR_RETURN;
1711                REGISTER_CHECK(tmp);
1712
1713                emitV(storeIndirOp, src1, 0, tmp, gen, noCost, gen.rs(), size, gen.point(), gen.addrSpace());
1714                if (loperand->decRefCount())
1715                   gen.rs()->freeRegister(tmp);
1716                break;
1717             }
1718          }
1719          if (roperand->decRefCount())
1720             gen.rs()->freeRegister(src1);
1721          gen.rs()->freeRegister(src2);
1722          retReg = REG_NULL;
1723          break;
1724       }
1725       case storeIndirOp: {
1726         
1727          if (!roperand->generateCode_phase2(gen, noCost, addr, src1)) ERROR_RETURN;
1728          if (!loperand->generateCode_phase2(gen, noCost, addr, src2)) ERROR_RETURN;
1729          REGISTER_CHECK(src1);
1730          REGISTER_CHECK(src2);
1731          emitV(op, src1, 0, src2, gen, noCost, gen.rs(), size, gen.point(), gen.addrSpace());
1732          if (roperand->decRefCount())
1733             gen.rs()->freeRegister(src1);
1734          if (loperand->decRefCount())
1735             gen.rs()->freeRegister(src2);
1736          retReg = REG_NULL;
1737          break;
1738       }
1739       case trampPreamble: {
1740          // This ast cannot be shared because it doesn't return a register
1741          retReg = REG_NULL;
1742          break;
1743       }
1744       case plusOp:
1745       case minusOp:
1746       case timesOp:
1747       case divOp:
1748       case orOp:
1749       case andOp:
1750       case eqOp:
1751       case neOp:
1752       case lessOp:
1753       case leOp:
1754       case greaterOp:
1755       case geOp:
1756       default: 
1757       {
1758          src1 = Null_Register;
1759          right_dest = Null_Register;
1760          if (loperand) {
1761             if (!loperand->generateCode_phase2(gen,
1762                                                noCost, addr, src1)) ERROR_RETURN;
1763             REGISTER_CHECK(src1);
1764          }
1765          
1766          if (roperand &&
1767              (roperand->getoType() == Constant) &&
1768              doNotOverflow((Register) (long) roperand->getOValue())) {
1769             if (retReg == REG_NULL) {
1770                retReg = allocateAndKeep(gen, noCost);
1771                ast_printf("Operator node, const RHS, allocated register %d\n", retReg);
1772             }
1773             else
1774                ast_printf("Operator node, const RHS, keeping register %d\n", retReg);
1775                                 
1776             emitImm(op, src1, (Register) (long) roperand->getOValue(), retReg, gen, noCost, gen.rs());
1777
1778             if (src1 != Null_Register && loperand->decRefCount())
1779                gen.rs()->freeRegister(src1); 
1780
1781             // We do not .generateCode for roperand, so need to update its
1782             // refcounts manually
1783             roperand->decUseCount(gen);
1784          }
1785          else {
1786             if (roperand) {
1787                if (!roperand->generateCode_phase2(gen, noCost, addr, right_dest)) ERROR_RETURN;
1788                REGISTER_CHECK(right_dest);
1789             }
1790             if (retReg == REG_NULL) {
1791                retReg = allocateAndKeep(gen, noCost);
1792             }
1793             emitV(op, src1, right_dest, retReg, gen, noCost, gen.rs(), size, gen.point(), gen.addrSpace());
1794             if (src1 != Null_Register && loperand->decRefCount()) {
1795                // Don't free inputs until afterwards; we have _no_ idea
1796                gen.rs()->freeRegister(src1); 
1797             }
1798             // what the underlying code might do with a temporary register.
1799             if (right_dest != Null_Register && roperand->decRefCount())
1800                gen.rs()->freeRegister(right_dest); 
1801          }
1802       }
1803    }
1804         decUseCount(gen);
1805    return true;
1806 }
1807
1808 bool AstOperandNode::generateCode_phase2(codeGen &gen, bool noCost,
1809                                          Address &,
1810                                          Register &retReg) {
1811         RETURN_KEPT_REG(retReg);
1812     
1813
1814     Address addr = ADDR_NULL;
1815     Register src = Null_Register;
1816
1817 #if defined(ASTDEBUG)
1818    sprintf(errorLine,"### location: %p ###\n", gen.point());
1819    logLine(errorLine);
1820 #endif
1821    // Allocate a register to return
1822    if (oType != DataReg) {
1823        if (retReg == REG_NULL) {
1824            retReg = allocateAndKeep(gen, noCost);
1825        }
1826    }
1827    Register temp;
1828    int tSize;
1829    int len;
1830    BPatch_type *Type;
1831    switch (oType) {
1832    case Constant:
1833      assert(oVar == NULL);
1834      emitVload(loadConstOp, (Address)oValue, retReg, retReg, gen,
1835                  noCost, gen.rs(), size, gen.point(), gen.addrSpace());
1836      break;
1837    case DataIndir:
1838       if (!operand_->generateCode_phase2(gen, noCost, addr, src)) ERROR_RETURN;
1839       REGISTER_CHECK(src);
1840       Type = const_cast<BPatch_type *> (getType());
1841       // Internally generated calls will not have type information set
1842       if(Type)
1843          tSize = Type->getSize();
1844       else
1845          tSize = sizeof(long);
1846       emitV(loadIndirOp, src, 0, retReg, gen, noCost, gen.rs(), tSize, gen.point(), gen.addrSpace()); 
1847       if (operand_->decRefCount())
1848          gen.rs()->freeRegister(src);
1849       break;
1850    case DataReg:
1851        retReg = (Register) (long) oValue;
1852        break;
1853    case origRegister:
1854       gen.rs()->readProgramRegister(gen, (Register)(long)oValue, retReg, size);
1855        //emitLoadPreviousStackFrameRegister((Address) oValue, retReg, gen,
1856        //size, noCost);
1857        break;
1858    case variableAddr:
1859      assert(oVar);
1860      emitVariableLoad(loadConstOp, retReg, retReg, gen,
1861                  noCost, gen.rs(), size, gen.point(), gen.addrSpace());
1862      break;
1863    case variableValue:
1864      assert(oVar);
1865      emitVariableLoad(loadOp, retReg, retReg, gen,
1866         noCost, gen.rs(), size, gen.point(), gen.addrSpace());
1867      break;
1868    case ReturnVal:
1869        src = emitR(getRetValOp, 0, Null_Register, retReg, gen, noCost, gen.point(),
1870                    gen.addrSpace()->multithread_capable());
1871        REGISTER_CHECK(src);
1872        if (src != retReg) {
1873            // Move src to retReg. Can't simply return src, since it was not
1874            // allocated properly
1875            emitImm(orOp, src, 0, retReg, gen, noCost, gen.rs());
1876        }
1877        break;
1878    case ReturnAddr:
1879        src = emitR(getRetAddrOp, 0, Null_Register, retReg, gen, noCost, gen.point(),
1880                    gen.addrSpace()->multithread_capable());
1881        REGISTER_CHECK(src);
1882        if (src != retReg) {
1883            // Move src to retReg. Can't simply return src, since it was not
1884            // allocated properly
1885            emitImm(orOp, src, 0, retReg, gen, noCost, gen.rs());
1886        }
1887        break;
1888    case Param:
1889    case ParamAtCall: 
1890    case ParamAtEntry: {
1891        opCode paramOp = undefOp;
1892        switch(oType) {
1893            case Param: 
1894                paramOp = getParamOp;
1895                break;
1896            case ParamAtCall: 
1897                paramOp = getParamAtCallOp;
1898                break;
1899            case ParamAtEntry: 
1900                paramOp = getParamAtEntryOp;
1901                break;
1902            default:
1903                assert(0);
1904                break;
1905        }
1906        src = emitR(paramOp, (Address)oValue, Null_Register,
1907                    retReg, gen, noCost, gen.point(),
1908                    gen.addrSpace()->multithread_capable());
1909        REGISTER_CHECK(src);
1910        if (src != retReg) {
1911            // Move src to retReg. Can't simply return src, since it was not
1912            // allocated properly
1913            emitImm(orOp, src, 0, retReg, gen, noCost, gen.rs());
1914        }
1915        }
1916        break;
1917    case DataAddr:
1918      {
1919        assert(oVar == NULL);
1920        Address addr = reinterpret_cast<Address>(oValue);
1921        emitVload(loadOp, addr, retReg, retReg, gen, noCost, NULL, size, gen.point(), gen.addrSpace());
1922      }
1923      
1924        break;
1925    case FrameAddr:
1926        addr = (Address) oValue;
1927        temp = gen.rs()->allocateRegister(gen, noCost);
1928        emitVload(loadFrameRelativeOp, addr, temp, retReg, gen, noCost, gen.rs(), size, gen.point(), gen.addrSpace());
1929        gen.rs()->freeRegister(temp);
1930        break;
1931    case RegOffset:
1932        // Prepare offset from value in any general register (not just fp).
1933        // This AstNode holds the register number, and loperand holds offset.
1934        assert(operand_);
1935        addr = (Address) operand_->getOValue();
1936        emitVload(loadRegRelativeOp, addr, (long)oValue, retReg, gen, noCost, gen.rs(), size, gen.point(), gen.addrSpace());
1937        break;
1938    case ConstantString:
1939        // XXX This is for the std::string type.  If/when we fix the std::string type
1940        // to make it less of a hack, we'll need to change this.
1941        len = strlen((char *)oValue) + 1;
1942        
1943        addr = (Address) gen.addrSpace()->inferiorMalloc(len, dataHeap); //dataheap
1944        
1945        if (!gen.addrSpace()->writeDataSpace((char *)addr, len, (char *)oValue)) {
1946            ast_printf("Failed to write string constant into mutatee\n");
1947            return false;
1948        }
1949
1950        if(!gen.addrSpace()->needsPIC())
1951        {
1952           emitVload(loadConstOp, addr, retReg, retReg, gen, noCost, gen.rs(), size, gen.point(), gen.addrSpace());
1953        }
1954        else
1955        {
1956           gen.codeEmitter()->emitLoadShared(loadConstOp, retReg, NULL, true, size, gen, addr);
1957        }
1958        break;
1959    default:
1960        fprintf(stderr, "[%s:%d] ERROR: Unknown operand type %d in AstOperandNode generation\n",
1961                __FILE__, __LINE__, oType);
1962        return false;
1963        break;
1964    }
1965         decUseCount(gen);
1966    return true;
1967 }
1968
1969 bool AstMemoryNode::generateCode_phase2(codeGen &gen, bool noCost,
1970                                         Address &,
1971                                         Register &retReg) {
1972   
1973         RETURN_KEPT_REG(retReg);
1974         
1975     const BPatch_memoryAccess* ma;
1976     const BPatch_addrSpec_NP *start;
1977     const BPatch_countSpec_NP *count;
1978     if (retReg == REG_NULL)
1979         retReg = allocateAndKeep(gen, noCost);    
1980     switch(mem_) {
1981     case EffectiveAddr: {
1982       
1983         // VG(11/05/01): get effective address
1984         // VG(07/31/02): take care which one
1985         // 1. get the point being instrumented & memory access info
1986         assert(gen.point());
1987         
1988         BPatch_addressSpace *bproc = (BPatch_addressSpace *)gen.addrSpace()->up_ptr();
1989         BPatch_point *bpoint = bproc->findOrCreateBPPoint(NULL, gen.point(), BPatch_point::convertInstPointType_t(gen.point()->type()));
1990         if (bpoint == NULL) {
1991             fprintf(stderr, "ERROR: Unable to find BPatch point for internal point %p/0x%lx\n",
1992                     gen.point(), gen.point()->insnAddr());
1993         }
1994         assert(bpoint);
1995         ma = bpoint->getMemoryAccess();
1996         if(!ma) {
1997             bpfatal( "Memory access information not available at this point.\n");
1998             bpfatal( "Make sure you create the point in a way that generates it.\n");
1999             bpfatal( "E.g.: findPoint(const std::set<BPatch_opCode>& ops).\n");
2000             assert(0);
2001         }
2002         if(which_ >= ma->getNumberOfAccesses()) {
2003             bpfatal( "Attempt to instrument non-existent memory access number.\n");
2004             bpfatal( "Consider using filterPoints()...\n");
2005             assert(0);
2006         }
2007         start = ma->getStartAddr(which_);
2008         emitASload(start, retReg, 0, gen, noCost);
2009         break;
2010     }
2011     case BytesAccessed: {
2012         // 1. get the point being instrumented & memory access info
2013         assert(gen.point());
2014         
2015         BPatch_addressSpace *bproc = (BPatch_addressSpace *)gen.addrSpace()->up_ptr();
2016         BPatch_point *bpoint = bproc->findOrCreateBPPoint(NULL, gen.point(), BPatch_point::convertInstPointType_t(gen.point()->type()));
2017         ma = bpoint->getMemoryAccess();
2018         if(!ma) {
2019             bpfatal( "Memory access information not available at this point.\n");
2020             bpfatal("Make sure you create the point in a way that generates it.\n");
2021             bpfatal( "E.g.: findPoint(const std::set<BPatch_opCode>& ops).\n");
2022             assert(0);
2023         }
2024         if(which_ >= ma->getNumberOfAccesses()) {
2025             bpfatal( "Attempt to instrument non-existent memory access number.\n");
2026             bpfatal( "Consider using filterPoints()...\n");
2027             assert(0);
2028         }
2029         count = ma->getByteCount(which_);
2030         emitCSload(count, retReg, gen, noCost);
2031         break;
2032     }
2033     default:
2034         assert(0);
2035     }
2036         decUseCount(gen);
2037     return true;
2038 }
2039
2040 bool AstCallNode::initRegisters(codeGen &gen) {
2041     // For now, we only care if we should save everything. "Everything", of course, 
2042     // is platform dependent. This is the new location of the clobberAllFuncCalls
2043     // that had previously been in emitCall.
2044
2045     bool ret = true;
2046
2047     // First, check kids
2048     pdvector<AstNodePtr > kids;
2049     getChildren(kids);
2050     for (unsigned i = 0; i < kids.size(); i++) {
2051         if (!kids[i]->initRegisters(gen))
2052             ret = false;
2053     }
2054
2055     // Platform-specific...
2056 #if defined(arch_x86) || defined(arch_x86_64)
2057     // Our "everything" is "floating point registers".
2058     // We also need a function object.
2059     func_instance *callee = func_;
2060     if (!callee) {
2061         // Painful lookup time
2062         callee = gen.addrSpace()->findOnlyOneFunction(func_name_.c_str());
2063     }
2064     assert(callee);
2065
2066     // Marks registers as used based on the callee's behavior
2067     // This means we'll save them if necessary (also, lets us use
2068     // them in our generated code because we've saved, instead
2069     // of saving others).
2070     assert(gen.codeEmitter());
2071     gen.codeEmitter()->clobberAllFuncCall(gen.rs(), callee);
2072
2073
2074 #endif
2075 #if defined(arch_power)
2076     if (callReplace_) return true;
2077
2078     // This code really doesn't work right now...
2079     func_instance *callee = func_;
2080     if (!callee) {
2081         // Painful lookup time
2082         callee = gen.addrSpace()->findOnlyOneFunction(func_name_.c_str());
2083         assert(callee);
2084     }
2085     gen.codeEmitter()->clobberAllFuncCall(gen.rs(), callee);
2086     // We clobber in clobberAllFuncCall...
2087
2088     // Monotonically increasing...
2089 #endif
2090     return ret;
2091     
2092 }
2093
2094 bool AstCallNode::generateCode_phase2(codeGen &gen, bool noCost,
2095                                       Address &, 
2096                                       Register &retReg) {
2097         // We call this anyway... not that we'll ever be kept.
2098         // Well... if we can somehow know a function is entirely
2099         // dependent on arguments (a flag?) we can keep it around.
2100         RETURN_KEPT_REG(retReg);
2101
2102     // VG(11/06/01): This platform independent fn calls a platfrom
2103     // dependent fn which calls it back for each operand... Have to
2104     // fix those as well to pass location...
2105
2106     func_instance *use_func = func_;
2107
2108     if (!use_func && !func_addr_) {
2109         // We purposefully don't cache the func_instance object; the AST nodes
2110         // are process independent, and functions kinda are.
2111         use_func = gen.addrSpace()->findOnlyOneFunction(func_name_.c_str());
2112         if (!use_func) {
2113             fprintf(stderr, "ERROR: failed to find function %s, unable to create call\n",
2114                     func_name_.c_str());
2115         }
2116         assert(use_func); // Otherwise we've got trouble...
2117     }
2118
2119     Register tmp = 0;
2120
2121     if (use_func && !callReplace_) {
2122         tmp = emitFuncCall(callOp, gen, args_,  
2123                            noCost, use_func);
2124     }
2125     else if (use_func && callReplace_) {
2126         tmp = emitFuncCall(funcJumpOp, gen, args_,
2127                            noCost, use_func);
2128     }
2129     else if (func_addr_) {
2130         tmp = emitFuncCall(callOp, gen, args_,  
2131                            noCost, func_addr_);
2132     }
2133     else {
2134         char msg[256];
2135         sprintf(msg, "%s[%d]:  internal error:  unable to find %s",
2136                 __FILE__, __LINE__, func_name_.c_str());
2137         showErrorCallback(100, msg);
2138         assert(0);  // can probably be more graceful
2139     }
2140     
2141         // TODO: put register allocation here and have emitCall just
2142         // move the return result.
2143     if (tmp == REG_NULL) {
2144         // Happens in function replacement... didn't allocate
2145         // a return register.
2146     }
2147     else if (retReg == REG_NULL) {
2148         //emitFuncCall allocated tmp; we can use it, but let's see
2149         // if we should keep it around.
2150         retReg = tmp;
2151         // from allocateAndKeep:
2152         if (useCount > 1) {
2153             // If use count is 0 or 1, we don't want to keep
2154             // it around. If it's > 1, then we can keep the node
2155             // (by construction) and want to since there's another
2156             // use later.
2157             gen.tracker()->addKeptRegister(gen, this, retReg);
2158         }
2159     }           
2160     else if (retReg != tmp) {
2161         emitImm(orOp, tmp, 0, retReg, gen, noCost, gen.rs());
2162         gen.rs()->freeRegister(tmp);
2163     }
2164     decUseCount(gen);
2165     return true;
2166 }
2167
2168 bool AstSequenceNode::generateCode_phase2(codeGen &gen, bool noCost,
2169                                           Address &,
2170                                           Register &retReg) {
2171     RETURN_KEPT_REG(retReg);
2172     Register tmp = REG_NULL;
2173     Address unused = ADDR_NULL;
2174     
2175     if (sequence_.size() == 0) {
2176       // Howzat???
2177       return true;
2178     }
2179
2180     for (unsigned i = 0; i < sequence_.size() - 1; i++) {
2181       if (!sequence_[i]->generateCode_phase2(gen,
2182                                                noCost, 
2183                                                unused,
2184                                                tmp)) ERROR_RETURN;
2185         if (sequence_[i]->decRefCount())
2186            gen.rs()->freeRegister(tmp);
2187         tmp = REG_NULL;
2188     }
2189
2190     // We keep the last one
2191     if (!sequence_.back()->generateCode_phase2(gen, noCost, unused, retReg)) ERROR_RETURN;
2192
2193         decUseCount(gen);
2194     
2195     return true;
2196 }
2197
2198 bool AstVariableNode::generateCode_phase2(codeGen &gen, bool noCost,
2199                                           Address &addr,
2200                                           Register &retReg) {
2201     return ast_wrappers_[index]->generateCode_phase2(gen, noCost, addr, retReg);
2202 }
2203
2204 bool AstInsnNode::generateCode_phase2(codeGen &gen, bool,
2205                                       Address &, Register &) {
2206     assert(insn_);
2207    
2208     insnCodeGen::generate(gen,*insn_,gen.addrSpace(),origAddr_,gen.currAddr());
2209     decUseCount(gen);
2210     
2211     return true;
2212 }
2213
2214 bool AstInsnBranchNode::generateCode_phase2(codeGen &gen, bool noCost,
2215                                             Address &, Register & ) {
2216     assert(insn_);
2217     
2218     // Generate side 2 and get the result...
2219     Address targetAddr = ADDR_NULL;
2220     Register targetReg = REG_NULL;
2221     if (target_) {
2222         // TODO: address vs. register...
2223         if (!target_->generateCode_phase2(gen, noCost, targetAddr, targetReg)) ERROR_RETURN;
2224     }
2225     // We'd now generate a fixed or register branch. But we don't. So there.
2226     assert(0 && "Unimplemented");
2227     insnCodeGen::generate(gen,*insn_,gen.addrSpace(), origAddr_, gen.currAddr(), 0, 0);
2228         decUseCount(gen);
2229
2230     return true;
2231 }
2232
2233 bool AstInsnMemoryNode::generateCode_phase2(codeGen &gen, bool noCost,
2234                                             Address &, Register &) {
2235     Register loadReg = REG_NULL;
2236     Register storeReg = REG_NULL;
2237     Address loadAddr = ADDR_NULL;
2238     Address storeAddr = ADDR_NULL;
2239     assert(insn_);
2240
2241     // Step 1: save machine-specific state (AKA flags) and mark registers used in
2242     // the instruction itself as off-limits.
2243
2244     gen.rs()->saveVolatileRegisters(gen);
2245     pdvector<int> usedRegisters;
2246     if (insn_->getUsedRegs(usedRegisters)) {
2247         for (unsigned i = 0; i < usedRegisters.size(); i++) {
2248             gen.rs()->markReadOnly(usedRegisters[i]);
2249         }
2250     }
2251     else {
2252         // We don't know who to avoid... return false?
2253         fprintf(stderr, "WARNING: unknown \"off limits\" register set, returning false from memory modification\n");
2254         return false;
2255     }
2256
2257     // Step 2: generate code (this may spill registers)
2258
2259     if (load_)
2260         if (!load_->generateCode_phase2(gen, noCost, loadAddr, loadReg)) ERROR_RETURN;
2261     
2262     if (store_)
2263         if (!store_->generateCode_phase2(gen, noCost, storeAddr, storeReg)) ERROR_RETURN;
2264
2265     // Step 3: restore flags (before the original instruction)
2266
2267     gen.rs()->restoreVolatileRegisters(gen);
2268
2269     // Step 4: generate the memory instruction
2270     if (!insnCodeGen::generateMem(gen,*insn_,origAddr_, gen.currAddr(), loadReg, storeReg)) {
2271         fprintf(stderr, "ERROR: generateMem call failed\n");
2272         return false;
2273     }
2274
2275     // Step 5: restore any registers that were st0mped. 
2276
2277
2278     gen.rs()->restoreAllRegisters(gen, true);
2279
2280     decUseCount(gen);
2281     return true;
2282 }
2283
2284 bool AstOriginalAddrNode::generateCode_phase2(codeGen &gen,
2285                                               bool noCost,
2286                                               Address &,
2287                                               Register &retReg) {
2288     RETURN_KEPT_REG(retReg);
2289     if (retReg == REG_NULL) {
2290         retReg = allocateAndKeep(gen, noCost);
2291     }
2292     if (retReg == REG_NULL) return false;
2293
2294     emitVload(loadConstOp, 
2295               (Address) gen.point()->addr_compat(),
2296               retReg, retReg, gen, noCost);
2297     return true;
2298 }
2299
2300 bool AstActualAddrNode::generateCode_phase2(codeGen &gen,
2301                                             bool noCost,
2302                                             Address &,
2303                                             Register &retReg) {
2304     if (retReg == REG_NULL) {
2305         retReg = allocateAndKeep(gen, noCost);
2306     }
2307     if (retReg == REG_NULL) return false;
2308
2309     emitVload(loadConstOp, 
2310               (Address) gen.currAddr(),
2311               retReg, retReg, 
2312               gen, noCost);
2313
2314     return true;
2315 }
2316
2317 bool AstDynamicTargetNode::generateCode_phase2(codeGen &gen,
2318                                             bool noCost,
2319                                             Address & retAddr,
2320                                             Register &retReg) 
2321 {
2322     if (gen.point()->type() != instPoint::PreCall &&
2323        gen.point()->type() != instPoint::FuncExit &&
2324        gen.point()->type() != instPoint::PreInsn) 
2325        return false;
2326
2327    InstructionAPI::Instruction::Ptr insn = gen.point()->block()->getInsn(gen.point()->block()->last());
2328    if (insn->getCategory() == c_ReturnInsn) {
2329       // if this is a return instruction our AST reads the top stack value
2330       if (retReg == REG_NULL) {
2331          retReg = allocateAndKeep(gen, noCost);
2332       }
2333       if (retReg == REG_NULL) return false;
2334
2335 #if defined (arch_x86)
2336         emitVload(loadRegRelativeOp, 
2337                   (Address) sizeof(Address), 
2338                   REGNUM_ESP, 
2339                   retReg, 
2340                   gen, noCost);
2341 #elif defined (arch_x86_64) // KEVINTODO: untested
2342         emitVload(loadRegRelativeOp, 
2343                   (Address) sizeof(Address), 
2344                   REGNUM_RSP, 
2345                   retReg, 
2346                   gen, noCost);
2347         bpwarn("WARNING: Untested functionality for x86/64 platform");
2348 #elif defined (arch_power) // KEVINTODO: untested
2349         emitVload(loadRegRelativeOp, 
2350                   (Address) sizeof(Address), 
2351                   REG_SP,
2352                   retReg, 
2353                   gen, noCost);
2354 #else
2355         assert(0);
2356 #endif
2357       return true;
2358    }
2359    else {// this is a dynamic ctrl flow instruction, have
2360       // getDynamicCallSiteArgs generate the necessary AST
2361       pdvector<AstNodePtr> args;
2362       if (!gen.addrSpace()->getDynamicCallSiteArgs(insn, gen.point()->block()->last(), args)) {
2363          return false;
2364       }
2365       if (!args[0]->generateCode_phase2(gen, noCost, retAddr, retReg)) {
2366          return false;
2367       }
2368       return true;                      
2369    }
2370 }
2371
2372 bool AstScrambleRegistersNode::generateCode_phase2(codeGen &gen, 
2373                                                   bool , 
2374                                                   Address&, 
2375                                                   Register& )
2376 {
2377    (void)gen; // unused
2378 #if defined(arch_x86_64)
2379    for (int i = 0; i < gen.rs()->numGPRs(); i++) {
2380       registerSlot *reg = gen.rs()->GPRs()[i];
2381       if (reg->encoding() != REGNUM_RBP && reg->encoding() != REGNUM_RSP)
2382           gen.codeEmitter()->emitLoadConst(reg->encoding() , -1, gen);
2383    }
2384 #endif
2385    return true;
2386 }
2387
2388 #if defined(AST_PRINT)
2389 std::string getOpString(opCode op)
2390 {
2391     switch (op) {
2392         case plusOp: return("+");
2393         case minusOp: return("-");
2394         case timesOp: return("*");
2395         case divOp: return("/");
2396         case lessOp: return("<");
2397         case leOp: return("<=");
2398         case greaterOp: return(">");
2399         case geOp: return(">=");
2400         case eqOp: return("==");
2401         case neOp: return("!=");
2402         case loadOp: return("lda");
2403         case loadConstOp: return("load");
2404         case storeOp: return("=");
2405         case ifOp: return("if");
2406         case ifMCOp: return("ifMC");
2407         case whileOp: return("while") ;
2408         case doOp: return("while") ;
2409         case trampPreamble: return("preTramp");
2410         case branchOp: return("goto");
2411         case noOp: return("nop");
2412         case andOp: return("and");
2413         case orOp: return("or");
2414         case loadIndirOp: return("load&");
2415         case storeIndirOp: return("=&");
2416         case loadFrameRelativeOp: return("load $fp");
2417         case loadRegRelativeOp: return("load $reg");
2418         case loadFrameAddr: return("$fp");
2419         case storeFrameRelativeOp: return("store $fp");
2420         case getAddrOp: return("&");
2421         default: return("ERROR");
2422     }
2423 }
2424 #endif
2425
2426 #undef MIN
2427 #define MIN(x,y) ((x)>(y) ? (y) : (x))
2428 #undef MAX
2429 #define MAX(x,y) ((x)>(y) ? (x) : (y))
2430 #undef AVG
2431 #define AVG(x,y) (((x)+(y))/2)
2432
2433 int AstOperatorNode::costHelper(enum CostStyleType costStyle) const {
2434     int total = 0;
2435     int getInsnCost(opCode t);
2436     
2437     if (op == ifOp) {
2438         // loperand is the conditional expression
2439         if (loperand) total += loperand->costHelper(costStyle);
2440         total += getInsnCost(op);
2441         int rcost = 0, ecost = 0;
2442         if (roperand) {
2443             rcost = roperand->costHelper(costStyle);
2444             if (eoperand)
2445                 rcost += getInsnCost(branchOp);
2446         }
2447         if (eoperand)
2448             ecost = eoperand->costHelper(costStyle);
2449         if(ecost == 0) { // ie. there's only the if body
2450             if(costStyle      == Min)  total += 0;
2451             //guess half time body not executed
2452             else if(costStyle == Avg)  total += rcost / 2;
2453             else if(costStyle == Max)  total += rcost;
2454         } else {  // ie. there's an else block also, for the statements
2455             if(costStyle      == Min)  total += MIN(rcost, ecost);
2456             else if(costStyle == Avg)  total += AVG(rcost, ecost);
2457             else if(costStyle == Max)  total += MAX(rcost, ecost);
2458         }
2459     } else if (op == storeOp) {
2460         if (roperand) total += roperand->costHelper(costStyle);
2461         total += getInsnCost(op);
2462     } else if (op == storeIndirOp) {
2463         if (loperand) total += loperand->costHelper(costStyle);
2464         if (roperand) total += roperand->costHelper(costStyle);
2465         total += getInsnCost(op);
2466     } else if (op == trampPreamble) {
2467         total = getInsnCost(op);
2468     } else {
2469         if (loperand) 
2470             total += loperand->costHelper(costStyle);
2471         if (roperand) 
2472             total += roperand->costHelper(costStyle);
2473         total += getInsnCost(op);
2474     }
2475     return total;
2476 }
2477
2478 int AstOperandNode::costHelper(enum CostStyleType costStyle) const {
2479     int total = 0;
2480     if (oType == Constant) {
2481         total = getInsnCost(loadConstOp);
2482     } else if (oType == DataIndir) {
2483         total = getInsnCost(loadIndirOp);
2484         total += operand()->costHelper(costStyle);
2485     } else if (oType == DataAddr) {
2486         total = getInsnCost(loadOp);
2487     } else if (oType == DataReg) {
2488         total = getInsnCost(loadIndirOp);
2489     } else if (oType == Param || oType == ParamAtCall || oType == ParamAtEntry) {
2490         total = getInsnCost(getParamOp);
2491     }
2492     return total;
2493 }
2494
2495 int AstCallNode::costHelper(enum CostStyleType costStyle) const {
2496     int total = 0;
2497     if (func_) total += getPrimitiveCost(func_->prettyName().c_str());
2498     else total += getPrimitiveCost(func_name_);
2499
2500     for (unsigned u = 0; u < args_.size(); u++)
2501         if (args_[u]) total += args_[u]->costHelper(costStyle);
2502     return total;
2503 }
2504     
2505
2506 int AstSequenceNode::costHelper(enum CostStyleType costStyle) const {
2507     int total = 0;
2508     for (unsigned i = 0; i < sequence_.size(); i++) {
2509         total += sequence_[i]->costHelper(costStyle);
2510     }
2511
2512     return total;
2513 }
2514
2515 int AstVariableNode::costHelper(enum CostStyleType /*costStyle*/) const{
2516     int total = 0;
2517     return total;
2518 }
2519
2520 #if defined(AST_PRINT)
2521 void AstNode::print() const {
2522   if (this) {
2523 #if defined(ASTDEBUG)
2524     bpfatal("{%d}", referenceCount) ;
2525 #endif
2526     if (type == operandNode) {
2527       if (oType == Constant) {
2528         fprintf(stderr,"%d", (int)(Address) oValue);
2529       } else if (oType == ConstantString) {
2530         fprintf(stderr," %s", (char *)oValue);
2531       } else if (oType == DataIndir) {
2532         fprintf(stderr," @[");
2533         loperand->print();
2534         fprintf(stderr,"]");
2535       } else if (oType == DataReg) {
2536         fprintf(stderr," reg%d ",(int)(Address)oValue);
2537         loperand->print();
2538       } else if (oType == Param || oType == ParamAtCall || oType == ParamAtEntry) {
2539         fprintf(stderr," param[%d]", (int)(Address) oValue);
2540       } else if (oType == ReturnVal) {
2541         fprintf(stderr,"retVal");
2542       } else if (oType == ReturnAddr) {
2543         fprintf(stderr, "retAddr");
2544       } else if (oType == DataAddr)  {
2545         if(!oVar)
2546         {
2547           fprintf(stderr," [0x%lx]", (long) oValue);
2548         }
2549         else
2550         {
2551           fprintf(stderr," [%s]", oVar->symTabName().c_str());
2552         }
2553         
2554       } else if (oType == FrameAddr)  {
2555         fprintf(stderr," [$fp + %d]", (int)(Address) oValue);
2556       } else if (oType == RegOffset)  {
2557         fprintf(stderr," [$%d + %d]", (int)(Address) loperand->getOValue(), (int)(Address) oValue);
2558       } else if (oType == EffectiveAddr)  {
2559         fprintf(stderr," <<effective address>>");
2560       } else if (oType == BytesAccessed)  {
2561         fprintf(stderr," <<bytes accessed>>");
2562       } else {
2563         fprintf(stderr," <Unknown Operand>");
2564       }
2565     } else if (type == opCodeNode_t) {
2566       cerr << "(" << getOpString(op);
2567       if (loperand) loperand->print();
2568       if (roperand) roperand->print();
2569       if (eoperand) eoperand->print();
2570       fprintf(stderr,")\n");
2571     } else if (type == callNode) {
2572       cerr << "(" << callee;
2573       for (unsigned u = 0; u < operands.size(); u++)
2574          operands[u]->print();
2575       fprintf(stderr,")\n");
2576     } else if (type == sequenceNode_t) {
2577        if (loperand) loperand->print();
2578        fprintf(stderr,",");
2579        if (roperand) roperand->print();
2580        fprintf(stderr,"\n");
2581     }
2582   }
2583 }
2584 #endif
2585
2586 BPatch_type *AstNode::checkType(BPatch_function*) {
2587     return BPatch::bpatch->type_Untyped;
2588 }
2589
2590 BPatch_type *AstOperatorNode::checkType(BPatch_function* func) {
2591     BPatch_type *ret = NULL;
2592     BPatch_type *lType = NULL, *rType = NULL, *eType = NULL;
2593     bool errorFlag = false;
2594
2595     assert(BPatch::bpatch != NULL);     /* We'll use this later. */
2596
2597     if ((loperand || roperand) && getType()) {
2598         // something has already set the type for us.
2599         // this is likely an expression for array access
2600        ret = const_cast<BPatch_type *>(getType());
2601        return ret;
2602     }
2603
2604     if (loperand) lType = loperand->checkType(func);
2605
2606     if (roperand) rType = roperand->checkType(func);
2607
2608     if (eoperand) eType = eoperand->checkType(func);
2609     (void)eType; // unused...
2610
2611     if (lType == BPatch::bpatch->type_Error ||
2612         rType == BPatch::bpatch->type_Error)
2613        errorFlag = true;
2614     
2615     switch (op) {
2616     case ifOp:
2617     case whileOp:
2618         // XXX No checking for now.  Should check that loperand
2619         // is boolean.
2620         ret = BPatch::bpatch->type_Untyped;
2621         break;
2622     case noOp:
2623         ret = BPatch::bpatch->type_Untyped;
2624         break;
2625     case funcJumpOp:
2626         ret = BPatch::bpatch->type_Untyped;
2627         break;
2628     case getAddrOp:
2629         // Should set type to the infered type not just void * 
2630         //  - jkh 7/99
2631         ret = BPatch::bpatch->stdTypes->findType("void *");
2632         assert(ret != NULL);
2633         break;
2634     default:
2635         // XXX The following line must change to decide based on the
2636         // types and operation involved what the return type of the
2637         // expression will be.
2638         ret = lType;
2639         if (lType != NULL && rType != NULL) {
2640             if (!lType->isCompatible(rType)) {
2641                 fprintf(stderr, "WARNING: LHS type %s not compatible with RHS type %s\n",
2642                         lType->getName(), rType->getName());
2643                 errorFlag = true;
2644             }
2645         }
2646         break;
2647     }
2648     assert (ret != NULL);
2649
2650     if (errorFlag && doTypeCheck) {
2651        ret = BPatch::bpatch->type_Error;
2652     } else if (errorFlag) {
2653        ret = BPatch::bpatch->type_Untyped;
2654     }
2655
2656 #if defined(ASTDEBUG)
2657     // it would be useful to have some indication of what the type applied to
2658     // (currently it appears to be copious amounts of contextless junk)
2659     if (ret) {
2660        logLine(" type is ");
2661        if (ret->getName()){ 
2662           logLine(ret->getName());
2663        } else {
2664           logLine(" <NULL Name String>");
2665           logLine("\n");
2666        }
2667     }
2668 #endif
2669
2670     // remember what type we are
2671     setType(ret);
2672
2673     return ret;
2674 }
2675
2676 BPatch_type *AstOperandNode::checkType(BPatch_function* func)
2677 {
2678     BPatch_type *ret = NULL;
2679     BPatch_type *type = NULL;
2680     bool errorFlag = false;
2681     
2682     assert(BPatch::bpatch != NULL);     /* We'll use this later. */
2683
2684     if (operand_ && getType()) {
2685        // something has already set the type for us.
2686        // this is likely an expression for array access
2687        ret = const_cast<BPatch_type *>(getType());
2688        return ret;
2689     }
2690     
2691     if (operand_) type = operand_->checkType(func);
2692
2693     if (type == BPatch::bpatch->type_Error)
2694        errorFlag = true;
2695     
2696     if (oType == DataIndir) {
2697         // XXX Should really be pointer to lType -- jkh 7/23/99
2698         ret = BPatch::bpatch->type_Untyped;
2699     } 
2700     else if ((oType == Param) || (oType == ParamAtCall) || 
2701              (oType == ParamAtEntry) || (oType == ReturnVal) 
2702              || (oType == ReturnAddr)) {
2703       if(func)
2704       {
2705         switch(oType)
2706         {
2707         case ReturnVal:
2708           {
2709             ret = func->getReturnType();
2710             if(!ret || (ret->isCompatible(BPatch::bpatch->builtInTypes->findBuiltInType("void")))) {
2711                   if(ret) {
2712                       errorFlag = true;
2713                   } 
2714               ret = BPatch::bpatch->type_Untyped;
2715             } 
2716             break;
2717           }
2718         default:
2719           ret = BPatch::bpatch->type_Untyped;
2720         }
2721         
2722       }
2723       else
2724       {
2725         // If we don't have a function context, then ignore types
2726         ret = BPatch::bpatch->type_Untyped; 
2727       }
2728     }
2729     else if (oType == origRegister) {
2730         ret = BPatch::bpatch->type_Untyped;
2731     }
2732     else {
2733         ret = const_cast<BPatch_type *>(getType());
2734     }
2735     assert(ret != NULL);
2736
2737     if (errorFlag && doTypeCheck) {
2738        ret = BPatch::bpatch->type_Error;
2739     } else if (errorFlag) {
2740        ret = BPatch::bpatch->type_Untyped;
2741     }
2742
2743 #if defined(ASTDEBUG)
2744     // it would be useful to have some indication of what the type applied to
2745     // (currently it appears to be copious amounts of contextless junk)
2746     if (ret) {
2747         logLine(" type is ");
2748         if (ret->getName()) 
2749              logLine(ret->getName());
2750         else
2751              logLine(" <NULL Name String>");
2752         logLine("\n");
2753     }
2754 #endif
2755
2756     // remember what type we are
2757     setType(ret);
2758
2759     return ret;
2760
2761 }
2762
2763
2764 BPatch_type *AstCallNode::checkType(BPatch_function* func) {
2765     BPatch_type *ret = NULL;
2766     bool errorFlag = false;
2767     
2768     assert(BPatch::bpatch != NULL);     /* We'll use this later. */
2769     
2770     unsigned i;
2771     for (i = 0; i < args_.size(); i++) {
2772         BPatch_type *operandType = args_[i]->checkType(func);
2773         /* XXX Check operands for compatibility */
2774         if (operandType == BPatch::bpatch->type_Error) {
2775             errorFlag = true;
2776         }
2777     }
2778     /* XXX Should set to return type of function. */
2779     ret = BPatch::bpatch->type_Untyped;
2780
2781     assert(ret != NULL);
2782
2783     if (errorFlag && doTypeCheck) {
2784        ret = BPatch::bpatch->type_Error;
2785     } else if (errorFlag) {
2786        ret = BPatch::bpatch->type_Untyped;
2787     }
2788
2789 #if defined(ASTDEBUG)
2790     // it would be useful to have some indication of what the type applied to
2791     // (currently it appears to be copious amounts of contextless junk)
2792     if (ret) {
2793         logLine(" type is ");
2794         if (ret->getName()) 
2795              logLine(ret->getName());
2796         else
2797              logLine(" <NULL Name String>");
2798         logLine("\n");
2799     }
2800 #endif
2801
2802     // remember what type we are
2803     setType(ret);
2804
2805     return ret;
2806 }
2807
2808 BPatch_type *AstSequenceNode::checkType(BPatch_function* func) {
2809     BPatch_type *ret = NULL;
2810     BPatch_type *sType = NULL;
2811     bool errorFlag = false;
2812     
2813     assert(BPatch::bpatch != NULL);     /* We'll use this later. */
2814
2815     if (getType()) {
2816         // something has already set the type for us.
2817         // this is likely an expression for array access
2818         ret = const_cast<BPatch_type *>(getType());
2819         return ret;
2820     }
2821
2822     for (unsigned i = 0; i < sequence_.size(); i++) {
2823         sType = sequence_[i]->checkType(func);
2824         if (sType == BPatch::bpatch->type_Error)
2825             errorFlag = true;
2826     }
2827
2828     ret = sType;
2829
2830     assert(ret != NULL);
2831     
2832     if (errorFlag && doTypeCheck) {
2833         ret = BPatch::bpatch->type_Error;
2834     } else if (errorFlag) {
2835         ret = BPatch::bpatch->type_Untyped;
2836     }
2837     
2838 #if defined(ASTDEBUG)
2839     // it would be useful to have some indication of what the type applied to
2840     // (currently it appears to be copious amounts of contextless junk)
2841     if (ret) {
2842         logLine(" type is ");
2843         if (ret->getName()) 
2844              logLine(ret->getName());
2845         else
2846              logLine(" <NULL Name String>");
2847         logLine("\n");
2848     }
2849 #endif
2850
2851     // remember what type we are
2852     setType(ret);
2853
2854     return ret;
2855 }
2856
2857 bool AstNode::accessesParam() {
2858 #if 0
2859     fprintf(stderr, "Undefined call to getChildren for type: ");
2860     if (dynamic_cast<AstNullNode *>(this)) fprintf(stderr, "nullNode\n");
2861     else if (dynamic_cast<AstOperatorNode *>(this)) fprintf(stderr, "operatorNode\n");
2862     else if (dynamic_cast<AstOperandNode *>(this)) fprintf(stderr, "operandNode\n");
2863     else if (dynamic_cast<AstCallNode *>(this)) fprintf(stderr, "callNode\n");
2864     else if (dynamic_cast<AstSequenceNode *>(this)) fprintf(stderr, "seqNode\n");
2865     else if (dynamic_cast<AstVariableNode *>(this)) fprintf(stderr, "varNode\n");
2866     else if (dynamic_cast<AstInsnNode *>(this)) fprintf(stderr, "insnNode\n");
2867     else if (dynamic_cast<AstMiniTrampNode *>(this)) fprintf(stderr, "miniTrampNode\n");
2868     else if (dynamic_cast<AstMemoryNode *>(this)) fprintf(stderr, "memoryNode\n");
2869     else fprintf(stderr, "unknownNode\n");
2870 #endif
2871     return false;
2872 }
2873
2874
2875 // This is not the most efficient way to traverse a DAG
2876 bool AstOperatorNode::accessesParam()
2877 {
2878     bool ret = false;
2879     if (loperand)
2880         ret |= loperand->accessesParam();
2881     if (roperand)
2882         ret |= roperand->accessesParam();
2883     if (eoperand)
2884         ret |= eoperand->accessesParam();
2885     return ret;
2886 }
2887
2888
2889 bool AstCallNode::accessesParam() {
2890     for (unsigned i = 0; i < args_.size(); i++) {
2891         if (args_[i]->accessesParam())
2892             return true;
2893     }
2894     return false;
2895 }
2896
2897 bool AstSequenceNode::accessesParam() {
2898     for (unsigned i = 0; i < sequence_.size(); i++) {
2899         if (sequence_[i]->accessesParam())
2900             return true;
2901     }
2902     return false;
2903 }
2904
2905 bool AstVariableNode::accessesParam() {
2906     return ast_wrappers_[index]->accessesParam();
2907 }
2908
2909 // Our children may have incorrect useCounts (most likely they 
2910 // assume that we will not bother them again, which is wrong)
2911 void AstNode::fixChildrenCounts()
2912 {
2913     pdvector<AstNodePtr> children;
2914     getChildren(children);
2915     for (unsigned i=0; i<children.size(); i++) {
2916                 children[i]->setUseCount();
2917     }
2918 }
2919
2920
2921 // Check if the node can be kept at all. Some nodes (e.g., storeOp)
2922 // can not be cached. In fact, there are fewer nodes that can be cached.
2923 bool AstOperatorNode::canBeKept() const {
2924     switch (op) {
2925     case plusOp:
2926     case minusOp:
2927     case timesOp:
2928     case divOp:
2929     case neOp:
2930     case noOp:
2931     case orOp:
2932     case andOp:
2933                 break;
2934     default:
2935         return false;
2936     }
2937
2938     // The switch statement is a little odd, but hey. 
2939     if (loperand && !loperand->canBeKept()) return false;
2940     if (roperand && !roperand->canBeKept()) return false;
2941     if (eoperand && !eoperand->canBeKept()) return false;
2942     
2943     return true;
2944 }
2945
2946 bool AstOperandNode::canBeKept() const {
2947     
2948     switch (oType) {
2949     case DataReg:
2950     case DataIndir:
2951     case RegOffset:
2952     case origRegister:
2953     case DataAddr:
2954     case variableValue:
2955         return false;
2956     default:
2957                 break;
2958     }
2959     if (operand_ && !operand_->canBeKept()) return false;
2960     return true;
2961 }
2962
2963 bool AstCallNode::canBeKept() const {
2964     if (constFunc_) {
2965         for (unsigned i = 0; i < args_.size(); i++) {
2966             if (!args_[i]->canBeKept()) {
2967                 fprintf(stderr, "AST %p: labelled const func but argument %d cannot be kept!\n",
2968                         this, i);
2969                 return false;
2970             }
2971         }
2972         return true;
2973     }
2974     return false;
2975     
2976 }
2977
2978 bool AstSequenceNode::canBeKept() const {
2979         // Theoretically we could keep the entire thing, but... not sure
2980         // that's a terrific idea. For now, don't keep a sequence node around.
2981     return false;
2982 }
2983
2984 bool AstVariableNode::canBeKept() const {
2985     return ast_wrappers_[index]->canBeKept();
2986 }
2987
2988 bool AstMiniTrampNode::canBeKept() const {
2989         // Well... depends on the actual AST, doesn't it.
2990         assert(ast_);
2991         
2992         return ast_->canBeKept();
2993 }
2994
2995 bool AstMemoryNode::canBeKept() const {
2996         // Despite our memory loads, we can be kept;
2997         // we're loading off process state, which is defined
2998         // to be invariant during the instrumentation phase.
2999         return true;
3000 }
3001
3002 // Occasionally, we do not call .generateCode_phase2 for the referenced node, 
3003 // but generate code by hand. This routine decrements its use count properly
3004 void AstNode::decUseCount(codeGen &gen)
3005 {
3006     if (useCount == 0) return;
3007     
3008     useCount--;
3009     
3010     if (useCount == 0) {
3011         gen.tracker()->removeKeptRegister(gen, this);
3012     }
3013 }
3014
3015 // Return all children of this node ([lre]operand, ..., operands[])
3016
3017 void AstNode::getChildren(pdvector<AstNodePtr > &) {
3018 #if 0
3019     fprintf(stderr, "Undefined call to getChildren for type: ");
3020     if (dynamic_cast<AstNullNode *>(this)) fprintf(stderr, "nullNode\n");
3021     else if (dynamic_cast<AstOperatorNode *>(this)) fprintf(stderr, "operatorNode\n");
3022     else if (dynamic_cast<AstOperandNode *>(this)) fprintf(stderr, "operandNode\n");
3023     else if (dynamic_cast<AstCallNode *>(this)) fprintf(stderr, "callNode\n");
3024     else if (dynamic_cast<AstSequenceNode *>(this)) fprintf(stderr, "seqNode\n");
3025     else if (dynamic_cast<AstInsnNode *>(this)) fprintf(stderr, "insnNode\n");
3026     else if (dynamic_cast<AstMiniTrampNode *>(this)) fprintf(stderr, "miniTrampNode\n");
3027     else if (dynamic_cast<AstMemoryNode *>(this)) fprintf(stderr, "memoryNode\n");
3028     else fprintf(stderr, "unknownNode\n");
3029 #endif
3030 }
3031
3032 void AstNode::setChildren(pdvector<AstNodePtr > &) {
3033 #if 0
3034     fprintf(stderr, "Undefined call to setChildren for type: ");
3035     if (dynamic_cast<AstNullNode *>(this)) fprintf(stderr, "nullNode\n");
3036     else if (dynamic_cast<AstOperatorNode *>(this)) fprintf(stderr, "operatorNode\n");
3037     else if (dynamic_cast<AstOperandNode *>(this)) fprintf(stderr, "operandNode\n");
3038     else if (dynamic_cast<AstCallNode *>(this)) fprintf(stderr, "callNode\n");
3039     else if (dynamic_cast<AstSequenceNode *>(this)) fprintf(stderr, "seqNode\n");
3040     else if (dynamic_cast<AstInsnNode *>(this)) fprintf(stderr, "insnNode\n");
3041     else if (dynamic_cast<AstMiniTrampNode *>(this)) fprintf(stderr, "miniTrampNode\n");
3042     else if (dynamic_cast<AstMemoryNode *>(this)) fprintf(stderr, "memoryNode\n");
3043     else fprintf(stderr, "unknownNode\n");
3044 #endif
3045 }
3046
3047 void AstOperatorNode::getChildren(pdvector<AstNodePtr > &children) {
3048     if (loperand) children.push_back(loperand);
3049     if (roperand) children.push_back(roperand);
3050     if (eoperand) children.push_back(eoperand);
3051 }
3052
3053 void AstOperatorNode::setChildren(pdvector<AstNodePtr > &children){
3054    int count = (loperand ? 1 : 0) + (roperand ? 1 : 0) + (eoperand ? 1 : 0); 
3055    if ((int)children.size() == count){
3056       //memory management?
3057       if (loperand) loperand = children[0];
3058       if (roperand) roperand = children[1];
3059       if (eoperand) eoperand = children[2];
3060    }else{
3061       fprintf(stderr, "OPERATOR setChildren given bad arguments. Wanted:%d , given:%d\n", count, (int)children.size());      
3062    }
3063 }
3064
3065 AstNodePtr AstOperatorNode::deepCopy(){
3066    AstNodePtr copy = operatorNode(op, (loperand ? loperand->deepCopy() : loperand),
3067                                   (roperand ? roperand->deepCopy() : roperand),
3068                                   (eoperand ? eoperand->deepCopy() : eoperand));
3069    copy->setType(bptype);
3070    copy->setTypeChecking(doTypeCheck);
3071
3072    copy->setLineNum(getLineNum());
3073    copy->setColumnNum(getColumnNum());
3074    copy->setSnippetName(snippetName);
3075
3076 /* TODO: Impliment this copy.
3077    copy->columnInfoSet = columnInfoSet
3078    copy->lineInfoSet = lineInfoSet;
3079 */
3080    return copy;
3081 }
3082
3083 void AstOperandNode::getChildren(pdvector<AstNodePtr > &children) {
3084     if (operand_) children.push_back(operand_);
3085 }
3086
3087 void AstOperandNode::setChildren(pdvector<AstNodePtr > &children){
3088    if (children.size() == 1){
3089       //memory management?
3090       operand_ = children[0];
3091    }else{
3092       fprintf(stderr, "OPERAND setChildren given bad arguments. Wanted:%d , given:%d\n", 1,  (int)children.size());      
3093    }
3094 }
3095
3096 AstNodePtr AstOperandNode::deepCopy(){
3097    AstOperandNode * copy = new AstOperandNode();
3098    copy->oType = oType;
3099    copy->oValue = oValue; //this might need to be copied deeper
3100    copy->oVar = oVar;
3101    if(operand_) copy->operand_ = operand_->deepCopy();
3102
3103    copy->setType(bptype);
3104    copy->setTypeChecking(doTypeCheck);
3105
3106    copy->setLineNum(getLineNum());
3107    copy->lineInfoSet = lineInfoSet;
3108    copy->setColumnNum(getColumnNum());
3109    copy->columnInfoSet = columnInfoSet;
3110    copy->setSnippetName(getSnippetName());
3111    return AstNodePtr(copy);
3112 }
3113
3114 void AstCallNode::getChildren(pdvector<AstNodePtr > &children) {
3115     for (unsigned i = 0; i < args_.size(); i++)
3116         children.push_back(args_[i]);
3117 }
3118
3119 void AstCallNode::setChildren(pdvector<AstNodePtr > &children){
3120    if (children.size() == args_.size()){
3121       //memory management?
3122       for (unsigned i = 0; i < args_.size(); i++){
3123          AstNodePtr * newNode = new AstNodePtr(children[i]);
3124          args_.push_back(*newNode);
3125          args_.erase(args_.begin() + i + 1);
3126       }
3127    }else{
3128       fprintf(stderr, "CALL setChildren given bad arguments. Wanted:%d , given:%d\n",  (int)args_.size(),  (int)children.size());      
3129    }
3130 }
3131
3132 AstNodePtr AstCallNode::deepCopy(){
3133    pdvector<AstNodePtr> empty_args;
3134
3135    AstCallNode * copy;
3136
3137    if(func_name_.empty()){
3138       copy = new AstCallNode();
3139    }else{
3140       copy = new AstCallNode(func_name_, empty_args);
3141    }
3142 //   copy->func_name_ = func_name_;
3143    copy->func_addr_ = func_addr_; 
3144    copy->func_ = func_;
3145
3146    for(unsigned int i = 0; i < args_.size(); ++i){
3147       copy->args_.push_back(args_[i]->deepCopy());
3148    }
3149   
3150    copy->callReplace_ = callReplace_;
3151    copy->constFunc_ = constFunc_;
3152
3153    copy->setType(bptype);
3154    copy->setTypeChecking(doTypeCheck);
3155
3156    copy->setLineNum(getLineNum());
3157    copy->lineInfoSet = lineInfoSet;
3158    copy->setColumnNum(getColumnNum());
3159    copy->columnInfoSet = columnInfoSet;
3160    copy->setSnippetName(getSnippetName());
3161    copy->snippetNameSet = snippetNameSet;
3162
3163    return AstNodePtr(copy);
3164 }
3165
3166 void AstSequenceNode::getChildren(pdvector<AstNodePtr > &children) {
3167     for (unsigned i = 0; i < sequence_.size(); i++)
3168         children.push_back(sequence_[i]);
3169 }
3170
3171 void AstSequenceNode::setChildren(pdvector<AstNodePtr > &children){
3172    if (children.size() == sequence_.size()){
3173       //memory management?
3174       for (unsigned i = 0; i < sequence_.size(); i++){
3175          AstNodePtr * newNode = new AstNodePtr(children[i]);
3176          sequence_.push_back(*newNode);
3177          sequence_.erase(sequence_.begin() + i + 1);
3178       }
3179    }else{
3180       fprintf(stderr, "SEQ setChildren given bad arguments. Wanted:%d , given:%d\n", (int)sequence_.size(),  (int)children.size());      
3181    }
3182 }
3183
3184 AstNodePtr AstSequenceNode::deepCopy(){
3185    AstSequenceNode * copy = new AstSequenceNode();
3186    for(unsigned int i = 0; i < sequence_.size(); ++i){
3187       copy->sequence_.push_back(sequence_[i]->deepCopy());
3188    }
3189
3190    copy->setType(bptype);
3191    copy->setTypeChecking(doTypeCheck);
3192
3193    copy->setLineNum(getLineNum());
3194    copy->lineInfoSet = lineInfoSet;
3195    copy->setColumnNum(getColumnNum());
3196    copy->columnInfoSet = columnInfoSet;
3197    copy->setSnippetName(getSnippetName());
3198    copy->snippetNameSet = snippetNameSet;
3199
3200    return AstNodePtr(copy);
3201 }
3202
3203 void AstVariableNode::getChildren(pdvector<AstNodePtr > &children) {
3204     ast_wrappers_[index]->getChildren(children);
3205 }
3206
3207 void AstVariableNode::setChildren(pdvector<AstNodePtr > &children){
3208    ast_wrappers_[index]->setChildren(children);
3209 }
3210
3211 AstNodePtr AstVariableNode::deepCopy(){
3212    AstVariableNode * copy = new AstVariableNode();
3213    copy->index = index;
3214    copy->ranges_ = ranges_; //i'm not sure about this one. (it's a vector)
3215    for(unsigned int i = 0; i < ast_wrappers_.size(); ++i){
3216       copy->ast_wrappers_.push_back(ast_wrappers_[i]->deepCopy());
3217    }
3218
3219    copy->setType(bptype);
3220    copy->setTypeChecking(doTypeCheck);
3221
3222    copy->setLineNum(getLineNum());
3223    copy->lineInfoSet = lineInfoSet;
3224    copy->setColumnNum(getColumnNum());
3225    copy->columnInfoSet = columnInfoSet;
3226    copy->setSnippetName(getSnippetName());
3227    copy->snippetNameSet = snippetNameSet;
3228
3229    return AstNodePtr(copy);
3230 }
3231
3232 void AstMiniTrampNode::getChildren(pdvector<AstNodePtr > &children) {
3233     children.push_back(ast_);
3234 }
3235
3236 void AstMiniTrampNode::setChildren(pdvector<AstNodePtr > &children){
3237    if (children.size() == 1){
3238       //memory management?
3239       ast_ = children[0];
3240    }else{
3241  fprintf(stderr, "MINITRAMP setChildren given bad arguments. Wanted:%d , given:%d\n", 1,  (int)children.size());      
3242    }
3243 }
3244
3245 AstNodePtr AstMiniTrampNode::deepCopy(){
3246    AstMiniTrampNode * copy = new AstMiniTrampNode();
3247    copy->inline_ = inline_;
3248    copy->ast_ = ast_->deepCopy();
3249
3250    copy->setType(bptype);
3251    copy->setTypeChecking(doTypeCheck);
3252
3253    copy->setLineNum(getLineNum());
3254    copy->lineInfoSet = lineInfoSet;
3255    copy->setColumnNum(getColumnNum());
3256    copy->columnInfoSet = columnInfoSet;
3257    copy->setSnippetName(getSnippetName());
3258    copy->snippetNameSet = snippetNameSet;
3259
3260    return AstNodePtr(copy);
3261 }
3262
3263
3264 void AstOperatorNode::setVariableAST(codeGen &g) {
3265     if(loperand) loperand->setVariableAST(g);
3266     if(roperand) roperand->setVariableAST(g);
3267     if(eoperand) eoperand->setVariableAST(g);
3268 }
3269
3270 void AstOperandNode::setVariableAST(codeGen &g){
3271     if(operand_) operand_->setVariableAST(g);
3272 }
3273
3274 void AstCallNode::setVariableAST(codeGen &g){
3275     for (unsigned i = 0; i < args_.size(); i++)
3276         args_[i]->setVariableAST(g);
3277 }
3278
3279 void AstSequenceNode::setVariableAST(codeGen &g) {
3280     for (unsigned i = 0; i < sequence_.size(); i++)
3281         sequence_[i]->setVariableAST(g);
3282 }
3283
3284 void AstVariableNode::setVariableAST(codeGen &gen){
3285     //fprintf(stderr, "Generating code for variable in function %s with start address 0x%lx at address 0x%lx\n",gen.func()->prettyName().c_str(), gen.func()->getAddress(),gen.point()->addr());
3286     if(!ranges_)
3287         return;
3288     if(!gen.point())    //oneTimeCode. Set the AST at the beginning of the function??
3289     {
3290         index = 0;
3291         return;
3292     }
3293     Address addr = gen.point()->addr_compat();     //Offset of inst point from function base address
3294     bool found = false;
3295     for(unsigned i=0; i< ranges_->size();i++){
3296        if((*ranges_)[i].first<=addr && addr<=(*ranges_)[i].second) {
3297           index = i;
3298           found = true;
3299        }
3300     }
3301     if (!found) {
3302        cerr << "Error: unable to find AST representing variable at " << hex << addr << dec << endl;
3303        cerr << "Pointer " << hex << this << dec << endl;
3304        cerr << "Options are: " << endl;
3305        for(unsigned i=0; i< ranges_->size();i++){
3306           cerr << "\t" << hex << (*ranges_)[i].first << "-" << (*ranges_)[i].second << dec << endl;
3307        }
3308     }
3309     assert(found);
3310 }
3311
3312 void AstInsnBranchNode::setVariableAST(codeGen &g){
3313     if(target_) target_->setVariableAST(g);
3314 }
3315
3316 void AstInsnMemoryNode::setVariableAST(codeGen &g){
3317     if(load_) load_->setVariableAST(g);
3318     if(store_) store_->setVariableAST(g);
3319 }
3320
3321 void AstMiniTrampNode::setVariableAST(codeGen &g){
3322     if(ast_) ast_->setVariableAST(g);
3323 }
3324
3325 bool AstCallNode::containsFuncCall() const {
3326    return true;
3327 }
3328
3329
3330
3331 bool AstOperatorNode::containsFuncCall() const {
3332         if (loperand && loperand->containsFuncCall()) return true;
3333         if (roperand && roperand->containsFuncCall()) return true;
3334         if (eoperand && eoperand->containsFuncCall()) return true;
3335         return false;
3336 }
3337
3338 bool AstOperandNode::containsFuncCall() const {
3339         if (operand_ && operand_->containsFuncCall()) return true;
3340         return false;
3341 }
3342
3343 bool AstMiniTrampNode::containsFuncCall() const {
3344         if (ast_ && ast_->containsFuncCall()) return true;
3345         return false;
3346 }
3347
3348 bool AstSequenceNode::containsFuncCall() const {
3349         for (unsigned i = 0; i < sequence_.size(); i++) {
3350                 if (sequence_[i]->containsFuncCall()) return true;
3351         }
3352         return false;
3353 }
3354
3355 bool AstVariableNode::containsFuncCall() const 
3356 {
3357     return ast_wrappers_[index]->containsFuncCall();
3358 }
3359
3360 bool AstInsnMemoryNode::containsFuncCall() const {
3361     if (load_ && load_->containsFuncCall()) return true;
3362     if (store_ && store_->containsFuncCall()) return true;
3363     return false;
3364 }
3365
3366 bool AstNullNode::containsFuncCall() const
3367 {
3368    return false;
3369 }
3370
3371 bool AstStackInsertNode::containsFuncCall() const
3372 {
3373     return false;
3374 }
3375
3376 bool AstStackRemoveNode::containsFuncCall() const
3377 {
3378     return false;
3379 }
3380
3381 bool AstStackGenericNode::containsFuncCall() const
3382 {
3383     return false;
3384 }
3385
3386 bool AstLabelNode::containsFuncCall() const
3387 {
3388    return false;
3389 }
3390
3391 bool AstMemoryNode::containsFuncCall() const
3392 {
3393    return false;
3394 }
3395
3396 bool AstInsnNode::containsFuncCall() const
3397 {
3398    return false;
3399 }
3400
3401 bool AstOriginalAddrNode::containsFuncCall() const
3402 {
3403    return false;
3404 }
3405
3406 bool AstActualAddrNode::containsFuncCall() const
3407 {
3408    return false;
3409 }
3410
3411 bool AstDynamicTargetNode::containsFuncCall() const
3412 {
3413    return false;
3414 }
3415 bool AstScrambleRegistersNode::containsFuncCall() const
3416 {
3417    return false;
3418 }
3419
3420 bool AstCallNode::usesAppRegister() const {
3421    for (unsigned i=0; i<args_.size(); i++) {
3422       if (args_[i] && args_[i]->usesAppRegister()) return true;
3423    }
3424    return false;
3425 }
3426
3427 bool AstOperatorNode::usesAppRegister() const {
3428         if (loperand && loperand->usesAppRegister()) return true;
3429         if (roperand && roperand->usesAppRegister()) return true;
3430         if (eoperand && eoperand->usesAppRegister()) return true;
3431         return false;
3432 }
3433
3434 bool AstOperandNode::usesAppRegister() const {
3435    if (oType == AstNode::FrameAddr ||
3436        oType == AstNode::RegOffset ||
3437        oType == AstNode::origRegister ||
3438        oType == AstNode::Param ||
3439        oType == AstNode::ParamAtEntry ||
3440        oType == AstNode::ParamAtCall ||
3441        oType == AstNode::ReturnVal)
3442    {
3443       return true;
3444    }
3445
3446    if (operand_ && operand_->usesAppRegister()) return true;
3447    return false;
3448 }
3449
3450 bool AstMiniTrampNode::usesAppRegister() const {
3451         if (ast_ && ast_->usesAppRegister()) return true;
3452         return false;
3453 }
3454
3455 bool AstSequenceNode::usesAppRegister() const {
3456         for (unsigned i = 0; i < sequence_.size(); i++) {
3457                 if (sequence_[i]->usesAppRegister()) return true;
3458         }
3459         return false;
3460 }
3461
3462 bool AstVariableNode::usesAppRegister() const 
3463 {
3464     return ast_wrappers_[index]->usesAppRegister();
3465 }
3466
3467 bool AstInsnMemoryNode::usesAppRegister() const {
3468     if (load_ && load_->usesAppRegister()) return true;
3469     if (store_ && store_->usesAppRegister()) return true;
3470     return false;
3471 }
3472
3473 bool AstNullNode::usesAppRegister() const
3474 {
3475    return false;
3476 }
3477
3478 bool AstStackInsertNode::usesAppRegister() const
3479 {
3480     return false;
3481 }
3482
3483 bool AstStackRemoveNode::usesAppRegister() const
3484 {
3485     return false;
3486 }
3487
3488 bool AstStackGenericNode::usesAppRegister() const
3489 {
3490     return false;
3491 }
3492
3493 bool AstLabelNode::usesAppRegister() const
3494 {
3495    return false;
3496 }
3497
3498 bool AstDynamicTargetNode::usesAppRegister() const
3499 {
3500    return false;
3501 }
3502
3503 bool AstActualAddrNode::usesAppRegister() const
3504 {
3505    return false;
3506 }
3507
3508 bool AstOriginalAddrNode::usesAppRegister() const
3509 {
3510    return false;
3511 }
3512
3513 bool AstMemoryNode::usesAppRegister() const
3514 {
3515    return true;
3516 }
3517
3518 bool AstInsnNode::usesAppRegister() const
3519 {
3520    return true;
3521 }
3522 bool AstScrambleRegistersNode::usesAppRegister() const
3523 {
3524    return true;
3525 }
3526
3527 void regTracker_t::addKeptRegister(codeGen &gen, AstNode *n, Register reg) {
3528         assert(n);
3529         if (tracker.find(n) != tracker.end()) {
3530                 assert(tracker[n].keptRegister == reg);
3531                 return;
3532         }
3533         commonExpressionTracker t;
3534         t.keptRegister = reg;
3535         t.keptLevel = condLevel;
3536         tracker[n] = t;
3537         gen.rs()->markKeptRegister(reg);
3538 }
3539
3540 void regTracker_t::removeKeptRegister(codeGen &gen, AstNode *n) {
3541    auto iter = tracker.find(n);
3542    if (iter == tracker.end()) return;
3543
3544    gen.rs()->unKeepRegister(iter->second.keptRegister);
3545    tracker.erase(iter);
3546 }
3547
3548 Register regTracker_t::hasKeptRegister(AstNode *n) {
3549    auto iter = tracker.find(n);
3550    if (iter == tracker.end())
3551       return REG_NULL;
3552    else return iter->second.keptRegister;
3553 }
3554
3555 // Find if the given register is "owned" by an AST node,
3556 // and if so nuke it.
3557
3558 bool regTracker_t::stealKeptRegister(Register r) {
3559         ast_printf("STEALING kept register %d for someone else\n", r);
3560         for (auto iter = tracker.begin(); iter != tracker.end(); ++iter) {
3561            if (iter->second.keptRegister == r) {
3562               tracker.erase(iter);
3563               return true;
3564            }
3565         }
3566         fprintf(stderr, "Odd - couldn't find kept register %d\n", r);
3567         return true;
3568 }
3569
3570 void regTracker_t::reset() {
3571         condLevel = 0;
3572         tracker.clear();
3573 }
3574
3575 void regTracker_t::increaseConditionalLevel() {
3576         condLevel++;
3577         ast_printf("Entering conditional branch, level now %d\n", condLevel);
3578 }
3579
3580 void regTracker_t::decreaseAndClean(codeGen &) {
3581
3582     assert(condLevel > 0);
3583     
3584     ast_printf("Exiting from conditional branch, level currently %d\n", condLevel);
3585     
3586     std::vector<AstNode *> delete_list;
3587
3588     for (auto iter = tracker.begin(); iter != tracker.end();) {
3589        if (iter->second.keptLevel == condLevel) {
3590           iter = tracker.erase(iter);
3591        }
3592        else {
3593           ++iter;
3594        }
3595     }
3596     
3597     condLevel--;
3598 }
3599
3600 unsigned regTracker_t::astHash(AstNode* const &ast) {
3601         return addrHash4((Address) ast);
3602 }
3603
3604 void regTracker_t::debugPrint() {
3605     if (!dyn_debug_ast) return;
3606     
3607     fprintf(stderr, "==== Begin debug dump of register tracker ====\n");
3608     
3609     fprintf(stderr, "Condition level: %d\n", condLevel);
3610     
3611     for (auto iter = tracker.begin(); iter != tracker.end(); ++iter) {
3612        fprintf(stderr, "AstNode %p: register %d, condition level %d\n",
3613                iter->first, iter->second.keptRegister, iter->second.keptLevel);
3614     }   
3615     fprintf(stderr, "==== End debug dump of register tracker ====\n");
3616 }
3617
3618 unsigned AstNode::getTreeSize() {
3619         pdvector<AstNodePtr > children;
3620         getChildren(children);
3621
3622         unsigned size = 1; // Us
3623         for (unsigned i = 0; i < children.size(); i++)
3624                 size += children[i]->getTreeSize();
3625         return size;
3626         
3627 }
3628
3629 int_variable* AstOperandNode::lookUpVar(AddressSpace* as)
3630 {
3631   mapped_module *mod = as->findModule(oVar->pdmod()->fileName());
3632   if(mod && (oVar->pdmod() == mod->pmod()))
3633   {
3634     int_variable* tmp = mod->obj()->findVariable(const_cast<image_variable*>(oVar));
3635     return tmp;
3636   }
3637   return NULL;
3638 }
3639
3640 void AstOperandNode::emitVariableLoad(opCode op, Register src2, Register dest, codeGen& gen, 
3641                                       bool noCost, registerSpace* rs, 
3642                                       int size, const instPoint* point, AddressSpace* as)
3643 {
3644   int_variable* var = lookUpVar(as);
3645   if(var && !as->needsPIC(var))
3646   {
3647     emitVload(op, var->getAddress(), src2, dest, gen, noCost, rs, size, point, as);
3648   }
3649   else
3650   {
3651     gen.codeEmitter()->emitLoadShared(op, dest, oVar, (var!=NULL),size, gen, 0);
3652   }  
3653 }
3654
3655 void AstOperandNode::emitVariableStore(opCode op, Register src1, Register src2, codeGen& gen, 
3656                                       bool noCost, registerSpace* rs, 
3657                                       int size, const instPoint* point, AddressSpace* as)
3658 {
3659   int_variable* var = lookUpVar(as);
3660   if (var && !as->needsPIC(var))
3661