Description of the SPARC as a target architecture.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@233 91177308-0d34-0410-b5e6-96231b3b80d8

4 files changed, 1813 insertions, 0 deletions

diff --git a/lib/CodeGen/TargetMachine/Sparc/Makefile b/lib/CodeGen/TargetMachine/Sparc/Makefile
new file mode 100644
index 0000000000..27105f7172
--- /dev/null
+++ b/lib/CodeGen/TargetMachine/Sparc/Makefile
@@ -0,0 +1,19 @@
+LEVEL = ../../../..
+
+DIRS  = 
+
+LIBRARYNAME = sparc
+
+## List source files in link order
+Source  = \
+	  Sparc.o \
+	  Sparc.burm.o \
+	  SparcInstrSelection.o
+
+include $(LEVEL)/Makefile.common
+
+BURG = burg -I
+
+%.burm.c: %.burg
+	$(BURG) -o $@ $<
+
diff --git a/lib/CodeGen/TargetMachine/Sparc/Sparc.burg b/lib/CodeGen/TargetMachine/Sparc/Sparc.burg
new file mode 100644
index 0000000000..d2e3e8c001
--- /dev/null
+++ b/lib/CodeGen/TargetMachine/Sparc/Sparc.burg
@@ -0,0 +1,282 @@
+%{
+#include <stdio.h>
+#include <llvm/Codegen/InstrForest.h>
+
+typedef BasicTreeNode* NODEPTR_TYPE;
+#define OP_LABEL(p)	((p)->opLabel)
+#define LEFT_CHILD(p)	((p)->leftChild)
+#define RIGHT_CHILD(p)	((p)->rightChild)
+#define STATE_LABEL(p)	((p)->state)
+#define PANIC		printf
+%}
+
+%start stmt
+
+%term Ret=1		/* return void from a function */
+%term RetValue=101	/* return a value from a function */
+%term BrUncond=2
+%term BrCond=102
+%term Switch=3 
+		/* 4 is unused */
+%term Not=4
+%term Add=5
+%term Sub=6
+%term Mul=7
+%term Div=8
+%term Rem=9
+%term And=10
+%term Or=11
+%term Xor=12
+%term SetCC=113		/* use this to match all SetCC instructions */
+	/* %term SetEQ=13 */
+	/* %term SetNE=14 */
+	/* %term SetLE=15 */
+	/* %term SetGE=16 */
+	/* %term SetLT=17 */
+	/* %term SetGT=18 */
+%term Malloc=19
+%term Free=20
+%term Alloca=21
+%term AllocaN=121	/* alloca with arg N */
+%term Load=22
+%term LoadIdx=122	/* load with index vector */
+%term Store=23
+%term GetElemPtr=24
+%term GetElemPtrIdx=124	/* getElemPtr with index vector */
+
+		/* 25 is PHINode, which is never a real tree node */
+
+%term Cast=26	/* cast that will be ignored.  others are made explicit */
+%term ToBoolTy=126
+%term ToUByteTy=127
+%term ToSByteTy=128
+%term ToUShortTy=129
+%term ToShortTy=130
+%term ToUIntTy=131
+%term ToIntTy=132
+%term ToULongTy=133
+%term ToLongTy=134
+%term ToFloatTy=135
+%term ToDoubleTy=136
+%term ToArrayTy=137
+%term ToPointerTy=138
+
+%term Call=27
+%term Shl=28
+%term Shr=29
+		/* 30...46 are unused */
+    /*
+     * The foll. values should match the constants in InstrForest.h
+     */
+%term VRegList=97
+%term VReg=98
+%term Constant=99
+%term Label=100
+		/* 50+i is a variant of i, as defined above */
+
+
+%%
+/*-----------------------------------------------------------------------*
+ * The productions of the grammar.
+ * Note that all chain rules are numbered 101 and above.
+ * Also, a special case of production X is numbered 100+X.
+ *-----------------------------------------------------------------------*/
+
+	/*
+	 * The top-level statements
+	 */
+stmt:	Ret			=   1 (3);
+stmt:	RetValue(reg)		=   2 (3);
+stmt:	Store(reg,reg)		=   3 (1);
+stmt:	Store(reg,ptrreg)	=   4 (1);
+stmt:	BrUncond		=   5 (2);
+stmt:	BrCond(boolconst)	=   6 (1);	/* may save one instruction */
+stmt:	BrCond(bool)		=   7 (2);
+stmt:	BrCond(boolreg)		=   8 (2);	
+stmt:	Switch(reg)		=   9 (3);	/* cost = load + branch */
+
+stmt:	reg			=  111 (0);
+stmt:	boolconst		=  112 (0);
+stmt:	bool			=  113 (0);
+
+	/*
+	 * List node used for nodes with more than 2 children
+	 */
+reg:	VRegList(reg,reg)	=  10 (0);
+
+	/*
+	 * The unary operators.  We encode NOT and individual casts into
+	 * separate non-terminals to combine instructions for some cases:
+	 *	Eg1:  zdouble <- todouble(xfloat) * todouble(yfloat)
+	 *	Eg2:  c       <- a AND (NOT b).
+	 * Note that the costs are counted for the individual non-terminals
+	 * below, not for reg.
+	 */
+reg:	not			=  121 (0);
+reg:	tobool			=  122 (0);
+reg:	toubyte			=  123 (0);
+reg:	tosbyte			=  124 (0);
+reg:	toushort		=  125 (0);
+reg:	toshort			=  126 (0);
+reg:	touint			=  127 (0);
+reg:	toint			=  128 (0);
+reg:	toulong			=  129 (0);
+reg:	tolong			=  130 (0);
+reg:	tofloat			=  131 (0);
+reg:	todouble		=  132 (0);
+
+not:	  Not(reg)		=  21 (1);
+tobool:	  ToBoolTy(reg)		=  22 (1);
+toubyte:  ToUByteTy(reg)	=  23 (1);
+tosbyte:  ToSByteTy(reg)	=  24 (1);
+toushort: ToUShortTy(reg)	=  25 (1);
+toshort:  ToShortTy(reg)	=  26 (1);
+touint:	  ToUIntTy(reg)		=  27 (1);
+toint:	  ToIntTy(reg)		=  28 (1);
+toulong:  ToULongTy(reg)	=  29 (1);
+tolong:	  ToLongTy(reg)		=  30 (1);
+tofloat:  ToFloatTy(reg)	=  31 (1);
+todouble: ToDoubleTy(reg)	=  32 (1);
+
+reg:	  ToArrayTy(reg)	=  19 (1);
+reg:	  ToPointerTy(reg)	=  20 (1);
+
+	/*
+	 * The binary operators.
+	 */
+reg:	Add(reg,reg)		=   33 (1);
+reg:	Sub(reg,reg)		=   34 (1);
+reg:	Mul(reg,reg)		=   35 (3);
+reg:	Mul(todouble,todouble)	=  135 (2);	/* avoids 1-2 type converts */
+reg:	Div(reg,reg)		=   36 (6);
+reg:	Rem(reg,reg)		=   37 (6);
+reg:	And(reg,reg)		=   38 (1);
+reg:	And(reg,not)		=  138 (0);	/* cost is counted for not */
+reg:	Or (reg,reg)		=   39 (1);
+reg:	Or (reg,not)		=  139 (0);	/* cost is counted for not */
+reg:	Xor(reg,reg)		=   40 (1);
+reg:	Xor(reg,not)		=  140 (0);	/* cost is counted for not */
+
+	/*
+	 * The SetCC instructions and other boolean values
+	 */
+boolconst: SetCC(reg,Constant)	=   41 (1);
+bool:	   SetCC(reg,reg)	=   42 (1);
+boolreg:   VReg			=   43 (0);
+
+	/*
+	 * Memory access instructions
+	 */
+reg:	Load(reg)		=   51 (3);
+reg:	Load(ptrreg)		=   52 (2);	/* 1 counted for ptrreg */
+reg:	LoadIdx(reg,reg)	=   53 (3);
+reg:	LoadIdx(ptrreg,reg)	=   54 (2);	/* 1 counted for ptrreg */
+reg:	ptrreg			=  155 (0);
+ptrreg:	GetElemPtr(reg)		=   55 (1);
+ptrreg:	GetElemPtrIdx(reg,reg)	=   56 (1);
+reg:	Alloca			=   57 (1);
+reg:	AllocaN(reg)		=   58 (1);
+
+	/*
+	 * Other operators producing register values
+	 */
+reg:	Call			=   61 (0);
+reg:	Shl(reg,reg)		=   62 (1);
+reg:	Shr(reg,reg)		=   63 (1);
+
+	/*
+	 * Finally, leaf nodes of expression trees (other than boolreg)
+	 */
+reg:	VReg			=   71 (0);
+reg:	Constant		=   72 (0);
+
+
+
+%%
+/*-----------------------------------------------------------------------*
+ * The rest of this file provides code to print the cover produced
+ * by BURG and information about computed tree cost and matches.
+ * This code was taken from sample.gr provided with BURG.
+ *-----------------------------------------------------------------------*/
+
+static char rcsid[] = "$Id$";
+
+#ifdef __STDC__
+void printcover(NODEPTR_TYPE p, int goalnt, int indent) {
+#else
+void printcover(p, goalnt, indent) NODEPTR_TYPE p; int goalnt; int indent; {
+#endif
+	int eruleno = burm_rule(STATE_LABEL(p), goalnt);
+	short *nts = burm_nts[eruleno];
+	NODEPTR_TYPE kids[10];
+	int i;
+	
+	if (eruleno == 0) {
+		printf("no cover\n");
+		return;
+	}
+	for (i = 0; i < indent; i++)
+		printf(".");
+	printf("%s\n", burm_string[eruleno]);
+	burm_kids(p, eruleno, kids);
+	for (i = 0; nts[i]; i++)
+		printcover(kids[i], nts[i], indent+1);
+}
+
+#ifdef __STDC__
+void printtree(NODEPTR_TYPE p) {
+#else
+void printtree(p) NODEPTR_TYPE p; {
+#endif
+	int op = burm_op_label(p);
+
+	printf("%s", burm_opname[op]);
+	switch (burm_arity[op]) {
+	case 0:
+		break;
+	case 1:
+		printf("(");
+		printtree(burm_child(p, 0));
+		printf(")");
+		break;
+	case 2:
+		printf("(");
+		printtree(burm_child(p, 0));
+		printf(", ");
+		printtree(burm_child(p, 1));
+		printf(")");
+		break;
+	}
+}
+
+#ifdef __STDC__
+int treecost(NODEPTR_TYPE p, int goalnt, int costindex) {
+#else
+int treecost(p, goalnt, costindex) NODEPTR_TYPE p; int goalnt; int costindex; {
+#endif
+	int eruleno = burm_rule(STATE_LABEL(p), goalnt);
+	int cost = burm_cost[eruleno][costindex], i;
+	short *nts = burm_nts[eruleno];
+	NODEPTR_TYPE kids[10];
+
+	burm_kids(p, eruleno, kids);
+	for (i = 0; nts[i]; i++)
+		cost += treecost(kids[i], nts[i], costindex);
+	return cost;
+}
+
+#ifdef __STDC__
+void printMatches(NODEPTR_TYPE p) {
+#else
+void printMatches(p) NODEPTR_TYPE p; {
+#endif
+	int nt;
+	int eruleno;
+
+	printf("Node 0x%lx= ", (unsigned long)p);
+	printtree(p);
+	printf(" matched rules:\n");
+	for (nt = 1; burm_ntname[nt] != (char*)NULL; nt++)
+		if ((eruleno = burm_rule(STATE_LABEL(p), nt)) != 0)
+			printf("\t%s\n", burm_string[eruleno]);
+}
diff --git a/lib/CodeGen/TargetMachine/Sparc/Sparc.cpp b/lib/CodeGen/TargetMachine/Sparc/Sparc.cpp
new file mode 100644
index 0000000000..08e12ff99a
--- /dev/null
+++ b/lib/CodeGen/TargetMachine/Sparc/Sparc.cpp
@@ -0,0 +1,56 @@
+// $Id$
+//***************************************************************************
+// File:
+//	Sparc.cpp
+// 
+// Purpose:
+//	
+// History:
+//	7/15/01	 -  Vikram Adve  -  Created
+//**************************************************************************/
+
+
+//************************** System Include Files **************************/
+
+//*************************** User Include Files ***************************/
+
+#include "llvm/DerivedTypes.h"
+#include "llvm/Codegen/Sparc.h"
+
+
+//************************ Exported Constants ******************************/
+
+
+// Set external object describing the machine instructions
+// 
+const MachineInstrInfo* TargetMachineInstrInfo = SparcMachineInstrInfo; 
+
+
+//************************ Class Implementations **************************/
+
+
+//---------------------------------------------------------------------------
+// class UltraSparcMachine 
+// 
+// Purpose:
+//   Machine description.
+// 
+//---------------------------------------------------------------------------
+
+UltraSparc::UltraSparc()
+  : TargetMachine()
+{
+  optSizeForSubWordData = 4;
+  intSize = 4; 
+  floatSize = 4; 
+  longSize = 8; 
+  doubleSize = 8; 
+  longDoubleSize = 16; 
+  pointerSize = 8;
+  minMemOpWordSize = 8; 
+  maxAtomicMemOpWordSize = 8;
+  machineInstrInfo = SparcMachineInstrInfo;
+  zeroRegNum = 0;			// %g0 always gives 0 on Sparc
+}
+
+//**************************************************************************/
diff --git a/lib/CodeGen/TargetMachine/Sparc/SparcInstrSelection.cpp b/lib/CodeGen/TargetMachine/Sparc/SparcInstrSelection.cpp
new file mode 100644
index 0000000000..13384b8edb
--- /dev/null
+++ b/lib/CodeGen/TargetMachine/Sparc/SparcInstrSelection.cpp
@@ -0,0 +1,1456 @@
+// $Id$
+//***************************************************************************
+// File:
+//	SparcInstrSelection.cpp
+// 
+// Purpose:
+//	
+// History:
+//	7/02/01	 -  Vikram Adve  -  Created
+//***************************************************************************
+
+
+//************************** System Include Files **************************/
+
+#include <assert.h>
+
+//*************************** User Include Files ***************************/
+
+#include "llvm/Type.h"
+#include "llvm/DerivedTypes.h"
+#include "llvm/SymbolTable.h"
+#include "llvm/Value.h"
+#include "llvm/Instruction.h"
+#include "llvm/InstrTypes.h"
+#include "llvm/iTerminators.h"
+#include "llvm/iMemory.h"
+#include "llvm/iOther.h"
+#include "llvm/BasicBlock.h"
+#include "llvm/Method.h"
+#include "llvm/ConstPoolVals.h"
+#include "llvm/LLC/CompileContext.h"
+#include "llvm/Codegen/Sparc.h"
+#include "llvm/Codegen/MachineInstr.h"
+#include "llvm/Codegen/InstrForest.h"
+#include "llvm/Codegen/InstrSelection.h"
+
+
+//******************** Internal Data Declarations ************************/
+
+// to be used later
+struct BranchPattern {
+  bool	        flipCondition; // should the sense of the test be reversed
+  BasicBlock*	targetBB;      // which basic block to branch to
+  MachineInstr* extraBranch;   // if neither branch is fall-through, then this
+                               // BA must be inserted after the cond'l one
+};
+
+//************************* Forward Declarations ***************************/
+
+
+static MachineOpCode	ChooseBprInstruction	(const InstructionNode* instrNode);
+
+static MachineOpCode	ChooseBccInstruction	(const InstructionNode* instrNode,
+						 bool& isFPBranch);
+
+static MachineOpCode	ChooseBpccInstruction	(const InstructionNode* instrNode,
+						 const BinaryOperator* setCCInstr);
+
+static MachineOpCode	ChooseBfpccInstruction	(const InstructionNode* instrNode,
+						 const BinaryOperator* setCCInstr);
+
+static MachineOpCode	ChooseConvertToFloatInstr(const InstructionNode* instrNode,
+						  const Type* opType);
+
+static MachineOpCode	ChooseConvertToIntInstr	(const InstructionNode* instrNode,
+						 const Type* opType);
+
+static MachineOpCode	ChooseAddInstruction	(const InstructionNode* instrNode);
+
+static MachineOpCode	ChooseSubInstruction	(const InstructionNode* instrNode);
+
+static MachineOpCode	ChooseFcmpInstruction	(const InstructionNode* instrNode);
+
+static MachineOpCode	ChooseMulInstruction	(const InstructionNode* instrNode,
+						 bool checkCasts);
+
+static MachineOpCode	ChooseDivInstruction	(const InstructionNode* instrNode);
+
+static MachineOpCode	ChooseLoadInstruction	(const Type* resultType);
+
+static MachineOpCode	ChooseStoreInstruction	(const Type* valueType);
+
+static void		SetOperandsForMemInstr	(MachineInstr* minstr,
+					 const InstructionNode* vmInstrNode,
+					 const TargetMachine& targetMachine);
+
+static void		SetMemOperands_Internal	(MachineInstr* minstr,
+					 const InstructionNode* vmInstrNode,
+					 Value* ptrVal,
+					 Value* arrayOffsetVal,
+					 const vector<ConstPoolVal*>& idxVec,
+					 const TargetMachine& targetMachine);
+
+static unsigned		FixConstantOperands(const InstructionNode* vmInstrNode,
+					 MachineInstr** mvec,
+					 unsigned numInstr,
+					 TargetMachine& targetMachine);
+
+static unsigned		InsertLoadConstInstructions(unsigned loadConstFlags,
+				         const InstructionNode* vmInstrNode,
+					 MachineInstr** mvec,
+					 unsigned numInstr);
+
+static MachineInstr*	MakeOneLoadConstInstr(Instruction* vmInstr,
+					      Value* val);
+
+
+//******************* Externally Visible Functions *************************/
+
+
+//------------------------------------------------------------------------ 
+// External Function: ThisIsAChainRule
+//
+// Purpose:
+//   Check if a given BURG rule is a chain rule.
+//------------------------------------------------------------------------ 
+
+extern bool
+ThisIsAChainRule(int eruleno)
+{
+  switch(eruleno)
+    {
+    case 111:	// stmt:  reg
+    case 112:	// stmt:  boolconst
+    case 113:	// stmt:  bool
+    case 121:
+    case 122:
+    case 123:
+    case 124:
+    case 125:
+    case 126:
+    case 127:
+    case 128:
+    case 129:
+    case 130:
+    case 131:
+    case 132:
+    case 153: return true; break;
+      
+    default: return false; break;
+    }
+}
+
+//------------------------------------------------------------------------ 
+// External Function: GetInstructionsByRule
+//
+// Purpose:
+//   Choose machine instructions for the SPARC according to the
+//   patterns chosen by the BURG-generated parser.
+//------------------------------------------------------------------------ 
+
+unsigned
+GetInstructionsByRule(InstructionNode* subtreeRoot,
+		      int ruleForNode,
+		      short* nts,
+		      CompileContext& ccontext,
+		      MachineInstr** mvec)
+{
+  int numInstr = 1;			// initialize for common case
+  bool checkCast = false;		// initialize here to use fall-through
+  Value *leftVal, *rightVal;
+  const Type* opType;
+  int nextRule;
+  BranchPattern brPattern;
+  
+  mvec[0] = mvec[1] = mvec[2] = mvec[3] = NULL;	// just for safety
+  
+  switch(ruleForNode) {
+  case 1:	// stmt:   Ret
+  case 2:	// stmt:   RetValue(reg)
+		// NOTE: Prepass of register allocation is responsible
+		//	 for moving return value to appropriate register.
+		// Mark the return-address register as a hidden virtual reg.
+    {		
+    Instruction* returnReg = new TmpInstruction(Instruction::UserOp1,
+					subtreeRoot->getInstruction(), NULL);
+    subtreeRoot->getInstruction()->getMachineInstrVec().addTempValue(returnReg);
+    
+    mvec[0] = new MachineInstr(RETURN);
+    mvec[0]->SetMachineOperand(0, MachineOperand::MO_Register, returnReg);
+    mvec[0]->SetMachineOperand(1, MachineOperand::MO_SignExtendedImmed,
+			          (int64_t) 0);
+
+    mvec[numInstr++] = new MachineInstr(NOP); // delay slot
+    break;
+    }  
+    
+  case 3:	// stmt:   Store(reg,reg)
+  case 4:	// stmt:   Store(reg,ptrreg)
+    mvec[0] = new MachineInstr(ChooseStoreInstruction(subtreeRoot->leftChild()->getValue()->getType()));
+    SetOperandsForMemInstr(mvec[0], subtreeRoot, ccontext.getTarget());
+    break;
+    
+  case 5:	// stmt:   BrUncond
+    mvec[0] = new MachineInstr(BA);
+    mvec[0]->SetMachineOperand(0, MachineOperand::MO_PCRelativeDisp,
+	      ((BranchInst*) subtreeRoot->getInstruction())->getSuccessor(0));
+    
+    mvec[numInstr++] = new MachineInstr(NOP); // delay slot
+    break;
+    
+  case 6:	// stmt:   BrCond(boolconst)
+    // boolconst => boolean was computed with `%b = setCC type reg1 constant'
+    // If the constant is ZERO, we can use the branch-on-integer-register
+    // instructions and avoid the SUBcc instruction entirely.
+    // Otherwise this is just the same as case 5, so just fall through.
+    {
+    InstrTreeNode* constNode = subtreeRoot->leftChild()->rightChild();
+    assert(constNode && constNode->getNodeType() ==InstrTreeNode::NTConstNode);
+    ConstPoolVal* constVal = (ConstPoolVal*) constNode->getValue();
+    
+    if (constVal->getType()->isIntegral()
+	&& ((constVal->getType()->isSigned()
+	     && ((ConstPoolSInt*) constVal)->getValue()==0)
+	    || (constVal->getType()->isUnsigned()
+		&& ((ConstPoolUInt*) constVal)->getValue()== 0)))
+      {
+	// Whew!  Ok, that was zero after all...
+	// Use the left child of the setCC instruction as the first argument!
+	mvec[0] = new MachineInstr(ChooseBprInstruction(subtreeRoot));
+	mvec[0]->SetMachineOperand(0, MachineOperand::MO_Register,
+		      subtreeRoot->leftChild()->leftChild()->getValue());
+	mvec[0]->SetMachineOperand(1, MachineOperand::MO_PCRelativeDisp,
+	      ((BranchInst*) subtreeRoot->getInstruction())->getSuccessor(0));
+
+	mvec[numInstr++] = new MachineInstr(NOP); // delay slot
+	
+	mvec[numInstr++] = new MachineInstr(BA); // false branch
+	mvec[numInstr-1]->SetMachineOperand(0, MachineOperand::MO_PCRelativeDisp, ((BranchInst*) subtreeRoot->getInstruction())->getSuccessor(1));
+	break;
+      }
+    // ELSE FALL THROUGH
+    }
+    
+  case 7:	// stmt:   BrCond(bool)
+    // bool => boolean was computed with `%b = setcc type reg1 reg2'
+    // Need to check whether the type was a FP, signed int or unsigned int,
+    // nad check the branching condition in order to choose the branch to use.
+    // Also, for FP branches, an extra operand specifies which FCCn reg to use.
+    // 
+    {
+    bool isFPBranch;
+    mvec[0] = new MachineInstr(ChooseBccInstruction(subtreeRoot, isFPBranch));
+    
+    int opNum = 0;
+    if (isFPBranch)
+	mvec[0]->SetMachineOperand(opNum++, MachineOperand::MO_CCRegister,
+				  subtreeRoot->leftChild()->getValue());
+    
+    mvec[0]->SetMachineOperand(opNum, MachineOperand::MO_PCRelativeDisp,
+	      ((BranchInst*) subtreeRoot->getInstruction())->getSuccessor(0));
+    
+    mvec[numInstr++] = new MachineInstr(NOP); // delay slot
+    
+    mvec[numInstr++] = new MachineInstr(BA); // false branch
+    mvec[numInstr-1]->SetMachineOperand(0, MachineOperand::MO_PCRelativeDisp, ((BranchInst*) subtreeRoot->getInstruction())->getSuccessor(1));
+    break;
+    }
+  
+  case 8:	// stmt:   BrCond(boolreg)
+    // bool => boolean is stored in an existing register.
+    // Just use the branch-on-integer-register instruction!
+    // 
+    mvec[0] = new MachineInstr(BRNZ);
+    mvec[0]->SetMachineOperand(0, MachineOperand::MO_Register,
+			         subtreeRoot->leftChild()->getValue());
+    mvec[0]->SetMachineOperand(1, MachineOperand::MO_PCRelativeDisp,
+	      ((BranchInst*) subtreeRoot->getInstruction())->getSuccessor(0));
+    mvec[numInstr++] = new MachineInstr(NOP); // delay slot
+    break;
+    
+  case 9:	// stmt:   Switch(reg)
+    assert(0 && "*** SWITCH instruction is not implemented yet.");
+    numInstr = 0;
+    break;
+    
+  case 10:	// reg:   VRegList(reg, reg)
+    assert(0 && "VRegList should never be the topmost non-chain rule");
+    break;
+    
+  case 21:	// reg:   Not(reg):	Implemented as reg = reg XOR-NOT 0
+    mvec[0] = new MachineInstr(XNOR);
+    mvec[0]->SetMachineOperand(0, MachineOperand::MO_Register,
+			          subtreeRoot->leftChild()->getValue());
+    mvec[0]->SetMachineOperand(1, /*regNum %g0*/ (unsigned int) 0);
+    mvec[0]->SetMachineOperand(2, MachineOperand::MO_Register,
+				 subtreeRoot->getValue());
+    break;
+    
+  case 22:	// reg:   ToBoolTy(reg):
+    opType = subtreeRoot->leftChild()->getValue()->getType();
+    assert(opType->isIntegral() || opType == Type::BoolTy);
+    numInstr = 0;
+    break;
+    
+  case 23:	// reg:   ToUByteTy(reg)
+  case 25:	// reg:   ToUShortTy(reg)
+  case 27:	// reg:   ToUIntTy(reg)
+  case 29:	// reg:   ToULongTy(reg)
+    opType = subtreeRoot->leftChild()->getValue()->getType();
+    assert(opType->isIntegral() || opType == Type::BoolTy);
+    numInstr = 0;
+    break;
+    
+  case 24:	// reg:   ToSByteTy(reg)
+  case 26:	// reg:   ToShortTy(reg)
+  case 28:	// reg:   ToIntTy(reg)
+  case 30:	// reg:   ToLongTy(reg)
+    opType = subtreeRoot->leftChild()->getValue()->getType();
+    if (opType->isIntegral() || opType == Type::BoolTy)
+      numInstr = 0;
+    else
+      {
+	mvec[0] =new MachineInstr(ChooseConvertToIntInstr(subtreeRoot,opType));
+	Set2OperandsFromInstr(mvec[0], subtreeRoot, ccontext.getTarget());
+      }
+    break;
+    
+  case 31:	// reg:   ToFloatTy(reg):
+  case 32:	// reg:   ToDoubleTy(reg):
+    
+    // If this instruction has a parent (a user) in the tree 
+    // and the user is translated as an FsMULd instruction,
+    // then the cast is unnecessary.  So check that first.
+    // In the future, we'll want to do the same for the FdMULq instruction,
+    // so do the check here instead of only for ToFloatTy(reg).
+    // 
+    if (subtreeRoot->parent() != NULL &&
+	((InstructionNode*) subtreeRoot->parent())->getInstruction()->getMachineInstrVec()[0]->getOpCode() == FSMULD)
+      {
+	numInstr = 0;
+      }
+    else
+      {
+	opType = subtreeRoot->leftChild()->getValue()->getType();
+	mvec[0] = new MachineInstr(ChooseConvertToFloatInstr(subtreeRoot, opType));
+	Set2OperandsFromInstr(mvec[0], subtreeRoot, ccontext.getTarget());
+      }
+    break;
+    
+  case 19:	// reg:   ToArrayTy(reg):
+  case 20:	// reg:   ToPointerTy(reg):
+    numInstr = 0;
+    break;
+    
+  case 33:	// reg:   Add(reg, reg)
+    mvec[0] = new MachineInstr(ChooseAddInstruction(subtreeRoot));
+    Set3OperandsFromInstr(mvec[0], subtreeRoot, ccontext.getTarget());
+    break;
+    
+  case 34:	// reg:   Sub(reg, reg)
+    mvec[0] = new MachineInstr(ChooseSubInstruction(subtreeRoot));
+    Set3OperandsFromInstr(mvec[0], subtreeRoot, ccontext.getTarget());
+    break;
+    
+  case 135:	// reg:   Mul(todouble, todouble)
+    checkCast = true;
+    // FALL THROUGH 
+    
+  case 35:	// reg:   Mul(reg, reg)
+    mvec[0] = new MachineInstr(ChooseMulInstruction(subtreeRoot, checkCast));
+    Set3OperandsFromInstr(mvec[0], subtreeRoot, ccontext.getTarget());
+    break;
+    
+  case 36:	// reg:   Div(reg, reg)
+    mvec[0] = new MachineInstr(ChooseDivInstruction(subtreeRoot));
+    Set3OperandsFromInstr(mvec[0], subtreeRoot, ccontext.getTarget());
+    break;
+    
+  case 37:	// reg:   Rem(reg, reg)
+    assert(0 && "REM instruction unimplemented for the SPARC.");
+    break;
+    
+  case 38:	// reg:   And(reg, reg)
+    mvec[0] = new MachineInstr(AND);
+    Set3OperandsFromInstr(mvec[0], subtreeRoot, ccontext.getTarget());
+    break;
+    
+  case 138:	// reg:   And(reg, not)
+    mvec[0] = new MachineInstr(ANDN);
+    Set3OperandsFromInstr(mvec[0], subtreeRoot, ccontext.getTarget());
+    break;
+    
+  case 39:	// reg:   Or(reg, reg)
+    mvec[0] = new MachineInstr(ORN);
+    Set3OperandsFromInstr(mvec[0], subtreeRoot, ccontext.getTarget());
+    break;
+    
+  case 139:	// reg:   Or(reg, not)
+    mvec[0] = new MachineInstr(ORN);
+    Set3OperandsFromInstr(mvec[0], subtreeRoot, ccontext.getTarget());
+    break;
+    
+  case 40:	// reg:   Xor(reg, reg)
+    mvec[0] = new MachineInstr(XOR);
+    Set3OperandsFromInstr(mvec[0], subtreeRoot, ccontext.getTarget());
+    break;
+    
+  case 140:	// reg:   Xor(reg, not)
+    mvec[0] = new MachineInstr(XNOR);
+    Set3OperandsFromInstr(mvec[0], subtreeRoot, ccontext.getTarget());
+    break;
+    
+  case 41:	// boolconst:   SetCC(reg, Constant)
+    // Check if this is an integer comparison, and
+    // there is a parent, and the parent decided to use
+    // a branch-on-integer-register instead of branch-on-condition-code.
+    // If so, the SUBcc instruction is not required.
+    // (However, we must still check for constants to be loaded from
+    // the constant pool so that such a load can be associated with
+    // this instruction.)
+    // 
+    // Otherwise this is just the same as case 7, so just fall through.
+    // 
+    if (subtreeRoot->leftChild()->getValue()->getType()->isIntegral() &&
+	subtreeRoot->parent() != NULL)
+      {
+	InstructionNode* parentNode = (InstructionNode*) subtreeRoot->parent();
+	assert(parentNode->getNodeType() == InstrTreeNode::NTInstructionNode);
+	const vector<MachineInstr*>&
+	  minstrVec = parentNode->getInstruction()->getMachineInstrVec();
+	MachineOpCode parentOpCode;
+	if (minstrVec.size() == 1 &&
+	    (parentOpCode = minstrVec[0]->getOpCode()) >= BRZ &&
+	    parentOpCode <= BRGEZ)
+	  {
+	    numInstr = 0;
+	    break;
+	  }
+      }
+    // ELSE FALL THROUGH
+    
+  case 42:	// bool:   SetCC(reg, reg):
+    if (subtreeRoot->leftChild()->getValue()->getType()->isIntegral())
+      {
+	// integer condition: destination should be %g0
+	mvec[0] = new MachineInstr(SUBcc);
+	Set3OperandsFromInstr(mvec[0], subtreeRoot, ccontext.getTarget(),
+			      /*canDiscardResult*/ true);
+      }
+    else
+      {
+	// FP condition: dest should be a FCCn register chosen by reg-alloc
+	mvec[0] = new MachineInstr(ChooseFcmpInstruction(subtreeRoot));
+	
+	leftVal = subtreeRoot->leftChild()->getValue();
+	rightVal = subtreeRoot->rightChild()->getValue();
+	mvec[0]->SetMachineOperand(0, MachineOperand::MO_CCRegister,
+				     subtreeRoot->getValue());
+	mvec[0]->SetMachineOperand(1, MachineOperand::MO_Register, leftVal);
+	mvec[0]->SetMachineOperand(2, MachineOperand::MO_Register, rightVal);
+      }
+    break;
+    
+  case 43:	// boolreg: VReg
+    numInstr = 0;
+    break;
+
+  case 51:	// reg:   Load(reg)
+  case 52:	// reg:   Load(ptrreg)
+  case 53:	// reg:   LoadIdx(reg,reg)
+  case 54:	// reg:   LoadIdx(ptrreg,reg)
+    mvec[0] = new MachineInstr(ChooseLoadInstruction(subtreeRoot->getValue()->getType()));
+    SetOperandsForMemInstr(mvec[0], subtreeRoot, ccontext.getTarget());
+    break;
+    
+  case 55:	// reg:   GetElemPtr(reg)
+  case 56:	// reg:   GetElemPtrIdx(reg,reg)
+    if (subtreeRoot->parent() != NULL)
+      {
+	// Check if the parent was an array access.
+	// If so, we still need to generate this instruction.
+	MemAccessInst* memInst =(MemAccessInst*) subtreeRoot->getInstruction();
+	const PointerType* ptrType =
+	  (const PointerType*) memInst->getPtrOperand()->getType();
+	if (! ptrType->getValueType()->isArrayType())
+	  {// we don't need a separate instr
+	    numInstr = 0;
+	    break;
+	  }
+      }
+    // else in all other cases we need to a separate ADD instruction
+    mvec[0] = new MachineInstr(ADD);
+    SetOperandsForMemInstr(mvec[0], subtreeRoot, ccontext.getTarget());
+    break;
+    
+  case 57:	// reg:   Alloca: Implement as 2 instructions:
+    		//	sub %sp, tmp -> %sp
+    {		//	add %sp, 0   -> result
+    Instruction* instr = subtreeRoot->getInstruction();
+    const PointerType* instrType = (const PointerType*) instr->getType();
+    assert(instrType->isPointerType());
+    int tsize = (int) ccontext.getTarget().findOptimalStorageSize(
+						    instrType->getValueType());
+    if (tsize == 0)
+      {
+	numInstr = 0;
+	break;
+      }
+    //else go on to create the instructions needed...
+    
+    // Create a temporary Value to hold the constant type-size
+    ConstPoolSInt* valueForTSize = new ConstPoolSInt(Type::IntTy, tsize);
+    ConstantPool &cpool = instr->getParent()->getParent()->getConstantPool();
+    if (cpool.find(valueForTSize) == 0)
+      cpool.insert(valueForTSize);
+    
+    // Instruction 1: sub %sp, tsize -> %sp
+    // tsize is always constant, but it may have to be put into a
+    // register if it doesn't fit in the immediate field.
+    // 
+    mvec[0] = new MachineInstr(SUB);
+    mvec[0]->SetMachineOperand(0, /*regNum %sp = o6 = r[14]*/(unsigned int)14);
+    mvec[0]->SetMachineOperand(1, MachineOperand::MO_Register, valueForTSize);
+    mvec[0]->SetMachineOperand(2, /*regNum %sp = o6 = r[14]*/(unsigned int)14);
+    
+    // Instruction 2: add %sp, 0 -> result
+    numInstr++;
+    mvec[1] = new MachineInstr(ADD);
+    mvec[1]->SetMachineOperand(0, /*regNum %sp = o6 = r[14]*/(unsigned int)14);
+    mvec[1]->SetMachineOperand(1, /*regNum %g0*/ (unsigned int) 0);
+    mvec[1]->SetMachineOperand(2, MachineOperand::MO_Register, instr);
+    break;
+    }
+  
+  case 58:	// reg:   Alloca(reg): Implement as 3 instructions:
+    		//	mul num, typeSz -> tmp
+    		//	sub %sp, tmp    -> %sp
+    {		//	add %sp, 0      -> result
+    Instruction* instr = subtreeRoot->getInstruction();
+    const PointerType* instrType = (const PointerType*) instr->getType();
+    assert(instrType->isPointerType() &&
+	   instrType->getValueType()->isArrayType());
+    const Type* eltType =
+      ((ArrayType*) instrType->getValueType())->getElementType();
+    int tsize = (int) ccontext.getTarget().findOptimalStorageSize(eltType);
+    
+    if (tsize == 0)
+      {
+	numInstr = 0;
+	break;
+      }
+    //else go on to create the instructions needed...
+
+    // Create a temporary Value to hold the constant type-size
+    ConstPoolSInt* valueForTSize = new ConstPoolSInt(Type::IntTy, tsize);
+    ConstantPool &cpool = instr->getParent()->getParent()->getConstantPool();
+    if (cpool.find(valueForTSize) == 0)
+      cpool.insert(valueForTSize);
+    
+    // Create a temporary value to hold `tmp'
+    Instruction* tmpInstr = new TmpInstruction(Instruction::UserOp1,
+					  subtreeRoot->leftChild()->getValue(),
+					  NULL /*could insert tsize here*/);
+    subtreeRoot->getInstruction()->getMachineInstrVec().addTempValue(tmpInstr);
+
+    // Instruction 1: mul numElements, typeSize -> tmp
+    mvec[0] = new MachineInstr(MULX);
+    mvec[0]->SetMachineOperand(0, MachineOperand::MO_Register,
+				subtreeRoot->leftChild()->getValue());
+    mvec[0]->SetMachineOperand(1, MachineOperand::MO_Register, valueForTSize);
+    mvec[0]->SetMachineOperand(2, MachineOperand::MO_Register, tmpInstr);
+
+    // Instruction 2: sub %sp, tmp -> %sp
+    numInstr++;
+    mvec[1] = new MachineInstr(SUB);
+    mvec[1]->SetMachineOperand(0, /*regNum %sp = o6 = r[14]*/(unsigned int)14);
+    mvec[1]->SetMachineOperand(1, MachineOperand::MO_Register, tmpInstr);
+    mvec[1]->SetMachineOperand(2, /*regNum %sp = o6 = r[14]*/(unsigned int)14);
+    
+    // Instruction 3: add %sp, 0 -> result
+    numInstr++;
+    mvec[2] = new MachineInstr(ADD);
+    mvec[2]->SetMachineOperand(0, /*regNum %sp = o6 = r[14]*/(unsigned int)14);
+    mvec[2]->SetMachineOperand(1, /*regNum %g0*/ (unsigned int) 0);
+    mvec[2]->SetMachineOperand(2, MachineOperand::MO_Register, instr);
+    break;
+    }
+    
+  case 61:	// reg:   Call
+		// Generate a call-indirect (i.e., JMPL) for now to expose
+		// the potential need for registers.  If an absolute address
+		// is available, replace this with a CALL instruction.
+		// Mark both the indirection register and the return-address
+    {		// register as hidden virtual registers.
+      
+    Instruction* targetReg = new TmpInstruction(Instruction::UserOp1,
+	((CallInst*) subtreeRoot->getInstruction())->getCalledMethod(), NULL);
+    Instruction* returnReg = new TmpInstruction(Instruction::UserOp1,
+						subtreeRoot->getValue(), NULL);
+    subtreeRoot->getInstruction()->getMachineInstrVec().addTempValue(targetReg);
+    subtreeRoot->getInstruction()->getMachineInstrVec().addTempValue(returnReg);
+    
+    mvec[0] = new MachineInstr(JMPL);
+    mvec[0]->SetMachineOperand(0, MachineOperand::MO_Register, targetReg);
+    mvec[0]->SetMachineOperand(1, MachineOperand::MO_SignExtendedImmed,
+			          (int64_t) 0);
+    mvec[0]->SetMachineOperand(2, MachineOperand::MO_Register, returnReg);
+    
+    mvec[numInstr++] = new MachineInstr(NOP); // delay slot
+    break;
+    }
+    
+  case 62:	// reg:   Shl(reg, reg)
+    opType = subtreeRoot->leftChild()->getValue()->getType();
+    assert(opType->isIntegral() || opType == Type::BoolTy); 
+    mvec[0] = new MachineInstr((opType == Type::LongTy)? SLLX : SLL);
+    Set3OperandsFromInstr(mvec[0], subtreeRoot, ccontext.getTarget());
+    break;
+    
+  case 63:	// reg:   Shr(reg, reg)
+    opType = subtreeRoot->leftChild()->getValue()->getType();
+    assert(opType->isIntegral() || opType == Type::BoolTy); 
+