--with-udis86

default
hidden
define
declare
declare
constructor
destructor
deprecated
fastcall
format
format_arg
non_null
noreturn
stdcall
unused
used
warn_unused_result
weak
section
stdcall
unused
used
visibility
warn_unused_result
weak
noinline
always_inline
pure
const
nothrow
malloc
no_instrument_function
cdecl
section
alias
visibility
regparm
alias
regparm
cleanup
common
nocommon
deprecated
dllimport
dllexport
transparent_union
unused
used
weak
deprecated
dllimport
dllexport
section
transparent_union
unused
used
weak
aligned
mode
packed
section
shared
tls_model
vector_size
shared
tls_model
vector_size
CallGraphSCCPass
doInitialization(Module
+        
The doInitialization(CallGraph
                                            &) method

         The runOnSCC method
-        The doFinalization(Module
+        
The doFinalization(CallGraph
                                            &) method

         

      The FunctionPass class
@@ -534,14 +534,14 @@
 
 
 
-  The doInitialization(Module &)
+  The doInitialization(CallGraph &)
   method
 
 
 
 
 -  virtual bool doInitialization(Module &M);
+  virtual bool doInitialization(CallGraph &CG);
 
 
 The doIninitialize method is allowed to do most of the things that
@@ -573,14 +573,14 @@
 
 
 

-  The doFinalization(Module
+  The doFinalization(CallGraph
    &) method
 

 
 
 
 -  virtual bool doFinalization(Module &M);
+  virtual bool doFinalization(CallGraph &CG);
 
 
 The doFinalization method is an infrequently used method that is
@@ -1711,7 +1711,7 @@
 
   Chris Lattner

   The LLVM Compiler Infrastructure

-  Last modified: $Date: 2006/12/07 20:04:41 $
+  Last modified: $Date: 2007/01/23 22:56:28 $
 
 
 





From evan.cheng at apple.com  Tue Jan 23 16:59:29 2007
From: evan.cheng at apple.com (Evan Cheng)
Date: Tue, 23 Jan 2007 16:59:29 -0600
Subject: [llvm-commits] CVS: llvm/lib/Target/ARM/ARMAsmPrinter.cpp
	ARMISelDAGToDAG.cpp ARMInstrThumb.td
Message-ID: <200701232259.l0NMxTf5023535@zion.cs.uiuc.edu>



Changes in directory llvm/lib/Target/ARM:

ARMAsmPrinter.cpp updated: 1.45 -> 1.46
ARMISelDAGToDAG.cpp updated: 1.99 -> 1.100
ARMInstrThumb.td updated: 1.1 -> 1.2
---
Log message:

- Reorg Thumb load / store instructions. Combine each rr and ri pair of 
  instructions into one (e.g. tLDRrr, tLDRri -> tLDR).
- Thumb ldrsb and ldrsh only have the [reg, reg] address format. If the
  address is not an add, materialize a 0 immediate into a register and use
  it as the offset field.


---
Diffs of the changes:  (+118 -110)

 ARMAsmPrinter.cpp   |   29 +++++++----
 ARMISelDAGToDAG.cpp |   67 ++++++++++++++++----------
 ARMInstrThumb.td    |  132 ++++++++++++++++++++++------------------------------
 3 files changed, 118 insertions(+), 110 deletions(-)


Index: llvm/lib/Target/ARM/ARMAsmPrinter.cpp
diff -u llvm/lib/Target/ARM/ARMAsmPrinter.cpp:1.45 llvm/lib/Target/ARM/ARMAsmPrinter.cpp:1.46

--- llvm/lib/Target/ARM/ARMAsmPrinter.cpp:1.45	Fri Jan 19 13:25:36 2007
+++ llvm/lib/Target/ARM/ARMAsmPrinter.cpp	Tue Jan 23 16:59:13 2007
@@ -98,9 +98,9 @@
     void printThumbAddrModeRROperand(const MachineInstr *MI, int OpNo);
     void printThumbAddrModeRI5Operand(const MachineInstr *MI, int OpNo,
                                       unsigned Scale);
-    void printThumbAddrModeRI5_1Operand(const MachineInstr *MI, int OpNo);
-    void printThumbAddrModeRI5_2Operand(const MachineInstr *MI, int OpNo);
-    void printThumbAddrModeRI5_4Operand(const MachineInstr *MI, int OpNo);
+    void printThumbAddrModeS1Operand(const MachineInstr *MI, int OpNo);
+    void printThumbAddrModeS2Operand(const MachineInstr *MI, int OpNo);
+    void printThumbAddrModeS4Operand(const MachineInstr *MI, int OpNo);
     void printThumbAddrModeSPOperand(const MachineInstr *MI, int OpNo);
     void printCCOperand(const MachineInstr *MI, int opNum);
     void printPCLabel(const MachineInstr *MI, int opNum);
@@ -518,7 +518,7 @@
 ARMAsmPrinter::printThumbAddrModeRI5Operand(const MachineInstr *MI, int Op,
                                             unsigned Scale) {
   const MachineOperand &MO1 = MI->getOperand(Op);
-  const MachineOperand &MO2 = MI->getOperand(Op+1);
+  const MachineOperand &MO2 = MI->getOperand(Op+2);
 
   if (!MO1.isRegister()) {   // FIXME: This is for CP entries, but isn't right.
     printOperand(MI, Op);
@@ -535,16 +535,25 @@
 }
 
 void
-ARMAsmPrinter::printThumbAddrModeRI5_1Operand(const MachineInstr *MI, int Op) {
-  printThumbAddrModeRI5Operand(MI, Op, 1);
+ARMAsmPrinter::printThumbAddrModeS1Operand(const MachineInstr *MI, int Op) {
+  if (MI->getOperand(Op+1).getReg())
+    printThumbAddrModeRROperand(MI, Op);
+  else
+    printThumbAddrModeRI5Operand(MI, Op, 1);
 }
 void
-ARMAsmPrinter::printThumbAddrModeRI5_2Operand(const MachineInstr *MI, int Op) {
-  printThumbAddrModeRI5Operand(MI, Op, 2);
+ARMAsmPrinter::printThumbAddrModeS2Operand(const MachineInstr *MI, int Op) {
+  if (MI->getOperand(Op+1).getReg())
+    printThumbAddrModeRROperand(MI, Op);
+  else
+    printThumbAddrModeRI5Operand(MI, Op, 2);
 }
 void
-ARMAsmPrinter::printThumbAddrModeRI5_4Operand(const MachineInstr *MI, int Op) {
-  printThumbAddrModeRI5Operand(MI, Op, 4);
+ARMAsmPrinter::printThumbAddrModeS4Operand(const MachineInstr *MI, int Op) {
+  if (MI->getOperand(Op+1).getReg())
+    printThumbAddrModeRROperand(MI, Op);
+  else
+    printThumbAddrModeRI5Operand(MI, Op, 4);
 }
 
 void ARMAsmPrinter::printThumbAddrModeSPOperand(const MachineInstr *MI,int Op) {


Index: llvm/lib/Target/ARM/ARMISelDAGToDAG.cpp
diff -u llvm/lib/Target/ARM/ARMISelDAGToDAG.cpp:1.99 llvm/lib/Target/ARM/ARMISelDAGToDAG.cpp:1.100
--- llvm/lib/Target/ARM/ARMISelDAGToDAG.cpp:1.99	Fri Jan 19 01:51:42 2007
+++ llvm/lib/Target/ARM/ARMISelDAGToDAG.cpp	Tue Jan 23 16:59:13 2007
@@ -71,12 +71,12 @@
 
   bool SelectThumbAddrModeRR(SDOperand Op, SDOperand N, SDOperand &Base,
                              SDOperand &Offset);
-  bool SelectThumbAddrModeRI5_1(SDOperand Op, SDOperand N, SDOperand &Base,
-                                SDOperand &Offset);
-  bool SelectThumbAddrModeRI5_2(SDOperand Op, SDOperand N, SDOperand &Base,
-                                SDOperand &Offset);
-  bool SelectThumbAddrModeRI5_4(SDOperand Op, SDOperand N, SDOperand &Base,
-                                SDOperand &Offset);
+  bool SelectThumbAddrModeS1(SDOperand Op, SDOperand N, SDOperand &Base,
+                             SDOperand &Offset, SDOperand &OffImm);
+  bool SelectThumbAddrModeS2(SDOperand Op, SDOperand N, SDOperand &Base,
+                             SDOperand &Offset, SDOperand &OffImm);
+  bool SelectThumbAddrModeS4(SDOperand Op, SDOperand N, SDOperand &Base,
+                             SDOperand &Offset, SDOperand &OffImm);
   bool SelectThumbAddrModeSP(SDOperand Op, SDOperand N, SDOperand &Base,
                              SDOperand &Offset);
 
@@ -340,8 +340,16 @@
 
 bool ARMDAGToDAGISel::SelectThumbAddrModeRR(SDOperand Op, SDOperand N,
                                             SDOperand &Base, SDOperand &Offset){
-  if (N.getOpcode() != ISD::ADD)
-    return false;
+  if (N.getOpcode() != ISD::ADD) {
+    Base = N;
+    // We must materialize a zero in a reg! Returning an constant here won't
+    // work since its node is -1 so it won't get added to the selection queue.
+    // Explicitly issue a tMOVri8 node!
+    Offset = SDOperand(CurDAG->getTargetNode(ARM::tMOVri8, MVT::i32,
+                                    CurDAG->getTargetConstant(0, MVT::i32)), 0);
+    return true;
+  }
+
   Base = N.getOperand(0);
   Offset = N.getOperand(1);
   return true;
@@ -349,13 +357,15 @@
 
 static bool SelectThumbAddrModeRI5(SDOperand N, unsigned Scale,
                                    TargetLowering &TLI, SelectionDAG *CurDAG,
-                                   SDOperand &Base, SDOperand &Offset) {
+                                   SDOperand &Base, SDOperand &Offset,
+                                   SDOperand &OffImm) {
   if (N.getOpcode() == ISD::FrameIndex)
     return false;
     
   if (N.getOpcode() != ISD::ADD) {
     Base = (N.getOpcode() == ARMISD::Wrapper) ? N.getOperand(0) : N;
-    Offset = CurDAG->getTargetConstant(0, MVT::i32);
+    Offset = CurDAG->getRegister(0, MVT::i32);
+    OffImm = CurDAG->getTargetConstant(0, MVT::i32);
     return true;
   }
 
@@ -366,28 +376,35 @@
       RHSC /= Scale;
       if (RHSC >= 0 && RHSC < 32) {
         Base = N.getOperand(0);
-        Offset = CurDAG->getTargetConstant(RHSC, MVT::i32);
+        Offset = CurDAG->getRegister(0, MVT::i32);
+        OffImm = CurDAG->getTargetConstant(RHSC, MVT::i32);
         return true;
       }
     }
   }
 
-  return false;
-}
-
-bool ARMDAGToDAGISel::SelectThumbAddrModeRI5_1(SDOperand Op, SDOperand N,
-                                            SDOperand &Base, SDOperand &Offset){
-  return SelectThumbAddrModeRI5(N, 1, TLI, CurDAG, Base, Offset);
-}
-
-bool ARMDAGToDAGISel::SelectThumbAddrModeRI5_2(SDOperand Op, SDOperand N,
-                                            SDOperand &Base, SDOperand &Offset){
-  return SelectThumbAddrModeRI5(N, 2, TLI, CurDAG, Base, Offset);
+  Base = N.getOperand(0);
+  Offset = N.getOperand(1);
+  OffImm = CurDAG->getTargetConstant(0, MVT::i32);
+  return true;
 }
 
-bool ARMDAGToDAGISel::SelectThumbAddrModeRI5_4(SDOperand Op, SDOperand N,
-                                            SDOperand &Base, SDOperand &Offset){
-  return SelectThumbAddrModeRI5(N, 4, TLI, CurDAG, Base, Offset);
+bool ARMDAGToDAGISel::SelectThumbAddrModeS1(SDOperand Op, SDOperand N,
+                                            SDOperand &Base, SDOperand &Offset,
+                                            SDOperand &OffImm) {
+  return SelectThumbAddrModeRI5(N, 1, TLI, CurDAG, Base, Offset, OffImm);
+}
+
+bool ARMDAGToDAGISel::SelectThumbAddrModeS2(SDOperand Op, SDOperand N,
+                                            SDOperand &Base, SDOperand &Offset,
+                                            SDOperand &OffImm) {
+  return SelectThumbAddrModeRI5(N, 2, TLI, CurDAG, Base, Offset, OffImm);
+}
+
+bool ARMDAGToDAGISel::SelectThumbAddrModeS4(SDOperand Op, SDOperand N,
+                                            SDOperand &Base, SDOperand &Offset,
+                                            SDOperand &OffImm) {
+  return SelectThumbAddrModeRI5(N, 4, TLI, CurDAG, Base, Offset, OffImm);
 }
 
 bool ARMDAGToDAGISel::SelectThumbAddrModeSP(SDOperand Op, SDOperand N,


Index: llvm/lib/Target/ARM/ARMInstrThumb.td
diff -u llvm/lib/Target/ARM/ARMInstrThumb.td:1.1 llvm/lib/Target/ARM/ARMInstrThumb.td:1.2
--- llvm/lib/Target/ARM/ARMInstrThumb.td:1.1	Fri Jan 19 01:51:42 2007
+++ llvm/lib/Target/ARM/ARMInstrThumb.td	Tue Jan 23 16:59:13 2007
@@ -114,22 +114,31 @@
   let MIOperandInfo = (ops GPR:$base, GPR:$offsreg);
 }
 
-// t_addrmode_ri5_{1|2|4} := reg + imm5 * {1|2|4}
+// t_addrmode_s4 := reg + reg
+//                  reg + imm5 * 4
 //
-def t_addrmode_ri5_1 : Operand,
-                       ComplexPattern {
-  let PrintMethod = "printThumbAddrModeRI5_1Operand";
-  let MIOperandInfo = (ops GPR:$base, i32imm:$offsimm);
+def t_addrmode_s4 : Operand,
+                    ComplexPattern {
+  let PrintMethod = "printThumbAddrModeS4Operand";
+  let MIOperandInfo = (ops GPR:$base, GPR:$offsreg, i32imm:$offsimm);
 }
-def t_addrmode_ri5_2 : Operand,
-                       ComplexPattern {
-  let PrintMethod = "printThumbAddrModeRI5_2Operand";
-  let MIOperandInfo = (ops GPR:$base, i32imm:$offsimm);
+
+// t_addrmode_s2 := reg + reg
+//                  reg + imm5 * 2
+//
+def t_addrmode_s2 : Operand,
+                    ComplexPattern {
+  let PrintMethod = "printThumbAddrModeS2Operand";
+  let MIOperandInfo = (ops GPR:$base, GPR:$offsreg, i32imm:$offsimm);
 }
-def t_addrmode_ri5_4 : Operand,
-                       ComplexPattern {
-  let PrintMethod = "printThumbAddrModeRI5_4Operand";
-  let MIOperandInfo = (ops GPR:$base, i32imm:$offsimm);
+
+// t_addrmode_s1 := reg + reg
+//                  reg + imm5
+//
+def t_addrmode_s1 : Operand,
+                    ComplexPattern {
+  let PrintMethod = "printThumbAddrModeS1Operand";
+  let MIOperandInfo = (ops GPR:$base, GPR:$offsreg, i32imm:$offsimm);
 }
 
 // t_addrmode_sp := sp + imm8 * 4
@@ -191,71 +200,48 @@
 //
 
 let isLoad = 1 in {
-def tLDRri : TI4<(ops GPR:$dst, t_addrmode_ri5_4:$addr),
-                 "ldr $dst, $addr",
-                 [(set GPR:$dst, (load t_addrmode_ri5_4:$addr))]>;
-
-def tLDRrr : TI<(ops GPR:$dst, t_addrmode_rr:$addr),
-                "ldr $dst, $addr",
-                [(set GPR:$dst, (load t_addrmode_rr:$addr))]>;
+def tLDR : TI4<(ops GPR:$dst, t_addrmode_s4:$addr),
+               "ldr $dst, $addr",
+               [(set GPR:$dst, (load t_addrmode_s4:$addr))]>;
+
+def tLDRB : TI1<(ops GPR:$dst, t_addrmode_s1:$addr),
+                "ldrb $dst, $addr",
+                [(set GPR:$dst, (zextloadi8 t_addrmode_s1:$addr))]>;
+
+def tLDRH : TI2<(ops GPR:$dst, t_addrmode_s2:$addr),
+                "ldrh $dst, $addr",
+                [(set GPR:$dst, (zextloadi16 t_addrmode_s2:$addr))]>;
+
+def tLDRSB : TI1<(ops GPR:$dst, t_addrmode_rr:$addr),
+                 "ldrsb $dst, $addr",
+                 [(set GPR:$dst, (sextloadi8 t_addrmode_rr:$addr))]>;
+
+def tLDRSH : TI2<(ops GPR:$dst, t_addrmode_rr:$addr),
+                 "ldrsh $dst, $addr",
+                 [(set GPR:$dst, (sextloadi16 t_addrmode_rr:$addr))]>;
+
 // def tLDRpci
 def tLDRspi : TIs<(ops GPR:$dst, t_addrmode_sp:$addr),
                   "ldr $dst, $addr",
                   [(set GPR:$dst, (load t_addrmode_sp:$addr))]>;
-
-def tLDRBri : TI1<(ops GPR:$dst, t_addrmode_ri5_1:$addr),
-                  "ldrb $dst, $addr",
-                  [(set GPR:$dst, (zextloadi8 t_addrmode_ri5_1:$addr))]>;
-
-def tLDRBrr : TI1<(ops GPR:$dst, t_addrmode_rr:$addr),
-                  "ldrb $dst, $addr",
-                  [(set GPR:$dst, (zextloadi8 t_addrmode_rr:$addr))]>;
-
-def tLDRHri : TI2<(ops GPR:$dst, t_addrmode_ri5_2:$addr),
-                  "ldrh $dst, $addr",
-                  [(set GPR:$dst, (zextloadi16 t_addrmode_ri5_2:$addr))]>;
-
-def tLDRHrr : TI2<(ops GPR:$dst, t_addrmode_rr:$addr),
-                  "ldrh $dst, $addr",
-                  [(set GPR:$dst, (zextloadi16 t_addrmode_rr:$addr))]>;
-
-def tLDRSBrr : TI1<(ops GPR:$dst, t_addrmode_rr:$addr),
-                   "ldrsb $dst, $addr",
-                   [(set GPR:$dst, (sextloadi8 t_addrmode_rr:$addr))]>;
-
-def tLDRSHrr : TI2<(ops GPR:$dst, t_addrmode_rr:$addr),
-                   "ldrsh $dst, $addr",
-                   [(set GPR:$dst, (sextloadi16 t_addrmode_rr:$addr))]>;
 } // isLoad
 
 let isStore = 1 in {
-def tSTRri : TI4<(ops GPR:$src, t_addrmode_ri5_4:$addr),
-                 "str $src, $addr",
-                 [(store GPR:$src, t_addrmode_ri5_4:$addr)]>;
-
-def tSTRrr : TI<(ops GPR:$src, t_addrmode_rr:$addr),
-                 "str $src, $addr",
-                 [(store GPR:$src, t_addrmode_rr:$addr)]>;
+def tSTR : TI4<(ops GPR:$src, t_addrmode_s4:$addr),
+               "str $src, $addr",
+               [(store GPR:$src, t_addrmode_s4:$addr)]>;
+
+def tSTRB : TI1<(ops GPR:$src, t_addrmode_s1:$addr),
+                 "strb $src, $addr",
+                 [(truncstorei8 GPR:$src, t_addrmode_s1:$addr)]>;
+
+def tSTRH : TI2<(ops GPR:$src, t_addrmode_s2:$addr),
+                 "strh $src, $addr",
+                 [(truncstorei16 GPR:$src, t_addrmode_s2:$addr)]>;
 
 def tSTRspi : TIs<(ops GPR:$src, t_addrmode_sp:$addr),
                    "str $src, $addr",
                    [(store GPR:$src, t_addrmode_sp:$addr)]>;
-
-def tSTRBri : TI1<(ops GPR:$src, t_addrmode_ri5_1:$addr),
-                   "strb $src, $addr",
-                   [(truncstorei8 GPR:$src, t_addrmode_ri5_1:$addr)]>;
-
-def tSTRBrr : TI1<(ops GPR:$src, t_addrmode_rr:$addr),
-                   "strb $src, $addr",
-                   [(truncstorei8 GPR:$src, t_addrmode_rr:$addr)]>;
-
-def tSTRHri : TI2<(ops GPR:$src, t_addrmode_ri5_2:$addr),
-                   "strh $src, $addr",
-                   [(truncstorei16 GPR:$src, t_addrmode_ri5_1:$addr)]>;
-
-def tSTRHrr : TI2<(ops GPR:$src, t_addrmode_rr:$addr),
-                   "strh $src, $addr",
-                   [(truncstorei16 GPR:$src, t_addrmode_rr:$addr)]>;
 }
 
 //===----------------------------------------------------------------------===//
@@ -491,16 +477,12 @@
 def : ThumbV5Pat<(ARMcall GPR:$dst), (tBLXr GPR:$dst)>;
 
 // zextload i1 -> zextload i8
-def : ThumbPat<(zextloadi1 t_addrmode_ri5_1:$addr),
-               (tLDRBri t_addrmode_ri5_1:$addr)>;
-def : ThumbPat<(zextloadi1 t_addrmode_rr:$addr),
-               (tLDRBri t_addrmode_rr:$addr)>;
+def : ThumbPat<(zextloadi1 t_addrmode_s1:$addr),
+               (tLDRB t_addrmode_s1:$addr)>;
                   
 // truncstore i1 -> truncstore i8
-def : ThumbPat<(truncstorei1 GPR:$src, t_addrmode_ri5_1:$dst), 
-               (tSTRBri GPR:$src, t_addrmode_ri5_1:$dst)>;
-def : ThumbPat<(truncstorei1 GPR:$src, t_addrmode_rr:$dst), 
-               (tSTRBrr GPR:$src, t_addrmode_rr:$dst)>;
+def : ThumbPat<(truncstorei1 GPR:$src, t_addrmode_s1:$dst), 
+               (tSTRB GPR:$src, t_addrmode_s1:$dst)>;
 
 // Large immediate handling.
 





From evan.cheng at apple.com  Tue Jan 23 17:29:05 2007
From: evan.cheng at apple.com (Evan Cheng)
Date: Tue, 23 Jan 2007 17:29:05 -0600
Subject: [llvm-commits] CVS: llvm/test/CodeGen/ARM/mul.ll
Message-ID: <200701232329.l0NNT5Tf024099@zion.cs.uiuc.edu>



Changes in directory llvm/test/CodeGen/ARM:

mul.ll updated: 1.3 -> 1.4
---
Log message:

Thumb test cases.

---
Diffs of the changes:  (+21 -10)

 mul.ll |   31 +++++++++++++++++++++----------
 1 files changed, 21 insertions(+), 10 deletions(-)


Index: llvm/test/CodeGen/ARM/mul.ll
diff -u llvm/test/CodeGen/ARM/mul.ll:1.3 llvm/test/CodeGen/ARM/mul.ll:1.4
--- llvm/test/CodeGen/ARM/mul.ll:1.3	Fri Jan 19 03:20:23 2007
+++ llvm/test/CodeGen/ARM/mul.ll	Tue Jan 23 17:28:50 2007
@@ -1,14 +1,25 @@
-; RUN: llvm-upgrade < %s | llvm-as | llc -march=arm &&
-; RUN: llvm-upgrade < %s | llvm-as | llc -march=arm | grep mul | wc -l | grep 2
+; RUN: llvm-as < %s | llc -march=arm &&
+; RUN: llvm-as < %s | llc -march=arm | grep mul | wc -l | grep 2 &&
+; RUN: llvm-as < %s | llc -march=arm | grep lsl | wc -l | grep 2 &&
+; RUN: llvm-as < %s | llc -march=arm -enable-thumb | grep mul | wc -l | grep 3 &&
+; RUN: llvm-as < %s | llc -march=arm -enable-thumb | grep lsl | wc -l | grep 1
 
-int %f1(int %u) {
-entry:
-	%tmp = mul int %u, %u;
-	ret int %tmp
+define i32 %f1(i32 %u) {
+    %tmp = mul i32 %u, %u
+    ret i32 %tmp
 }
 
-int %f2(int %u, int %v) {
-entry:
-	%tmp = mul int %u, %v;
-	ret int %tmp
+define i32 %f2(i32 %u, i32 %v) {
+    %tmp = mul i32 %u, %v
+    ret i32 %tmp
+}
+
+define i32 %f3(i32 %u) {
+	%tmp = mul i32 %u, 5
+        ret i32 %tmp
+}
+
+define i32 %f4(i32 %u) {
+	%tmp = mul i32 %u, 4
+        ret i32 %tmp
 }





From evan.cheng at apple.com  Tue Jan 23 20:21:37 2007
From: evan.cheng at apple.com (Evan Cheng)
Date: Tue, 23 Jan 2007 20:21:37 -0600
Subject: [llvm-commits] CVS: llvm/lib/Target/ARM/ARMISelDAGToDAG.cpp
Message-ID: <200701240221.l0O2Lb4x027033@zion.cs.uiuc.edu>



Changes in directory llvm/lib/Target/ARM:

ARMISelDAGToDAG.cpp updated: 1.100 -> 1.101
---
Log message:

Various Thumb mode load / store isel bug fixes.

---
Diffs of the changes:  (+38 -13)

 ARMISelDAGToDAG.cpp |   51 ++++++++++++++++++++++++++++++++++++++-------------
 1 files changed, 38 insertions(+), 13 deletions(-)


Index: llvm/lib/Target/ARM/ARMISelDAGToDAG.cpp
diff -u llvm/lib/Target/ARM/ARMISelDAGToDAG.cpp:1.100 llvm/lib/Target/ARM/ARMISelDAGToDAG.cpp:1.101
--- llvm/lib/Target/ARM/ARMISelDAGToDAG.cpp:1.100	Tue Jan 23 16:59:13 2007
+++ llvm/lib/Target/ARM/ARMISelDAGToDAG.cpp	Tue Jan 23 20:21:22 2007
@@ -71,6 +71,9 @@
 
   bool SelectThumbAddrModeRR(SDOperand Op, SDOperand N, SDOperand &Base,
                              SDOperand &Offset);
+  bool SelectThumbAddrModeRI5(SDOperand Op, SDOperand N, unsigned Scale,
+                              SDOperand &Base, SDOperand &Offset,
+                              SDOperand &OffImm);
   bool SelectThumbAddrModeS1(SDOperand Op, SDOperand N, SDOperand &Base,
                              SDOperand &Offset, SDOperand &OffImm);
   bool SelectThumbAddrModeS2(SDOperand Op, SDOperand N, SDOperand &Base,
@@ -78,7 +81,7 @@
   bool SelectThumbAddrModeS4(SDOperand Op, SDOperand N, SDOperand &Base,
                              SDOperand &Offset, SDOperand &OffImm);
   bool SelectThumbAddrModeSP(SDOperand Op, SDOperand N, SDOperand &Base,
-                             SDOperand &Offset);
+                             SDOperand &OffImm);
 
   bool SelectShifterOperandReg(SDOperand Op, SDOperand N, SDOperand &A,
                                SDOperand &B, SDOperand &C);
@@ -355,13 +358,16 @@
   return true;
 }
 
-static bool SelectThumbAddrModeRI5(SDOperand N, unsigned Scale,
-                                   TargetLowering &TLI, SelectionDAG *CurDAG,
-                                   SDOperand &Base, SDOperand &Offset,
-                                   SDOperand &OffImm) {
-  if (N.getOpcode() == ISD::FrameIndex)
-    return false;
-    
+bool
+ARMDAGToDAGISel::SelectThumbAddrModeRI5(SDOperand Op, SDOperand N,
+                                        unsigned Scale, SDOperand &Base,
+                                        SDOperand &Offset, SDOperand &OffImm) {
+  if (Scale == 4) {
+    SDOperand TmpBase, TmpOffImm;
+    if (SelectThumbAddrModeSP(Op, N, TmpBase, TmpOffImm))
+      return false;  // We want to select tLDRspi / tSTRspi instead.
+  }
+
   if (N.getOpcode() != ISD::ADD) {
     Base = (N.getOpcode() == ARMISD::Wrapper) ? N.getOperand(0) : N;
     Offset = CurDAG->getRegister(0, MVT::i32);
@@ -392,29 +398,46 @@
 bool ARMDAGToDAGISel::SelectThumbAddrModeS1(SDOperand Op, SDOperand N,
                                             SDOperand &Base, SDOperand &Offset,
                                             SDOperand &OffImm) {
-  return SelectThumbAddrModeRI5(N, 1, TLI, CurDAG, Base, Offset, OffImm);
+  return SelectThumbAddrModeRI5(Op, N, 1, Base, Offset, OffImm);
 }
 
 bool ARMDAGToDAGISel::SelectThumbAddrModeS2(SDOperand Op, SDOperand N,
                                             SDOperand &Base, SDOperand &Offset,
                                             SDOperand &OffImm) {
-  return SelectThumbAddrModeRI5(N, 2, TLI, CurDAG, Base, Offset, OffImm);
+  return SelectThumbAddrModeRI5(Op, N, 2, Base, Offset, OffImm);
 }
 
 bool ARMDAGToDAGISel::SelectThumbAddrModeS4(SDOperand Op, SDOperand N,
                                             SDOperand &Base, SDOperand &Offset,
                                             SDOperand &OffImm) {
-  return SelectThumbAddrModeRI5(N, 4, TLI, CurDAG, Base, Offset, OffImm);
+  return SelectThumbAddrModeRI5(Op, N, 4, Base, Offset, OffImm);
 }
 
 bool ARMDAGToDAGISel::SelectThumbAddrModeSP(SDOperand Op, SDOperand N,
-                                           SDOperand &Base, SDOperand &Offset) {
+                                           SDOperand &Base, SDOperand &OffImm) {
   if (N.getOpcode() == ISD::FrameIndex) {
     int FI = cast(N)->getIndex();
     Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
-    Offset = CurDAG->getTargetConstant(0, MVT::i32);
+    OffImm = CurDAG->getTargetConstant(0, MVT::i32);
     return true;
   }
+
+  if (N.getOpcode() == ISD::ADD &&
+      N.getOperand(0).getOpcode() == ISD::FrameIndex) {
+    // If the RHS is + imm8 * scale, fold into addr mode.
+    if (ConstantSDNode *RHS = dyn_cast(N.getOperand(1))) {
+      int RHSC = (int)RHS->getValue();
+      if ((RHSC & 3) == 0) {  // The constant is implicitly multiplied.
+        RHSC >>= 2;
+        if (RHSC >= 0 && RHSC < 256) {
+          int FI = cast(N.getOperand(0))->getIndex();
+          Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
+          OffImm = CurDAG->getTargetConstant(RHSC, MVT::i32);
+          return true;
+        }
+      }
+    }
+  }
   
   return false;
 }
@@ -492,6 +515,8 @@
                                 CurDAG->getTargetConstant(0, MVT::i32));
   }
   case ISD::MUL:
+    if (Subtarget->isThumb())
+      break;
     if (ConstantSDNode *C = dyn_cast(Op.getOperand(1))) {
       unsigned RHSV = C->getValue();
       if (!RHSV) break;





From evan.cheng at apple.com  Tue Jan 23 20:27:18 2007
From: evan.cheng at apple.com (Evan Cheng)
Date: Tue, 23 Jan 2007 20:27:18 -0600
Subject: [llvm-commits] CVS: llvm/test/CodeGen/ARM/ldr_frame.ll
Message-ID: <200701240227.l0O2RIj5027136@zion.cs.uiuc.edu>



Changes in directory llvm/test/CodeGen/ARM:

ldr_frame.ll added (r1.1)
---
Log message:

Added some load from stack frames test cases.

---
Diffs of the changes:  (+34 -0)

 ldr_frame.ll |   34 ++++++++++++++++++++++++++++++++++
 1 files changed, 34 insertions(+)


Index: llvm/test/CodeGen/ARM/ldr_frame.ll
diff -c /dev/null llvm/test/CodeGen/ARM/ldr_frame.ll:1.1
*** /dev/null	Tue Jan 23 20:27:13 2007
--- llvm/test/CodeGen/ARM/ldr_frame.ll	Tue Jan 23 20:27:03 2007
***************
*** 0 ****
--- 1,34 ----
+ ; RUN: llvm-as < %s | llc -march=arm &&
+ ; RUN: llvm-as < %s | llc -march=arm | not grep mov &&
+ ; RUN: llvm-as < %s | llc -march=arm -enable-thumb &&
+ ; RUN: llvm-as < %s | llc -march=arm -enable-thumb | grep cpy | wc -l | grep 2
+ 
+ define i32 %f1() {
+ 	%buf = alloca [32 x i32], align 4
+ 	%tmp = getelementptr [32 x i32]* %buf, i32 0, i32 0
+ 	%tmp1 = load i32* %tmp
+ 	ret i32 %tmp1
+ }
+ 
+ define i32 %f2() {
+ 	%buf = alloca [32 x i8], align 4
+ 	%tmp = getelementptr [32 x i8]* %buf, i32 0, i32 0
+ 	%tmp1 = load i8* %tmp
+         %tmp2 = zext i8 %tmp1 to i32
+ 	ret i32 %tmp2
+ }
+ 
+ define i32 %f3() {
+ 	%buf = alloca [32 x i32], align 4
+ 	%tmp = getelementptr [32 x i32]* %buf, i32 0, i32 32
+ 	%tmp1 = load i32* %tmp
+ 	ret i32 %tmp1
+ }
+ 
+ define i32 %f4() {
+ 	%buf = alloca [32 x i8], align 4
+ 	%tmp = getelementptr [32 x i8]* %buf, i32 0, i32 2
+ 	%tmp1 = load i8* %tmp
+         %tmp2 = zext i8 %tmp1 to i32
+ 	ret i32 %tmp2
+ }





From evan.cheng at apple.com  Tue Jan 23 20:45:41 2007
From: evan.cheng at apple.com (Evan Cheng)
Date: Tue, 23 Jan 2007 20:45:41 -0600
Subject: [llvm-commits] CVS: llvm/lib/Target/ARM/ARMISelDAGToDAG.cpp
Message-ID: <200701240245.l0O2jfhu027444@zion.cs.uiuc.edu>



Changes in directory llvm/lib/Target/ARM:

ARMISelDAGToDAG.cpp updated: 1.101 -> 1.102
---
Log message:

Allow [ fi#c, imm ] as ARM load / store addresses.

---
Diffs of the changes:  (+39 -25)

 ARMISelDAGToDAG.cpp |   64 +++++++++++++++++++++++++++++++---------------------
 1 files changed, 39 insertions(+), 25 deletions(-)


Index: llvm/lib/Target/ARM/ARMISelDAGToDAG.cpp
diff -u llvm/lib/Target/ARM/ARMISelDAGToDAG.cpp:1.101 llvm/lib/Target/ARM/ARMISelDAGToDAG.cpp:1.102
--- llvm/lib/Target/ARM/ARMISelDAGToDAG.cpp:1.101	Tue Jan 23 20:21:22 2007
+++ llvm/lib/Target/ARM/ARMISelDAGToDAG.cpp	Tue Jan 23 20:45:25 2007
@@ -122,17 +122,21 @@
   if (N.getOpcode() == ISD::ADD)
     if (ConstantSDNode *RHS = dyn_cast(N.getOperand(1))) {
       int RHSC = (int)RHS->getValue();
-      if (RHSC >= 0 && RHSC < 0x1000) { // 12 bits.
-        Base = N.getOperand(0);
-        Offset = CurDAG->getRegister(0, MVT::i32);
-        Opc = CurDAG->getTargetConstant(ARM_AM::getAM2Opc(ARM_AM::add, RHSC,
-                                                          ARM_AM::no_shift),
-                                        MVT::i32);
-        return true;
-      } else if (RHSC < 0 && RHSC > -0x1000) {
+      if ((RHSC >= 0 && RHSC < 0x1000) ||
+          (RHSC < 0 && RHSC > -0x1000)) { // 12 bits.
         Base = N.getOperand(0);
+        if (Base.getOpcode() == ISD::FrameIndex) {
+          int FI = cast(Base)->getIndex();
+          Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
+        }
         Offset = CurDAG->getRegister(0, MVT::i32);
-        Opc = CurDAG->getTargetConstant(ARM_AM::getAM2Opc(ARM_AM::sub, -RHSC,
+
+        ARM_AM::AddrOpc AddSub = ARM_AM::add;
+        if (RHSC < 0) {
+          AddSub = ARM_AM::sub;
+          RHSC = - RHSC;
+        }
+        Opc = CurDAG->getTargetConstant(ARM_AM::getAM2Opc(AddSub, RHSC,
                                                           ARM_AM::no_shift),
                                         MVT::i32);
         return true;
@@ -245,17 +249,21 @@
   // If the RHS is +/- imm8, fold into addr mode.
   if (ConstantSDNode *RHS = dyn_cast(N.getOperand(1))) {
     int RHSC = (int)RHS->getValue();
-    if (RHSC >= 0 && RHSC < 256) {
-      Base = N.getOperand(0);
-      Offset = CurDAG->getRegister(0, MVT::i32);
-      Opc = CurDAG->getTargetConstant(ARM_AM::getAM3Opc(ARM_AM::add, RHSC),
-                                      MVT::i32);
-      return true;
-    } else if (RHSC < 0 && RHSC > -256) { // note -256 itself isn't allowed.
+    if ((RHSC >= 0 && RHSC < 256) ||
+        (RHSC < 0 && RHSC > -256)) { // note -256 itself isn't allowed.
       Base = N.getOperand(0);
+      if (Base.getOpcode() == ISD::FrameIndex) {
+        int FI = cast(Base)->getIndex();
+        Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
+      }
       Offset = CurDAG->getRegister(0, MVT::i32);
-      Opc = CurDAG->getTargetConstant(ARM_AM::getAM3Opc(ARM_AM::sub, -RHSC),
-                                      MVT::i32);
+
+      ARM_AM::AddrOpc AddSub = ARM_AM::add;
+      if (RHSC < 0) {
+        AddSub = ARM_AM::sub;
+        RHSC = - RHSC;
+      }
+      Opc = CurDAG->getTargetConstant(ARM_AM::getAM3Opc(AddSub, RHSC),MVT::i32);
       return true;
     }
   }
@@ -309,14 +317,20 @@
     int RHSC = (int)RHS->getValue();
     if ((RHSC & 3) == 0) {  // The constant is implicitly multiplied by 4.
       RHSC >>= 2;
-      if (RHSC >= 0 && RHSC < 256) {
-        Base = N.getOperand(0);
-        Offset = CurDAG->getTargetConstant(ARM_AM::getAM5Opc(ARM_AM::add, RHSC),
-                                           MVT::i32);
-        return true;
-      } else if (RHSC < 0 && RHSC > -256) { // note -256 itself isn't allowed.
+      if ((RHSC >= 0 && RHSC < 256) ||
+          (RHSC < 0 && RHSC > -256)) { // note -256 itself isn't allowed.
         Base = N.getOperand(0);
-        Offset = CurDAG->getTargetConstant(ARM_AM::getAM5Opc(ARM_AM::sub,-RHSC),
+        if (Base.getOpcode() == ISD::FrameIndex) {
+          int FI = cast(Base)->getIndex();
+          Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
+        }
+
+        ARM_AM::AddrOpc AddSub = ARM_AM::add;
+        if (RHSC < 0) {
+          AddSub = ARM_AM::sub;
+          RHSC = - RHSC;
+        }
+        Offset = CurDAG->getTargetConstant(ARM_AM::getAM5Opc(AddSub, RHSC),
                                            MVT::i32);
         return true;
       }





From isanbard at gmail.com  Tue Jan 23 21:36:23 2007
From: isanbard at gmail.com (Bill Wendling)
Date: Tue, 23 Jan 2007 21:36:23 -0600
Subject: [llvm-commits] CVS: llvm/lib/Target/TargetMachOWriterInfo.cpp
Message-ID: <200701240336.l0O3aN7p028250@zion.cs.uiuc.edu>



Changes in directory llvm/lib/Target:

TargetMachOWriterInfo.cpp added (r1.1)
---
Log message:

New "TargetMachOWriterInfo" class. It holds target-specific information
that the MachOWriter needs in order to do its writing stuff 'n things.


---
Diffs of the changes:  (+23 -0)

 TargetMachOWriterInfo.cpp |   23 +++++++++++++++++++++++
 1 files changed, 23 insertions(+)


Index: llvm/lib/Target/TargetMachOWriterInfo.cpp
diff -c /dev/null llvm/lib/Target/TargetMachOWriterInfo.cpp:1.1
*** /dev/null	Tue Jan 23 21:36:15 2007
--- llvm/lib/Target/TargetMachOWriterInfo.cpp	Tue Jan 23 21:36:05 2007
***************
*** 0 ****
--- 1,23 ----
+ //===-- llvm/Target/TargetMachOWriterInfo.h - MachO Writer Info -*- C++ -*-===//
+ //
+ //                     The LLVM Compiler Infrastructure
+ //
+ // This file was developed by Bill Wendling and is distributed under the
+ // University of Illinois Open Source License. See LICENSE.TXT for details.
+ //
+ //===----------------------------------------------------------------------===//
+ //
+ // This file defines the TargetMachOWriterInfo class.
+ //
+ //===----------------------------------------------------------------------===//
+ 
+ #include "llvm/Target/TargetMachOWriterInfo.h"
+ #include "llvm/CodeGen/MachineRelocation.h"
+ using namespace llvm;
+ 
+ MachineRelocation
+ TargetMachOWriterInfo::GetJTRelocation(unsigned Offset,
+                                        MachineBasicBlock *MBB) const {
+   // FIXME: do something about PIC
+   return MachineRelocation::getBB(Offset, MachineRelocation::VANILLA, MBB);
+ }





From isanbard at gmail.com  Tue Jan 23 21:36:25 2007
From: isanbard at gmail.com (Bill Wendling)
Date: Tue, 23 Jan 2007 21:36:25 -0600
Subject: [llvm-commits] CVS: llvm/lib/Target/PowerPC/PPCMachOWriterInfo.cpp
	PPCMachOWriterInfo.h
Message-ID: <200701240336.l0O3aPhY028262@zion.cs.uiuc.edu>



Changes in directory llvm/lib/Target/PowerPC:

PPCMachOWriterInfo.cpp added (r1.1)
PPCMachOWriterInfo.h added (r1.1)
---
Log message:

New "TargetMachOWriterInfo" class. It holds target-specific information
that the MachOWriter needs in order to do its writing stuff 'n things.


---
Diffs of the changes:  (+57 -0)

 PPCMachOWriterInfo.cpp |   22 ++++++++++++++++++++++
 PPCMachOWriterInfo.h   |   35 +++++++++++++++++++++++++++++++++++
 2 files changed, 57 insertions(+)


Index: llvm/lib/Target/PowerPC/PPCMachOWriterInfo.cpp
diff -c /dev/null llvm/lib/Target/PowerPC/PPCMachOWriterInfo.cpp:1.1
*** /dev/null	Tue Jan 23 21:36:15 2007
--- llvm/lib/Target/PowerPC/PPCMachOWriterInfo.cpp	Tue Jan 23 21:36:05 2007
***************
*** 0 ****
--- 1,22 ----
+ //===-- PPCMachOWriterInfo.cpp - Mach-O Writer Info for the PowerPC -------===//
+ //
+ //                     The LLVM Compiler Infrastructure
+ //
+ // This file was developed by Bill Wendling and is distributed under the
+ // University of Illinois Open Source License. See LICENSE.TXT for details.
+ //
+ //===----------------------------------------------------------------------===//
+ //
+ // This file implements Mach-O writer information for the PowerPC backend.
+ //
+ //===----------------------------------------------------------------------===//
+ 
+ #include "PPCMachOWriterInfo.h"
+ #include "PPCTargetMachine.h"
+ using namespace llvm;
+ 
+ PPCMachOWriterInfo::PPCMachOWriterInfo(const PPCTargetMachine &TM)
+   : TargetMachOWriterInfo(TM.getTargetData()->getPointerSizeInBits() == 64 ?
+                           HDR_CPU_TYPE_POWERPC64 :
+                           HDR_CPU_TYPE_POWERPC,
+                           HDR_CPU_SUBTYPE_POWERPC_ALL) {}


Index: llvm/lib/Target/PowerPC/PPCMachOWriterInfo.h
diff -c /dev/null llvm/lib/Target/PowerPC/PPCMachOWriterInfo.h:1.1
*** /dev/null	Tue Jan 23 21:36:25 2007
--- llvm/lib/Target/PowerPC/PPCMachOWriterInfo.h	Tue Jan 23 21:36:05 2007
***************
*** 0 ****
--- 1,35 ----
+ //===-- PPCMachOWriterInfo.h - Mach-O Writer Info for PowerPC ---*- C++ -*-===//
+ //
+ //                     The LLVM Compiler Infrastructure
+ //
+ // This file was developed by Bill Wendling and is distributed under the
+ // University of Illinois Open Source License. See LICENSE.TXT for details.
+ //
+ //===----------------------------------------------------------------------===//
+ //
+ // This file implements Mach-O writer information for the PowerPC backend.
+ //
+ //===----------------------------------------------------------------------===//
+ 
+ #ifndef PPC_MACHO_WRITER_INFO_H
+ #define PPC_MACHO_WRITER_INFO_H
+ 
+ #include "llvm/Target/TargetMachOWriterInfo.h"
+ 
+ namespace llvm {
+ 
+   // Forward declarations
+   class PPCTargetMachine;
+ 
+   struct PPCMachOWriterInfo : public TargetMachOWriterInfo {
+     PPCMachOWriterInfo(const PPCTargetMachine &TM);
+     virtual ~PPCMachOWriterInfo() {}
+ 
+     virtual const char *getPassName() const {
+       return "PowerPC Mach-O Writer";
+     }
+   };
+ 
+ } // end llvm namespace
+ 
+ #endif // PPC_MACHO_WRITER_INFO_H





From isanbard at gmail.com  Tue Jan 23 21:36:25 2007
From: isanbard at gmail.com (Bill Wendling)
Date: Tue, 23 Jan 2007 21:36:25 -0600
Subject: [llvm-commits] CVS: llvm/include/llvm/Target/TargetMachOWriterInfo.h
Message-ID: <200701240336.l0O3aPCp028255@zion.cs.uiuc.edu>



Changes in directory llvm/include/llvm/Target:

TargetMachOWriterInfo.h added (r1.1)
---
Log message:

New "TargetMachOWriterInfo" class. It holds target-specific information
that the MachOWriter needs in order to do its writing stuff 'n things.


---
Diffs of the changes:  (+103 -0)

 TargetMachOWriterInfo.h |  103 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 files changed, 103 insertions(+)


Index: llvm/include/llvm/Target/TargetMachOWriterInfo.h
diff -c /dev/null llvm/include/llvm/Target/TargetMachOWriterInfo.h:1.1
*** /dev/null	Tue Jan 23 21:36:15 2007
--- llvm/include/llvm/Target/TargetMachOWriterInfo.h	Tue Jan 23 21:36:05 2007
***************
*** 0 ****
--- 1,103 ----
+ //===-- llvm/Target/TargetMachOWriterInfo.h - MachO Writer Info--*- C++ -*-===//
+ //
+ //                     The LLVM Compiler Infrastructure
+ //
+ // This file was developed by Bill Wendling and is distributed under the
+ // University of Illinois Open Source License. See LICENSE.TXT for details.
+ //
+ //===----------------------------------------------------------------------===//
+ //
+ // This file defines the TargetMachOWriterInfo class.
+ //
+ //===----------------------------------------------------------------------===//
+ 
+ #ifndef LLVM_TARGET_TARGETMACHOWRITERINFO_H
+ #define LLVM_TARGET_TARGETMACHOWRITERINFO_H
+ 
+ #include "llvm/CodeGen/MachineRelocation.h"
+ 
+ namespace llvm {
+ 
+   class MachineBasicBlock;
+ 
+   //===--------------------------------------------------------------------===//
+   //                        TargetMachOWriterInfo
+   //===--------------------------------------------------------------------===//
+ 
+   struct TargetMachOWriterInfo {
+     uint32_t CPUType;                 // CPU specifier
+     uint32_t CPUSubType;              // Machine specifier
+ 
+     // The various CPU_TYPE_* constants are already defined by at least one
+     // system header file and create compilation errors if not respected.
+ #if !defined(CPU_TYPE_I386)
+ #define CPU_TYPE_I386       7
+ #endif
+ #if !defined(CPU_TYPE_X86_64)
+ #define CPU_TYPE_X86_64     (CPU_TYPE_I386 | 0x1000000)
+ #endif
+ #if !defined(CPU_TYPE_ARM)
+ #define CPU_TYPE_ARM        12
+ #endif
+ #if !defined(CPU_TYPE_SPARC)
+ #define CPU_TYPE_SPARC      14
+ #endif
+ #if !defined(CPU_TYPE_POWERPC)
+ #define CPU_TYPE_POWERPC    18
+ #endif
+ #if !defined(CPU_TYPE_POWERPC64)
+ #define CPU_TYPE_POWERPC64  (CPU_TYPE_POWERPC | 0x1000000)
+ #endif
+ 
+     // Constants for the cputype field
+     // see 
+     enum {
+       HDR_CPU_TYPE_I386      = CPU_TYPE_I386,
+       HDR_CPU_TYPE_X86_64    = CPU_TYPE_X86_64,
+       HDR_CPU_TYPE_ARM       = CPU_TYPE_ARM,
+       HDR_CPU_TYPE_SPARC     = CPU_TYPE_SPARC,
+       HDR_CPU_TYPE_POWERPC   = CPU_TYPE_POWERPC,
+       HDR_CPU_TYPE_POWERPC64 = CPU_TYPE_POWERPC64
+     };
+       
+ #if !defined(CPU_SUBTYPE_I386_ALL)
+ #define CPU_SUBTYPE_I386_ALL    3
+ #endif
+ #if !defined(CPU_SUBTYPE_X86_64_ALL)
+ #define CPU_SUBTYPE_X86_64_ALL  3
+ #endif
+ #if !defined(CPU_SUBTYPE_ARM_ALL)
+ #define CPU_SUBTYPE_ARM_ALL     0
+ #endif
+ #if !defined(CPU_SUBTYPE_SPARC_ALL)
+ #define CPU_SUBTYPE_SPARC_ALL   0
+ #endif
+ #if !defined(CPU_SUBTYPE_POWERPC_ALL)
+ #define CPU_SUBTYPE_POWERPC_ALL 0
+ #endif
+ 
+     // Constants for the cpusubtype field
+     // see 
+     enum {
+       HDR_CPU_SUBTYPE_I386_ALL    = CPU_SUBTYPE_I386_ALL,
+       HDR_CPU_SUBTYPE_X86_64_ALL  = CPU_SUBTYPE_X86_64_ALL,
+       HDR_CPU_SUBTYPE_ARM_ALL     = CPU_SUBTYPE_ARM_ALL,
+       HDR_CPU_SUBTYPE_SPARC_ALL   = CPU_SUBTYPE_SPARC_ALL,
+       HDR_CPU_SUBTYPE_POWERPC_ALL = CPU_SUBTYPE_POWERPC_ALL
+     };
+ 
+     TargetMachOWriterInfo(uint32_t cputype, uint32_t cpusubtype)
+       : CPUType(cputype), CPUSubType(cpusubtype) {}
+     virtual ~TargetMachOWriterInfo() {}
+ 
+     virtual MachineRelocation GetJTRelocation(unsigned Offset,
+                                               MachineBasicBlock *MBB) const;
+ 
+     virtual const char *getPassName() const {
+       return "Mach-O Writer";
+     }
+   };
+ 
+ } // end llvm namespace
+ 
+ #endif // LLVM_TARGET_TARGETMACHOWRITERINFO_H





From isanbard at gmail.com  Tue Jan 23 21:37:34 2007
From: isanbard at gmail.com (Bill Wendling)
Date: Tue, 23 Jan 2007 21:37:34 -0600
Subject: [llvm-commits] CVS: llvm/include/llvm/CodeGen/MachOWriter.h
Message-ID: <200701240337.l0O3bYvD028292@zion.cs.uiuc.edu>



Changes in directory llvm/include/llvm/CodeGen:

MachOWriter.h updated: 1.14 -> 1.15
---
Log message:

Moved target-specific information to the TargetMachOWriterInfo obj.


---
Diffs of the changes:  (+7 -62)

 MachOWriter.h |   69 +++++-----------------------------------------------------
 1 files changed, 7 insertions(+), 62 deletions(-)


Index: llvm/include/llvm/CodeGen/MachOWriter.h
diff -u llvm/include/llvm/CodeGen/MachOWriter.h:1.14 llvm/include/llvm/CodeGen/MachOWriter.h:1.15
--- llvm/include/llvm/CodeGen/MachOWriter.h:1.14	Wed Jan 17 16:22:31 2007
+++ llvm/include/llvm/CodeGen/MachOWriter.h	Tue Jan 23 21:37:18 2007
@@ -19,6 +19,7 @@
 #include "llvm/CodeGen/MachineRelocation.h"
 #include "llvm/Target/TargetData.h"
 #include "llvm/Target/TargetMachine.h"
+#include "llvm/Target/TargetMachOWriterInfo.h"
 
 namespace llvm {
   class GlobalVariable;
@@ -126,8 +127,6 @@
     /// specific architecture type/subtype pair that is emitted to the file.
     struct MachOHeader {
       uint32_t  magic;      // mach magic number identifier
-      uint32_t  cputype;    // cpu specifier
-      uint32_t  cpusubtype; // machine specifier
       uint32_t  filetype;   // type of file
       uint32_t  ncmds;      // number of load commands
       uint32_t  sizeofcmds; // the size of all the load commands
@@ -138,62 +137,6 @@
       /// up for emission to the file.
       DataBuffer HeaderData;
 
-      // The various CPU_TYPE_* constants are already defined by at least one
-      // system header file and create compilation errors if not respected.
-#if !defined(CPU_TYPE_I386)
-#define CPU_TYPE_I386		7
-#endif
-#if !defined(CPU_TYPE_X86_64)
-#define CPU_TYPE_X86_64		(CPU_TYPE_I386 | 0x1000000)
-#endif
-#if !defined(CPU_TYPE_ARM)
-#define CPU_TYPE_ARM		12
-#endif
-#if !defined(CPU_TYPE_SPARC)
-#define CPU_TYPE_SPARC		14
-#endif
-#if !defined(CPU_TYPE_POWERPC)
-#define CPU_TYPE_POWERPC	18
-#endif
-#if !defined(CPU_TYPE_POWERPC64)
-#define CPU_TYPE_POWERPC64	(CPU_TYPE_POWERPC | 0x1000000)
-#endif
-
-      // Constants for the cputype field
-      // see 
-      enum { HDR_CPU_TYPE_I386      = CPU_TYPE_I386,
-             HDR_CPU_TYPE_X86_64    = CPU_TYPE_X86_64,
-             HDR_CPU_TYPE_ARM       = CPU_TYPE_ARM,
-             HDR_CPU_TYPE_SPARC     = CPU_TYPE_SPARC,
-             HDR_CPU_TYPE_POWERPC   = CPU_TYPE_POWERPC,
-             HDR_CPU_TYPE_POWERPC64 = CPU_TYPE_POWERPC64
-      };
-      
-#if !defined(CPU_SUBTYPE_I386_ALL)
-#define CPU_SUBTYPE_I386_ALL	3
-#endif
-#if !defined(CPU_SUBTYPE_X86_64_ALL)
-#define CPU_SUBTYPE_X86_64_ALL	3
-#endif
-#if !defined(CPU_SUBTYPE_ARM_ALL)
-#define CPU_SUBTYPE_ARM_ALL	0
-#endif
-#if !defined(CPU_SUBTYPE_SPARC_ALL)
-#define CPU_SUBTYPE_SPARC_ALL	0
-#endif
-#if !defined(CPU_SUBTYPE_POWERPC_ALL)
-#define CPU_SUBTYPE_POWERPC_ALL	0
-
-#endif
-      // Constants for the cpusubtype field
-      // see 
-      enum { HDR_CPU_SUBTYPE_I386_ALL = CPU_SUBTYPE_I386_ALL,
-             HDR_CPU_SUBTYPE_X86_64_ALL = CPU_SUBTYPE_X86_64_ALL,
-             HDR_CPU_SUBTYPE_ARM_ALL = CPU_SUBTYPE_ARM_ALL,
-             HDR_CPU_SUBTYPE_SPARC_ALL = CPU_SUBTYPE_SPARC_ALL,
-             HDR_CPU_SUBTYPE_POWERPC_ALL = CPU_SUBTYPE_POWERPC_ALL
-      };
-             
       // Constants for the filetype field
       // see  for additional info on the various types
       enum { MH_OBJECT     = 1, // relocatable object file
@@ -261,8 +204,8 @@
                 // stack execution privilege.  Only used in MH_EXECUTE filetype
       };
 
-      MachOHeader() : magic(0), cputype(0), cpusubtype(0), filetype(0),
-                      ncmds(0), sizeofcmds(0), flags(0), reserved(0) { }
+      MachOHeader() : magic(0), filetype(0), ncmds(0), sizeofcmds(0), flags(0),
+                      reserved(0) { }
       
       /// cmdSize - This routine returns the size of the MachOSection as written
       /// to disk, depending on whether the destination is a 64 bit Mach-O file.
@@ -671,8 +614,10 @@
     void BufferSymbolAndStringTable();
     void CalculateRelocations(MachOSection &MOS);
 
-    virtual MachineRelocation GetJTRelocation(unsigned Offset,
-                                              MachineBasicBlock *MBB) = 0;
+    MachineRelocation GetJTRelocation(unsigned Offset,
+                                      MachineBasicBlock *MBB) const {
+      return TM.getMachOWriterInfo()->GetJTRelocation(Offset, MBB);
+    }
     virtual void GetTargetRelocation(MachineRelocation &MR, MachOSection &From,
                                      MachOSection &To) = 0;
   };





From isanbard at gmail.com  Tue Jan 23 21:38:30 2007
From: isanbard at gmail.com (Bill Wendling)
Date: Tue, 23 Jan 2007 21:38:30 -0600
Subject: [llvm-commits] CVS: llvm/include/llvm/Target/TargetMachine.h
Message-ID: <200701240338.l0O3cUjm028319@zion.cs.uiuc.edu>



Changes in directory llvm/include/llvm/Target:

TargetMachine.h updated: 1.73 -> 1.74
---
Log message:

A virtual method to return the TargetMachOWriterInfo object. This returns
a real value in derived classes, of course.


---
Diffs of the changes:  (+6 -0)

 TargetMachine.h |    6 ++++++
 1 files changed, 6 insertions(+)


Index: llvm/include/llvm/Target/TargetMachine.h
diff -u llvm/include/llvm/Target/TargetMachine.h:1.73 llvm/include/llvm/Target/TargetMachine.h:1.74
--- llvm/include/llvm/Target/TargetMachine.h:1.73	Wed Jan 17 03:06:13 2007
+++ llvm/include/llvm/Target/TargetMachine.h	Tue Jan 23 21:38:14 2007
@@ -34,6 +34,7 @@
 class FunctionPassManager;
 class PassManager;
 class Pass;
+struct TargetMachOWriterInfo;
 
 // Relocation model types.
 namespace Reloc {
@@ -143,6 +144,11 @@
     return InstrItineraryData();
   }
 
+  /// getMachOWriterInfo - If this target supports a Mach-O writer, return
+  /// information for it, otherwise return null.
+  /// 
+  virtual const TargetMachOWriterInfo *getMachOWriterInfo() const { return 0; }
+
   /// getRelocationModel - Returns the code generation relocation model. The
   /// choices are static, PIC, and dynamic-no-pic, and target default.
   static Reloc::Model getRelocationModel();





From isanbard at gmail.com  Tue Jan 23 21:39:03 2007
From: isanbard at gmail.com (Bill Wendling)
Date: Tue, 23 Jan 2007 21:39:03 -0600
Subject: [llvm-commits] CVS: llvm/lib/CodeGen/MachOWriter.cpp
Message-ID: <200701240339.l0O3d3ge028342@zion.cs.uiuc.edu>



Changes in directory llvm/lib/CodeGen:

MachOWriter.cpp updated: 1.17 -> 1.18
---
Log message:

Use the TargetMachOWriterInfo class to get this information.


---
Diffs of the changes:  (+2 -2)

 MachOWriter.cpp |    4 ++--
 1 files changed, 2 insertions(+), 2 deletions(-)


Index: llvm/lib/CodeGen/MachOWriter.cpp
diff -u llvm/lib/CodeGen/MachOWriter.cpp:1.17 llvm/lib/CodeGen/MachOWriter.cpp:1.18
--- llvm/lib/CodeGen/MachOWriter.cpp:1.17	Sat Jan 20 16:35:55 2007
+++ llvm/lib/CodeGen/MachOWriter.cpp	Tue Jan 23 21:38:47 2007
@@ -461,8 +461,8 @@
   OutputBuffer FHOut(FH, is64Bit, isLittleEndian);
 
   FHOut.outword(Header.magic);
-  FHOut.outword(Header.cputype);
-  FHOut.outword(Header.cpusubtype);
+  FHOut.outword(TM.getMachOWriterInfo()->CPUType);
+  FHOut.outword(TM.getMachOWriterInfo()->CPUSubType);
   FHOut.outword(Header.filetype);
   FHOut.outword(Header.ncmds);
   FHOut.outword(Header.sizeofcmds);





From isanbard at gmail.com  Tue Jan 23 21:40:49 2007
From: isanbard at gmail.com (Bill Wendling)
Date: Tue, 23 Jan 2007 21:40:49 -0600
Subject: [llvm-commits] CVS: llvm/lib/Target/PowerPC/PPCMachOWriter.cpp
Message-ID: <200701240340.l0O3entL028386@zion.cs.uiuc.edu>



Changes in directory llvm/lib/Target/PowerPC:

PPCMachOWriter.cpp updated: 1.13 -> 1.14
---
Log message:

Move the getJTRelocation method out of here.


---
Diffs of the changes:  (+7 -26)

 PPCMachOWriter.cpp |   33 +++++++--------------------------
 1 files changed, 7 insertions(+), 26 deletions(-)


Index: llvm/lib/Target/PowerPC/PPCMachOWriter.cpp
diff -u llvm/lib/Target/PowerPC/PPCMachOWriter.cpp:1.13 llvm/lib/Target/PowerPC/PPCMachOWriter.cpp:1.14
--- llvm/lib/Target/PowerPC/PPCMachOWriter.cpp:1.13	Wed Jan 17 19:23:11 2007
+++ llvm/lib/Target/PowerPC/PPCMachOWriter.cpp	Tue Jan 23 21:40:33 2007
@@ -23,23 +23,11 @@
 namespace {
   class VISIBILITY_HIDDEN PPCMachOWriter : public MachOWriter {
   public:
-    PPCMachOWriter(std::ostream &O, PPCTargetMachine &TM) : MachOWriter(O, TM) {
-      if (TM.getTargetData()->getPointerSizeInBits() == 64) {
-        Header.cputype = MachOHeader::HDR_CPU_TYPE_POWERPC64;
-      } else {
-        Header.cputype = MachOHeader::HDR_CPU_TYPE_POWERPC;
-      }
-      Header.cpusubtype = MachOHeader::HDR_CPU_SUBTYPE_POWERPC_ALL;
-    }
+    PPCMachOWriter(std::ostream &O, PPCTargetMachine &TM)
+      : MachOWriter(O, TM) {}
 
     virtual void GetTargetRelocation(MachineRelocation &MR, MachOSection &From,
                                      MachOSection &To);
-    virtual MachineRelocation GetJTRelocation(unsigned Offset,
-                                              MachineBasicBlock *MBB);
-    
-    virtual const char *getPassName() const {
-      return "PowerPC Mach-O Writer";
-    }
 
     // Constants for the relocation r_type field.
     // see 
@@ -67,20 +55,20 @@
 
 /// GetTargetRelocation - For the MachineRelocation MR, convert it to one or
 /// more PowerPC MachORelocation(s), add the new relocations to the
-/// MachOSection, and rewrite the instruction at the section offset if required 
+/// MachOSection, and rewrite the instruction at the section offset if required
 /// by that relocation type.
 void PPCMachOWriter::GetTargetRelocation(MachineRelocation &MR,
                                          MachOSection &From,
                                          MachOSection &To) {
   uint64_t Addr = 0;
-  
+
   // Keep track of whether or not this is an externally defined relocation.
   bool     isExtern = false;
-  
+
   // Get the address of whatever it is we're relocating, if possible.
   if (!isExtern)
     Addr = (uintptr_t)MR.getResultPointer() + To.addr;
-    
+
   switch ((PPC::RelocationType)MR.getRelocationType()) {
   default: assert(0 && "Unknown PPC relocation type!");
   case PPC::reloc_absolute_low_ix:
@@ -89,7 +77,7 @@
   case PPC::reloc_vanilla:
     {
       // FIXME: need to handle 64 bit vanilla relocs
-      MachORelocation VANILLA(MR.getMachineCodeOffset(), To.Index, false, 2, 
+      MachORelocation VANILLA(MR.getMachineCodeOffset(), To.Index, false, 2,
                               isExtern, PPC_RELOC_VANILLA);
       ++From.nreloc;
 
@@ -165,10 +153,3 @@
     }
   }
 }
-
-MachineRelocation PPCMachOWriter::GetJTRelocation(unsigned Offset,
-                                                  MachineBasicBlock *MBB) {
-  // FIXME: do something about PIC
-  return MachineRelocation::getBB(Offset, PPC::reloc_vanilla, MBB);
-}
-





From isanbard at gmail.com  Tue Jan 23 21:41:52 2007
From: isanbard at gmail.com (Bill Wendling)
Date: Tue, 23 Jan 2007 21:41:52 -0600
Subject: [llvm-commits] CVS: llvm/lib/Target/PowerPC/PPCTargetMachine.cpp
	PPCTargetMachine.h
Message-ID: <200701240341.l0O3fqcp028419@zion.cs.uiuc.edu>



Changes in directory llvm/lib/Target/PowerPC:

PPCTargetMachine.cpp updated: 1.114 -> 1.115
PPCTargetMachine.h updated: 1.27 -> 1.28
---
Log message:

Add a field for and construction of the PPCMachOWriterInfo object.


---
Diffs of the changes:  (+7 -2)

 PPCTargetMachine.cpp |    2 +-
 PPCTargetMachine.h   |    7 ++++++-
 2 files changed, 7 insertions(+), 2 deletions(-)


Index: llvm/lib/Target/PowerPC/PPCTargetMachine.cpp
diff -u llvm/lib/Target/PowerPC/PPCTargetMachine.cpp:1.114 llvm/lib/Target/PowerPC/PPCTargetMachine.cpp:1.115
--- llvm/lib/Target/PowerPC/PPCTargetMachine.cpp:1.114	Wed Jan 17 03:06:13 2007
+++ llvm/lib/Target/PowerPC/PPCTargetMachine.cpp	Tue Jan 23 21:41:36 2007
@@ -87,7 +87,7 @@
   : Subtarget(*this, M, FS, is64Bit),
     DataLayout(Subtarget.getTargetDataString()), InstrInfo(*this),
     FrameInfo(*this, is64Bit), JITInfo(*this, is64Bit), TLInfo(*this),
-    InstrItins(Subtarget.getInstrItineraryData()) {
+    InstrItins(Subtarget.getInstrItineraryData()), MachOWriterInfo(*this) {
 
   if (getRelocationModel() == Reloc::Default)
     if (Subtarget.isDarwin())


Index: llvm/lib/Target/PowerPC/PPCTargetMachine.h
diff -u llvm/lib/Target/PowerPC/PPCTargetMachine.h:1.27 llvm/lib/Target/PowerPC/PPCTargetMachine.h:1.28
--- llvm/lib/Target/PowerPC/PPCTargetMachine.h:1.27	Wed Jan 17 03:06:13 2007
+++ llvm/lib/Target/PowerPC/PPCTargetMachine.h	Tue Jan 23 21:41:36 2007
@@ -19,6 +19,7 @@
 #include "PPCJITInfo.h"
 #include "PPCInstrInfo.h"
 #include "PPCISelLowering.h"
+#include "PPCMachOWriterInfo.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Target/TargetData.h"
 
@@ -36,7 +37,8 @@
   PPCJITInfo          JITInfo;
   PPCTargetLowering   TLInfo;
   InstrItineraryData  InstrItins;
-  
+  PPCMachOWriterInfo  MachOWriterInfo;
+
 protected:
   virtual const TargetAsmInfo *createTargetAsmInfo() const;
   
@@ -58,6 +60,9 @@
   virtual const InstrItineraryData getInstrItineraryData() const {  
     return InstrItins;
   }
+  virtual const PPCMachOWriterInfo *getMachOWriterInfo() const {
+    return &MachOWriterInfo;
+  }
   
   // Pass Pipeline Configuration
   virtual bool addInstSelector(FunctionPassManager &PM, bool Fast);





From isanbard at gmail.com  Tue Jan 23 21:42:19 2007
From: isanbard at gmail.com (Bill Wendling)
Date: Tue, 23 Jan 2007 21:42:19 -0600
Subject: [llvm-commits] CVS: llvm/Xcode/LLVM.xcodeproj/project.pbxproj
Message-ID: <200701240342.l0O3gJY6028442@zion.cs.uiuc.edu>



Changes in directory llvm/Xcode/LLVM.xcodeproj:

project.pbxproj updated: 1.28 -> 1.29
---
Log message:

Added new files.


---
Diffs of the changes:  (+11 -0)

 project.pbxproj |   11 +++++++++++
 1 files changed, 11 insertions(+)


Index: llvm/Xcode/LLVM.xcodeproj/project.pbxproj
diff -u llvm/Xcode/LLVM.xcodeproj/project.pbxproj:1.28 llvm/Xcode/LLVM.xcodeproj/project.pbxproj:1.29
--- llvm/Xcode/LLVM.xcodeproj/project.pbxproj:1.28	Mon Jan 22 08:13:45 2007
+++ llvm/Xcode/LLVM.xcodeproj/project.pbxproj	Tue Jan 23 21:42:03 2007
@@ -65,6 +65,10 @@
 /* End PBXContainerItemProxy section */
 
 /* Begin PBXFileReference section */
+		84115FFE0B66D87400E1293E /* TargetMachOWriterInfo.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = TargetMachOWriterInfo.cpp; sourceTree = ""; };
+		84115FFF0B66D89B00E1293E /* PPCMachOWriterInfo.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = PPCMachOWriterInfo.cpp; sourceTree = ""; };
+		841160000B66D8AC00E1293E /* PPCMachOWriterInfo.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = PPCMachOWriterInfo.h; sourceTree = ""; };
+		8443EF210B66B62D00959964 /* TargetMachOWriterInfo.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = TargetMachOWriterInfo.h; sourceTree = ""; };
 		CF1ACC9709C9DE4400D3C5EB /* IntrinsicInst.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = IntrinsicInst.cpp; path = ../lib/VMCore/IntrinsicInst.cpp; sourceTree = ""; };
 		CF26835B09178F5500C5F253 /* TargetInstrItineraries.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TargetInstrItineraries.h; sourceTree = ""; };
 		CF32AF5C0AEE6A4E00D24CD4 /* LLVMTargetMachine.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LLVMTargetMachine.cpp; sourceTree = ""; };
@@ -1479,6 +1483,7 @@
 		DE66EE9608ABEE5D00323D32 /* lib/Target */ = {
 			isa = PBXGroup;
 			children = (
+				84115FFE0B66D87400E1293E /* TargetMachOWriterInfo.cpp */,
 				DE66EE9708ABEE5D00323D32 /* Alpha */,
 				CF8F1BCF0B64FC8A00BB4199 /* ARM */,
 				DE66EEC908ABEE5E00323D32 /* CBackend */,
@@ -1592,6 +1597,8 @@
 		DE66EF1108ABEE5E00323D32 /* PowerPC */ = {
 			isa = PBXGroup;
 			children = (
+				841160000B66D8AC00E1293E /* PPCMachOWriterInfo.h */,
+				84115FFF0B66D89B00E1293E /* PPCMachOWriterInfo.cpp */,
 				CFA702CB0A6FA8AD0006009A /* PPCGenAsmWriter.inc */,
 				CFA702CC0A6FA8AD0006009A /* PPCGenCodeEmitter.inc */,
 				CFA702CD0A6FA8AD0006009A /* PPCGenDAGISel.inc */,
@@ -2151,6 +2158,7 @@
 		DE66F29F08ABF03200323D32 /* Target */ = {
 			isa = PBXGroup;
 			children = (
+				8443EF210B66B62D00959964 /* TargetMachOWriterInfo.h */,
 				DE66F2A008ABF03200323D32 /* MRegisterInfo.h */,
 				CF9BCD0808C74DE0001E7011 /* SubtargetFeature.h */,
 				CF47BD380AAF40BC00A8B13E /* TargetAsmInfo.h */,
@@ -2535,9 +2543,12 @@
 		08FB7793FE84155DC02AAC07 /* Project object */ = {
 			isa = PBXProject;
 			buildConfigurationList = DE66EC5008ABE78900323D32 /* Build configuration list for PBXProject "LLVM" */;
+			compatibilityVersion = "Xcode 2.4";
 			hasScannedForEncodings = 1;
 			mainGroup = 08FB7794FE84155DC02AAC07 /* LLVM */;
 			projectDirPath = "";
+			projectRoot = "";
+			shouldCheckCompatibility = 1;
 			targets = (
 				D28A88AD04BDD90700651E21 /* LLVM */,
 				CF0329B608D1BE110030FD33 /* LLVM lib */,





From sabre at nondot.org  Tue Jan 23 23:24:25 2007
From: sabre at nondot.org (Chris Lattner)
Date: Tue, 23 Jan 2007 23:24:25 -0600
Subject: [llvm-commits] CVS: llvm-www/www-index.html
Message-ID: <200701240524.l0O5OPfK030093@zion.cs.uiuc.edu>



Changes in directory llvm-www:

www-index.html updated: 1.132 -> 1.133
---
Log message:

backends have multiplied


---
Diffs of the changes:  (+3 -3)

 www-index.html |    6 +++---
 1 files changed, 3 insertions(+), 3 deletions(-)


Index: llvm-www/www-index.html
diff -u llvm-www/www-index.html:1.132 llvm-www/www-index.html:1.133
--- llvm-www/www-index.html:1.132	Mon Nov 20 01:44:49 2006
+++ llvm-www/www-index.html	Tue Jan 23 23:24:10 2007
@@ -35,9 +35,9 @@
 GCC-based C & C++
 front-end, a link-time optimization framework with a growing set of global
 and interprocedural analyses and transformations, static back-ends for the X86,
-PowerPC, IA-64, Alpha and SPARC architectures, a back-end which emits 
-portable C code, and a Just-In-Time compiler for X86 and PowerPC
-processors. 

+X86-64, PowerPC 32/64, ARM, Thumb, IA-64, Alpha and SPARC architectures, 
+a back-end which emits portable C code, and a Just-In-Time compiler for X86,
+X86-64, PowerPC 32/64 processors. 
 
 LLVM does not imply things that you would expect from a 
 high-level virtual machine.  It does not require garbage collection or 





From sabre at nondot.org  Tue Jan 23 23:26:25 2007
From: sabre at nondot.org (Chris Lattner)
Date: Tue, 23 Jan 2007 23:26:25 -0600
Subject: [llvm-commits] CVS: llvm-www/Features.html
Message-ID: <200701240526.l0O5QPi3030186@zion.cs.uiuc.edu>



Changes in directory llvm-www:

Features.html updated: 1.18 -> 1.19
---
Log message:

Update.


---
Diffs of the changes:  (+5 -3)

 Features.html |    8 +++++---
 1 files changed, 5 insertions(+), 3 deletions(-)


Index: llvm-www/Features.html
diff -u llvm-www/Features.html:1.18 llvm-www/Features.html:1.19
--- llvm-www/Features.html:1.18	Wed Nov 15 00:56:55 2006
+++ llvm-www/Features.html	Tue Jan 23 23:26:09 2007
@@ -27,10 +27,12 @@
   optimizations.
 
   An easily retargettable code generator, which currently supports X86, 
-      X86-64, PowerPC, PowerPC-64, SPARC, Alpha, and IA-64.
+      X86-64, PowerPC, PowerPC-64, ARM, Thumb, SPARC, Alpha, and IA-64.
 
-  A Just-In-Time (JIT) code generation system for X86, X86-64,
-  PowerPC and PowerPC-64.
+  A Just-In-Time (JIT) code generation system, which currently supports 
+  X86, X86-64, PowerPC and PowerPC-64.
+  
+  Support for generating DWARF debugging information.
 
   A C back-end useful for testing and for generating native code on targets
   other than the ones listed above.





From sabre at nondot.org  Tue Jan 23 23:27:34 2007
From: sabre at nondot.org (Chris Lattner)
Date: Tue, 23 Jan 2007 23:27:34 -0600
Subject: [llvm-commits] CVS: llvm-www/OpenProjects.html
Message-ID: <200701240527.l0O5RYJa030268@zion.cs.uiuc.edu>



Changes in directory llvm-www:

OpenProjects.html updated: 1.16 -> 1.17
---
Log message:

ARM exists.


---
Diffs of the changes:  (+2 -3)

 OpenProjects.html |    5 ++---
 1 files changed, 2 insertions(+), 3 deletions(-)


Index: llvm-www/OpenProjects.html
diff -u llvm-www/OpenProjects.html:1.16 llvm-www/OpenProjects.html:1.17
--- llvm-www/OpenProjects.html:1.16	Wed Jul 19 12:53:23 2006
+++ llvm-www/OpenProjects.html	Tue Jan 23 23:27:16 2007
@@ -320,8 +320,7 @@
     registers clobbered by a function. Use the pass to fine tune register usage 
     in callers based on *actual* registers used by the callee.
 Write a new backend for a target 
-(ARM? 
- MIPS? 
+(MIPS? 
  MMIX?)
 
 
@@ -374,7 +373,7 @@
   src="http://www.w3.org/Icons/valid-html401" alt="Valid HTML 4.01!">
 
   LLVM Compiler Infrastructure

-  Last modified: $Date: 2006/07/19 17:53:23 $
+  Last modified: $Date: 2007/01/24 05:27:16 $
 
 
 





From sabre at nondot.org  Tue Jan 23 23:28:26 2007
From: sabre at nondot.org (Chris Lattner)
Date: Tue, 23 Jan 2007 23:28:26 -0600
Subject: [llvm-commits] CVS: llvm-www/OpenProjects.html
Message-ID: <200701240528.l0O5SQ5j030326@zion.cs.uiuc.edu>



Changes in directory llvm-www:

OpenProjects.html updated: 1.17 -> 1.18
---
Log message:

also done


---
Diffs of the changes:  (+1 -2)

 OpenProjects.html |    3 +--
 1 files changed, 1 insertion(+), 2 deletions(-)


Index: llvm-www/OpenProjects.html
diff -u llvm-www/OpenProjects.html:1.17 llvm-www/OpenProjects.html:1.18
--- llvm-www/OpenProjects.html:1.17	Tue Jan 23 23:27:16 2007
+++ llvm-www/OpenProjects.html	Tue Jan 23 23:28:10 2007
@@ -181,7 +181,6 @@
 
 
 
-Rework the PassManager to be more flexible
 
 Some transformations and analyses only work on reducible flow graphs.  It
 would be nice to have a transformation which could be "required" by these passes
@@ -373,7 +372,7 @@
   src="http://www.w3.org/Icons/valid-html401" alt="Valid HTML 4.01!">
 
   LLVM Compiler Infrastructure

-  Last modified: $Date: 2007/01/24 05:27:16 $
+  Last modified: $Date: 2007/01/24 05:28:10 $
 
 
 





From evan.cheng at apple.com  Wed Jan 24 01:03:59 2007
From: evan.cheng at apple.com (Evan Cheng)
Date: Wed, 24 Jan 2007 01:03:59 -0600
Subject: [llvm-commits] CVS: llvm/lib/Target/TargetData.cpp
Message-ID: <200701240703.l0O73x88031970@zion.cs.uiuc.edu>



Changes in directory llvm/lib/Target:

TargetData.cpp updated: 1.81 -> 1.82
---
Log message:

Renamed getTypeAlignmentShift() to getPreferredTypeAlignmentShift().

---
Diffs of the changes:  (+2 -2)

 TargetData.cpp |    4 ++--
 1 files changed, 2 insertions(+), 2 deletions(-)


Index: llvm/lib/Target/TargetData.cpp
diff -u llvm/lib/Target/TargetData.cpp:1.81 llvm/lib/Target/TargetData.cpp:1.82
--- llvm/lib/Target/TargetData.cpp:1.81	Mon Jan 22 17:08:19 2007
+++ llvm/lib/Target/TargetData.cpp	Wed Jan 24 01:03:39 2007
@@ -450,7 +450,7 @@
   return Align;
 }
 
-unsigned char TargetData::getTypeAlignmentShift(const Type *Ty) const {
+unsigned char TargetData::getPreferredTypeAlignmentShift(const Type *Ty) const {
   unsigned Align = getTypeAlignmentPref(Ty);
   assert(!(Align & (Align-1)) && "Alignment is not a power of two!");
   return Log2_32(Align);
@@ -508,7 +508,7 @@
 /// requested alignment (if the global has one).
 unsigned TargetData::getPreferredAlignmentLog(const GlobalVariable *GV) const {
   const Type *ElemType = GV->getType()->getElementType();
-  unsigned Alignment = getTypeAlignmentShift(ElemType);
+  unsigned Alignment = getPreferredTypeAlignmentShift(ElemType);
   if (GV->getAlignment() > (1U << Alignment))
     Alignment = Log2_32(GV->getAlignment());
   





From evan.cheng at apple.com  Wed Jan 24 01:04:04 2007
From: evan.cheng at apple.com (Evan Cheng)
Date: Wed, 24 Jan 2007 01:04:04 -0600
Subject: [llvm-commits] CVS: llvm/lib/Target/Alpha/AlphaAsmPrinter.cpp
Message-ID: <200701240704.l0O744mZ031975@zion.cs.uiuc.edu>



Changes in directory llvm/lib/Target/Alpha:

AlphaAsmPrinter.cpp updated: 1.60 -> 1.61
---
Log message:

Renamed getTypeAlignmentShift() to getPreferredTypeAlignmentShift().

---
Diffs of the changes:  (+1 -1)

 AlphaAsmPrinter.cpp |    2 +-
 1 files changed, 1 insertion(+), 1 deletion(-)


Index: llvm/lib/Target/Alpha/AlphaAsmPrinter.cpp
diff -u llvm/lib/Target/Alpha/AlphaAsmPrinter.cpp:1.60 llvm/lib/Target/Alpha/AlphaAsmPrinter.cpp:1.61
--- llvm/lib/Target/Alpha/AlphaAsmPrinter.cpp:1.60	Tue Dec 19 16:59:25 2006
+++ llvm/lib/Target/Alpha/AlphaAsmPrinter.cpp	Wed Jan 24 01:03:39 2007
@@ -212,7 +212,7 @@
       std::string name = Mang->getValueName(I);
       Constant *C = I->getInitializer();
       unsigned Size = TD->getTypeSize(C->getType());
-      //      unsigned Align = TD->getTypeAlignmentShift(C->getType());
+      //      unsigned Align = TD->getPreferredTypeAlignmentShift(C->getType());
       unsigned Align = TD->getPreferredAlignmentLog(I);
 
       if (C->isNullValue() &&





From evan.cheng at apple.com  Wed Jan 24 01:04:05 2007
From: evan.cheng at apple.com (Evan Cheng)
Date: Wed, 24 Jan 2007 01:04:05 -0600
Subject: [llvm-commits] CVS: llvm/lib/Target/IA64/IA64AsmPrinter.cpp
Message-ID: <200701240704.l0O74541031985@zion.cs.uiuc.edu>



Changes in directory llvm/lib/Target/IA64:

IA64AsmPrinter.cpp updated: 1.41 -> 1.42
---
Log message:

Renamed getTypeAlignmentShift() to getPreferredTypeAlignmentShift().

---
Diffs of the changes:  (+1 -1)

 IA64AsmPrinter.cpp |    2 +-
 1 files changed, 1 insertion(+), 1 deletion(-)


Index: llvm/lib/Target/IA64/IA64AsmPrinter.cpp
diff -u llvm/lib/Target/IA64/IA64AsmPrinter.cpp:1.41 llvm/lib/Target/IA64/IA64AsmPrinter.cpp:1.42
--- llvm/lib/Target/IA64/IA64AsmPrinter.cpp:1.41	Tue Dec 19 16:59:26 2006
+++ llvm/lib/Target/IA64/IA64AsmPrinter.cpp	Wed Jan 24 01:03:39 2007
@@ -272,7 +272,7 @@
       std::string name = Mang->getValueName(I);
       Constant *C = I->getInitializer();
       unsigned Size = TD->getTypeSize(C->getType());
-      unsigned Align = TD->getTypeAlignmentShift(C->getType());
+      unsigned Align = TD->getPreferredTypeAlignmentShift(C->getType());
       
       if (C->isNullValue() &&
           (I->hasLinkOnceLinkage() || I->hasInternalLinkage() ||





From evan.cheng at apple.com  Wed Jan 24 01:04:05 2007
From: evan.cheng at apple.com (Evan Cheng)
Date: Wed, 24 Jan 2007 01:04:05 -0600
Subject: [llvm-commits] CVS: llvm/include/llvm/Target/TargetData.h
Message-ID: <200701240704.l0O745jK031988@zion.cs.uiuc.edu>



Changes in directory llvm/include/llvm/Target:

TargetData.h updated: 1.47 -> 1.48
---
Log message:

Renamed getTypeAlignmentShift() to getPreferredTypeAlignmentShift().

---
Diffs of the changes:  (+2 -2)

 TargetData.h |    4 ++--
 1 files changed, 2 insertions(+), 2 deletions(-)


Index: llvm/include/llvm/Target/TargetData.h
diff -u llvm/include/llvm/Target/TargetData.h:1.47 llvm/include/llvm/Target/TargetData.h:1.48
--- llvm/include/llvm/Target/TargetData.h:1.47	Mon Jan 22 17:14:52 2007
+++ llvm/include/llvm/Target/TargetData.h	Wed Jan 24 01:03:39 2007
@@ -233,10 +233,10 @@
   /// the specified type.
   unsigned char getTypeAlignmentPref(const Type *Ty) const;
 
-  /// getTypeAlignmentShift - Return the preferred alignment for the
+  /// getPreferredTypeAlignmentShift - Return the preferred alignment for the
   /// specified type, returned as log2 of the value (a shift amount).
   ///
-  unsigned char getTypeAlignmentShift(const Type *Ty) const;
+  unsigned char getPreferredTypeAlignmentShift(const Type *Ty) const;
 
   /// getIntPtrType - Return an unsigned integer type that is the same size or
   /// greater to the host pointer size.





From evan.cheng at apple.com  Wed Jan 24 01:04:04 2007
From: evan.cheng at apple.com (Evan Cheng)
Date: Wed, 24 Jan 2007 01:04:04 -0600
Subject: [llvm-commits] CVS: llvm/lib/CodeGen/SelectionDAG/ScheduleDAG.cpp
Message-ID: <200701240704.l0O744tf031978@zion.cs.uiuc.edu>



Changes in directory llvm/lib/CodeGen/SelectionDAG:

ScheduleDAG.cpp updated: 1.115 -> 1.116
---
Log message:

Renamed getTypeAlignmentShift() to getPreferredTypeAlignmentShift().

---
Diffs of the changes:  (+1 -1)

 ScheduleDAG.cpp |    2 +-
 1 files changed, 1 insertion(+), 1 deletion(-)


Index: llvm/lib/CodeGen/SelectionDAG/ScheduleDAG.cpp
diff -u llvm/lib/CodeGen/SelectionDAG/ScheduleDAG.cpp:1.115 llvm/lib/CodeGen/SelectionDAG/ScheduleDAG.cpp:1.116
--- llvm/lib/CodeGen/SelectionDAG/ScheduleDAG.cpp:1.115	Mon Jan 22 17:13:55 2007
+++ llvm/lib/CodeGen/SelectionDAG/ScheduleDAG.cpp	Wed Jan 24 01:03:39 2007
@@ -330,7 +330,7 @@
     const Type *Type = CP->getType();
     // MachineConstantPool wants an explicit alignment.
     if (Align == 0) {
-      Align = TM.getTargetData()->getTypeAlignmentShift(Type);
+      Align = TM.getTargetData()->getPreferredTypeAlignmentShift(Type);
       if (Align == 0) {
         // Alignment of packed types.  FIXME!
         Align = TM.getTargetData()->getTypeSize(Type);





From isanbard at gmail.com  Wed Jan 24 01:14:15 2007
From: isanbard at gmail.com (Bill Wendling)
Date: Wed, 24 Jan 2007 01:14:15 -0600
Subject: [llvm-commits] CVS: llvm/lib/CodeGen/MachOWriter.cpp
Message-ID: <200701240714.l0O7EFPd032162@zion.cs.uiuc.edu>



Changes in directory llvm/lib/CodeGen:

MachOWriter.cpp updated: 1.18 -> 1.19
---
Log message:

Make ivars private and use getters. Have the MachOWriter return "Mach-O
Writer" for the pass name.


---
Diffs of the changes:  (+2 -2)

 MachOWriter.cpp |    4 ++--
 1 files changed, 2 insertions(+), 2 deletions(-)


Index: llvm/lib/CodeGen/MachOWriter.cpp
diff -u llvm/lib/CodeGen/MachOWriter.cpp:1.18 llvm/lib/CodeGen/MachOWriter.cpp:1.19
--- llvm/lib/CodeGen/MachOWriter.cpp:1.18	Tue Jan 23 21:38:47 2007
+++ llvm/lib/CodeGen/MachOWriter.cpp	Wed Jan 24 01:13:56 2007
@@ -461,8 +461,8 @@
   OutputBuffer FHOut(FH, is64Bit, isLittleEndian);
 
   FHOut.outword(Header.magic);
-  FHOut.outword(TM.getMachOWriterInfo()->CPUType);
-  FHOut.outword(TM.getMachOWriterInfo()->CPUSubType);
+  FHOut.outword(TM.getMachOWriterInfo()->getCPUType());
+  FHOut.outword(TM.getMachOWriterInfo()->getCPUSubType());
   FHOut.outword(Header.filetype);
   FHOut.outword(Header.ncmds);
   FHOut.outword(Header.sizeofcmds);





From isanbard at gmail.com  Wed Jan 24 01:14:15 2007
From: isanbard at gmail.com (Bill Wendling)
Date: Wed, 24 Jan 2007 01:14:15 -0600
Subject: [llvm-commits] CVS: llvm/include/llvm/CodeGen/MachOWriter.h
Message-ID: <200701240714.l0O7EFK0032167@zion.cs.uiuc.edu>



Changes in directory llvm/include/llvm/CodeGen:

MachOWriter.h updated: 1.15 -> 1.16
---
Log message:

Make ivars private and use getters. Have the MachOWriter return "Mach-O
Writer" for the pass name.


---
Diffs of the changes:  (+4 -2)

 MachOWriter.h |    6 ++++--
 1 files changed, 4 insertions(+), 2 deletions(-)


Index: llvm/include/llvm/CodeGen/MachOWriter.h
diff -u llvm/include/llvm/CodeGen/MachOWriter.h:1.15 llvm/include/llvm/CodeGen/MachOWriter.h:1.16
--- llvm/include/llvm/CodeGen/MachOWriter.h:1.15	Tue Jan 23 21:37:18 2007
+++ llvm/include/llvm/CodeGen/MachOWriter.h	Wed Jan 24 01:13:55 2007
@@ -85,11 +85,13 @@
     MachineCodeEmitter &getMachineCodeEmitter() const {
       return *(MachineCodeEmitter*)MCE;
     }
+    virtual ~MachOWriter();
 
-    ~MachOWriter();
+    virtual const char *getPassName() const {
+      return "Mach-O Writer";
+    }
 
     typedef std::vector DataBuffer;
-
   protected:
     MachOWriter(std::ostream &O, TargetMachine &TM);
 





From isanbard at gmail.com  Wed Jan 24 01:14:15 2007
From: isanbard at gmail.com (Bill Wendling)
Date: Wed, 24 Jan 2007 01:14:15 -0600
Subject: [llvm-commits] CVS: llvm/include/llvm/Target/TargetMachOWriterInfo.h
Message-ID: <200701240714.l0O7EFe9032169@zion.cs.uiuc.edu>



Changes in directory llvm/include/llvm/Target:

TargetMachOWriterInfo.h updated: 1.1 -> 1.2
---
Log message:

Make ivars private and use getters. Have the MachOWriter return "Mach-O
Writer" for the pass name.


---
Diffs of the changes:  (+4 -5)

 TargetMachOWriterInfo.h |    9 ++++-----
 1 files changed, 4 insertions(+), 5 deletions(-)


Index: llvm/include/llvm/Target/TargetMachOWriterInfo.h
diff -u llvm/include/llvm/Target/TargetMachOWriterInfo.h:1.1 llvm/include/llvm/Target/TargetMachOWriterInfo.h:1.2
--- llvm/include/llvm/Target/TargetMachOWriterInfo.h:1.1	Tue Jan 23 21:36:05 2007
+++ llvm/include/llvm/Target/TargetMachOWriterInfo.h	Wed Jan 24 01:13:55 2007
@@ -24,10 +24,10 @@
   //                        TargetMachOWriterInfo
   //===--------------------------------------------------------------------===//
 
-  struct TargetMachOWriterInfo {
+  class TargetMachOWriterInfo {
     uint32_t CPUType;                 // CPU specifier
     uint32_t CPUSubType;              // Machine specifier
-
+  public:
     // The various CPU_TYPE_* constants are already defined by at least one
     // system header file and create compilation errors if not respected.
 #if !defined(CPU_TYPE_I386)
@@ -93,9 +93,8 @@
     virtual MachineRelocation GetJTRelocation(unsigned Offset,
                                               MachineBasicBlock *MBB) const;
 
-    virtual const char *getPassName() const {
-      return "Mach-O Writer";
-    }
+    uint32_t getCPUType() const { return CPUType; }
+    uint32_t getCPUSubType() const { return CPUSubType; }
   };
 
 } // end llvm namespace





From isanbard at gmail.com  Wed Jan 24 01:14:18 2007
From: isanbard at gmail.com (Bill Wendling)
Date: Wed, 24 Jan 2007 01:14:18 -0600
Subject: [llvm-commits] CVS: llvm/lib/Target/PowerPC/PPCMachOWriterInfo.h
Message-ID: <200701240714.l0O7EIT7032177@zion.cs.uiuc.edu>



Changes in directory llvm/lib/Target/PowerPC:

PPCMachOWriterInfo.h updated: 1.1 -> 1.2
---
Log message:

Make ivars private and use getters. Have the MachOWriter return "Mach-O
Writer" for the pass name.


---
Diffs of the changes:  (+2 -5)

 PPCMachOWriterInfo.h |    7 ++-----
 1 files changed, 2 insertions(+), 5 deletions(-)


Index: llvm/lib/Target/PowerPC/PPCMachOWriterInfo.h
diff -u llvm/lib/Target/PowerPC/PPCMachOWriterInfo.h:1.1 llvm/lib/Target/PowerPC/PPCMachOWriterInfo.h:1.2
--- llvm/lib/Target/PowerPC/PPCMachOWriterInfo.h:1.1	Tue Jan 23 21:36:05 2007
+++ llvm/lib/Target/PowerPC/PPCMachOWriterInfo.h	Wed Jan 24 01:13:56 2007
@@ -21,13 +21,10 @@
   // Forward declarations
   class PPCTargetMachine;
 
-  struct PPCMachOWriterInfo : public TargetMachOWriterInfo {
+  class PPCMachOWriterInfo : public TargetMachOWriterInfo {
+  public:
     PPCMachOWriterInfo(const PPCTargetMachine &TM);
     virtual ~PPCMachOWriterInfo() {}
-
-    virtual const char *getPassName() const {
-      return "PowerPC Mach-O Writer";
-    }
   };
 
 } // end llvm namespace





From evan.cheng at apple.com  Wed Jan 24 02:53:59 2007
From: evan.cheng at apple.com (Evan Cheng)
Date: Wed, 24 Jan 2007 02:53:59 -0600
Subject: [llvm-commits] CVS: llvm/lib/Target/ARM/ARMConstantIslandPass.cpp
	ARMISelDAGToDAG.cpp ARMInstrThumb.td
Message-ID: <200701240853.l0O8rxq5010054@zion.cs.uiuc.edu>



Changes in directory llvm/lib/Target/ARM:

ARMConstantIslandPass.cpp updated: 1.1 -> 1.2
ARMISelDAGToDAG.cpp updated: 1.102 -> 1.103
ARMInstrThumb.td updated: 1.2 -> 1.3
---
Log message:

Use PC relative ldr to load from a constantpool in Thumb mode.

---
Diffs of the changes:  (+25 -9)

 ARMConstantIslandPass.cpp |    3 +++
 ARMISelDAGToDAG.cpp       |   25 +++++++++++++++++--------
 ARMInstrThumb.td          |    6 +++++-
 3 files changed, 25 insertions(+), 9 deletions(-)


Index: llvm/lib/Target/ARM/ARMConstantIslandPass.cpp
diff -u llvm/lib/Target/ARM/ARMConstantIslandPass.cpp:1.1 llvm/lib/Target/ARM/ARMConstantIslandPass.cpp:1.2
--- llvm/lib/Target/ARM/ARMConstantIslandPass.cpp:1.1	Fri Jan 19 01:51:42 2007
+++ llvm/lib/Target/ARM/ARMConstantIslandPass.cpp	Wed Jan 24 02:53:17 2007
@@ -245,6 +245,9 @@
           case ARMII::AddrModeT4:
             MaxOffs = 1 << (5+2);
             break;
+          case ARMII::AddrModeTs:
+            MaxOffs = 1 << (8+2);
+            break;
           }
           
           // Remember that this is a user of a CP entry.


Index: llvm/lib/Target/ARM/ARMISelDAGToDAG.cpp
diff -u llvm/lib/Target/ARM/ARMISelDAGToDAG.cpp:1.102 llvm/lib/Target/ARM/ARMISelDAGToDAG.cpp:1.103
--- llvm/lib/Target/ARM/ARMISelDAGToDAG.cpp:1.102	Tue Jan 23 20:45:25 2007
+++ llvm/lib/Target/ARM/ARMISelDAGToDAG.cpp	Wed Jan 24 02:53:17 2007
@@ -380,6 +380,9 @@
     SDOperand TmpBase, TmpOffImm;
     if (SelectThumbAddrModeSP(Op, N, TmpBase, TmpOffImm))
       return false;  // We want to select tLDRspi / tSTRspi instead.
+    if (N.getOpcode() == ARMISD::Wrapper &&
+        N.getOperand(0).getOpcode() == ISD::TargetConstantPool)
+      return false;  // We want to select tLDRpci instead.
   }
 
   if (N.getOpcode() != ISD::ADD) {
@@ -505,14 +508,20 @@
       SDOperand CPIdx =
         CurDAG->getTargetConstantPool(ConstantInt::get(Type::Int32Ty, Val),
                                       TLI.getPointerTy());
-      SDOperand Ops[] = {
-        CPIdx, 
-        CurDAG->getRegister(0, MVT::i32),
-        CurDAG->getTargetConstant(0, MVT::i32),
-        CurDAG->getEntryNode()
-      };
-      SDNode *ResNode = 
-        CurDAG->getTargetNode(ARM::LDR, MVT::i32, MVT::Other, Ops, 4);
+
+      SDNode *ResNode;
+      if (Subtarget->isThumb())
+        ResNode = CurDAG->getTargetNode(ARM::tLDRpci, MVT::i32, MVT::Other,
+                                        CPIdx, CurDAG->getEntryNode());
+      else {
+        SDOperand Ops[] = {
+          CPIdx, 
+          CurDAG->getRegister(0, MVT::i32),
+          CurDAG->getTargetConstant(0, MVT::i32),
+          CurDAG->getEntryNode()
+        };
+        ResNode = CurDAG->getTargetNode(ARM::LDR, MVT::i32, MVT::Other, Ops, 4);
+      }
       ReplaceUses(Op, SDOperand(ResNode, 0));
       return NULL;
     }


Index: llvm/lib/Target/ARM/ARMInstrThumb.td
diff -u llvm/lib/Target/ARM/ARMInstrThumb.td:1.2 llvm/lib/Target/ARM/ARMInstrThumb.td:1.3
--- llvm/lib/Target/ARM/ARMInstrThumb.td:1.2	Tue Jan 23 16:59:13 2007
+++ llvm/lib/Target/ARM/ARMInstrThumb.td	Wed Jan 24 02:53:17 2007
@@ -220,10 +220,14 @@
                  "ldrsh $dst, $addr",
                  [(set GPR:$dst, (sextloadi16 t_addrmode_rr:$addr))]>;
 
-// def tLDRpci
 def tLDRspi : TIs<(ops GPR:$dst, t_addrmode_sp:$addr),
                   "ldr $dst, $addr",
                   [(set GPR:$dst, (load t_addrmode_sp:$addr))]>;
+
+// Load tconstpool
+def tLDRpci : TIs<(ops GPR:$dst, i32imm:$addr),
+                  "ldr $dst, $addr",
+                  [(set GPR:$dst, (load (ARMWrapper tconstpool:$addr)))]>;
 } // isLoad
 
 let isStore = 1 in {





From jlaskey at apple.com  Wed Jan 24 07:12:48 2007
From: jlaskey at apple.com (Jim Laskey)
Date: Wed, 24 Jan 2007 07:12:48 -0600
Subject: [llvm-commits] CVS: llvm/include/llvm/CodeGen/AsmPrinter.h
Message-ID: <200701241312.l0ODCmJ8014806@zion.cs.uiuc.edu>



Changes in directory llvm/include/llvm/CodeGen:

AsmPrinter.h updated: 1.58 -> 1.59
---
Log message:

Use asm printer to emit alignment

---
Diffs of the changes:  (+2 -0)

 AsmPrinter.h |    2 ++
 1 files changed, 2 insertions(+)


Index: llvm/include/llvm/CodeGen/AsmPrinter.h
diff -u llvm/include/llvm/CodeGen/AsmPrinter.h:1.58 llvm/include/llvm/CodeGen/AsmPrinter.h:1.59
--- llvm/include/llvm/CodeGen/AsmPrinter.h:1.58	Sun Dec 17 21:37:18 2006
+++ llvm/include/llvm/CodeGen/AsmPrinter.h	Wed Jan 24 07:12:32 2007
@@ -174,12 +174,14 @@
     /// do nothing and return false.
     bool EmitSpecialLLVMGlobal(const GlobalVariable *GV);
     
+  public:
     /// EmitAlignment - Emit an alignment directive to the specified power of
     /// two boundary.  For example, if you pass in 3 here, you will get an 8
     /// byte alignment.  If a global value is specified, and if that global has
     /// an explicit alignment requested, it will override the alignment request.
     void EmitAlignment(unsigned NumBits, const GlobalValue *GV = 0) const;
 
+  protected:
     /// EmitZeros - Emit a block of zeros.
     ///
     void EmitZeros(uint64_t NumZeros) const;





From jlaskey at apple.com  Wed Jan 24 07:12:50 2007
From: jlaskey at apple.com (Jim Laskey)
Date: Wed, 24 Jan 2007 07:12:50 -0600
Subject: [llvm-commits] CVS: llvm/lib/CodeGen/DwarfWriter.cpp
Message-ID: <200701241312.l0ODCoFm014811@zion.cs.uiuc.edu>



Changes in directory llvm/lib/CodeGen:

DwarfWriter.cpp updated: 1.111 -> 1.112
---
Log message:

Use asm printer to emit alignment

---
Diffs of the changes:  (+2 -8)

 DwarfWriter.cpp |   10 ++--------
 1 files changed, 2 insertions(+), 8 deletions(-)


Index: llvm/lib/CodeGen/DwarfWriter.cpp
diff -u llvm/lib/CodeGen/DwarfWriter.cpp:1.111 llvm/lib/CodeGen/DwarfWriter.cpp:1.112
--- llvm/lib/CodeGen/DwarfWriter.cpp:1.111	Mon Jan  8 16:15:18 2007
+++ llvm/lib/CodeGen/DwarfWriter.cpp	Wed Jan 24 07:12:32 2007
@@ -945,12 +945,6 @@
     O << "\n";
   }
   
-  /// EmitAlign - Print a align directive.
-  ///
-  void EmitAlign(unsigned Alignment) const {
-    O << TAI->getAlignDirective() << Alignment << "\n";
-  }
-                                        
   /// EmitULEB128Bytes - Emit an assembler byte data directive to compose an
   /// unsigned leb128 value.
   void EmitULEB128Bytes(unsigned Value) const {
@@ -2444,7 +2438,7 @@
     EmitFrameMoves(NULL, 0, Moves);
     for (unsigned i = 0, N = Moves.size(); i < N; ++i) delete Moves[i];
 
-    EmitAlign(2);
+    Asm->EmitAlignment(2);
     EmitLabel("frame_common_end", 0);
     
     O << "\n";
@@ -2477,7 +2471,7 @@
     
     EmitFrameMoves("func_begin", SubprogramCount, Moves);
     
-    EmitAlign(2);
+    Asm->EmitAlignment(2);
     EmitLabel("frame_end", SubprogramCount);
 
     O << "\n";





From sabre at nondot.org  Wed Jan 24 12:31:16 2007
From: sabre at nondot.org (Chris Lattner)
Date: Wed, 24 Jan 2007 12:31:16 -0600
Subject: [llvm-commits] CVS: llvm/lib/Target/X86/X86InstrInfo.td
Message-ID: <200701241831.l0OIVG9Y020416@zion.cs.uiuc.edu>



Changes in directory llvm/lib/Target/X86:

X86InstrInfo.td updated: 1.297 -> 1.298
---
Log message:

Fix a misencoding of CBW and CWD.  This fixes PR1030: http://llvm.org/PR1030 .


---
Diffs of the changes:  (+2 -2)

 X86InstrInfo.td |    4 ++--
 1 files changed, 2 insertions(+), 2 deletions(-)


Index: llvm/lib/Target/X86/X86InstrInfo.td
diff -u llvm/lib/Target/X86/X86InstrInfo.td:1.297 llvm/lib/Target/X86/X86InstrInfo.td:1.298
--- llvm/lib/Target/X86/X86InstrInfo.td:1.297	Tue Dec  5 13:50:18 2006
+++ llvm/lib/Target/X86/X86InstrInfo.td	Wed Jan 24 12:31:00 2007
@@ -2394,12 +2394,12 @@
                    [(set GR32:$dst, (zextloadi32i16 addr:$src))]>, TB;
 
 def CBW : I<0x98, RawFrm, (ops),
-            "{cbtw|cbw}", []>, Imp<[AL],[AX]>;   // AX = signext(AL)
+            "{cbtw|cbw}", []>, Imp<[AL],[AX]>, OpSize;   // AX = signext(AL)
 def CWDE : I<0x98, RawFrm, (ops),
             "{cwtl|cwde}", []>, Imp<[AX],[EAX]>;   // EAX = signext(AX)
 
 def CWD : I<0x99, RawFrm, (ops),
-            "{cwtd|cwd}", []>, Imp<[AX],[AX,DX]>;   // DX:AX = signext(AX)
+            "{cwtd|cwd}", []>, Imp<[AX],[AX,DX]>, OpSize; // DX:AX = signext(AX)
 def CDQ : I<0x99, RawFrm, (ops),
             "{cltd|cdq}", []>, Imp<[EAX],[EAX,EDX]>; // EDX:EAX = signext(EAX)
           





From alenhar2 at cs.uiuc.edu  Wed Jan 24 12:43:30 2007
From: alenhar2 at cs.uiuc.edu (Andrew Lenharth)
Date: Wed, 24 Jan 2007 12:43:30 -0600
Subject: [llvm-commits] CVS: llvm/lib/Target/Alpha/AlphaISelDAGToDAG.cpp
Message-ID: <200701241843.l0OIhUOb020838@zion.cs.uiuc.edu>



Changes in directory llvm/lib/Target/Alpha:

AlphaISelDAGToDAG.cpp updated: 1.66 -> 1.67
---
Log message:

Fix unordered fp on alpha

---
Diffs of the changes:  (+35 -15)

 AlphaISelDAGToDAG.cpp |   50 +++++++++++++++++++++++++++++++++++---------------
 1 files changed, 35 insertions(+), 15 deletions(-)


Index: llvm/lib/Target/Alpha/AlphaISelDAGToDAG.cpp
diff -u llvm/lib/Target/Alpha/AlphaISelDAGToDAG.cpp:1.66 llvm/lib/Target/Alpha/AlphaISelDAGToDAG.cpp:1.67
--- llvm/lib/Target/Alpha/AlphaISelDAGToDAG.cpp:1.66	Fri Jan 19 15:13:56 2007
+++ llvm/lib/Target/Alpha/AlphaISelDAGToDAG.cpp	Wed Jan 24 12:43:14 2007
@@ -350,30 +350,50 @@
 
   case ISD::SETCC:
     if (MVT::isFloatingPoint(N->getOperand(0).Val->getValueType(0))) {
-      unsigned Opc = Alpha::WTF;
       ISD::CondCode CC = cast(N->getOperand(2))->get();
+
+      unsigned Opc = Alpha::WTF;
       bool rev = false;
-      bool isNE = false;
+      bool inv = false;
       switch(CC) {
       default: DEBUG(N->dump()); assert(0 && "Unknown FP comparison!");
-      case ISD::SETEQ: case ISD::SETOEQ: case ISD::SETUEQ: Opc = Alpha::CMPTEQ; break;
-      case ISD::SETLT: case ISD::SETOLT: case ISD::SETULT: Opc = Alpha::CMPTLT; break;
-      case ISD::SETLE: case ISD::SETOLE: case ISD::SETULE: Opc = Alpha::CMPTLE; break;
-      case ISD::SETGT: case ISD::SETOGT: case ISD::SETUGT: Opc = Alpha::CMPTLT; rev = true; break;
-      case ISD::SETGE: case ISD::SETOGE: case ISD::SETUGE: Opc = Alpha::CMPTLE; rev = true; break;
-      case ISD::SETNE: case ISD::SETONE: case ISD::SETUNE: Opc = Alpha::CMPTEQ; isNE = true; break;
+      case ISD::SETEQ: case ISD::SETOEQ: case ISD::SETUEQ:
+	Opc = Alpha::CMPTEQ; break;
+      case ISD::SETLT: case ISD::SETOLT: case ISD::SETULT: 
+	Opc = Alpha::CMPTLT; break;
+      case ISD::SETLE: case ISD::SETOLE: case ISD::SETULE: 
+	Opc = Alpha::CMPTLE; break;
+      case ISD::SETGT: case ISD::SETOGT: case ISD::SETUGT: 
+	Opc = Alpha::CMPTLT; rev = true; break;
+      case ISD::SETGE: case ISD::SETOGE: case ISD::SETUGE: 
+	Opc = Alpha::CMPTLE; rev = true; break;
+      case ISD::SETNE: case ISD::SETONE: case ISD::SETUNE:
+	Opc = Alpha::CMPTEQ; inv = true; break;
+      case ISD::SETO:
+	Opc = Alpha::CMPTUN; inv = true; break;
+      case ISD::SETUO:
+	Opc = Alpha::CMPTUN; break;
       };
-      SDOperand tmp1 = N->getOperand(0);
-      SDOperand tmp2 = N->getOperand(1);
+      SDOperand tmp1 = N->getOperand(rev?1:0);
+      SDOperand tmp2 = N->getOperand(rev?0:1);
       AddToISelQueue(tmp1);
       AddToISelQueue(tmp2);
-      SDNode *cmp = CurDAG->getTargetNode(Opc, MVT::f64, 
-                                          rev?tmp2:tmp1,
-                                          rev?tmp1:tmp2);
-      if (isNE) 
+      SDNode *cmp = CurDAG->getTargetNode(Opc, MVT::f64, tmp1, tmp2);
+      if (inv) 
         cmp = CurDAG->getTargetNode(Alpha::CMPTEQ, MVT::f64, SDOperand(cmp, 0), 
                                     CurDAG->getRegister(Alpha::F31, MVT::f64));
-      
+      switch(CC) {
+      case ISD::SETUEQ: case ISD::SETULT: case ISD::SETULE:
+      case ISD::SETUNE: case ISD::SETUGT: case ISD::SETUGE:
+	{
+	  SDNode* cmp2 = CurDAG->getTargetNode(Alpha::CMPTUN, MVT::f64, tmp1, tmp2);
+	  cmp = CurDAG->getTargetNode(Alpha::ADDT, MVT::f64, 
+				      SDOperand(cmp2, 0), SDOperand(cmp, 0));
+	  break;
+	}
+      default: break;
+      }
+
       SDOperand LD;
       if (AlphaLowering.hasITOF()) {
         LD = CurDAG->getNode(AlphaISD::FTOIT_, MVT::i64, SDOperand(cmp, 0));





From jlaskey at apple.com  Wed Jan 24 12:45:32 2007
From: jlaskey at apple.com (Jim Laskey)
Date: Wed, 24 Jan 2007 12:45:32 -0600
Subject: [llvm-commits] CVS: llvm/include/llvm/Target/MRegisterInfo.h
Message-ID: <200701241845.l0OIjWDK020900@zion.cs.uiuc.edu>



Changes in directory llvm/include/llvm/Target:

MRegisterInfo.h updated: 1.87 -> 1.88
---
Log message:

Repair debug frames as a prelude to eh_frames.  Switched to using MachineMoves
by value so that clean up is less confusing (these vectors tend to be small.)


---
Diffs of the changes:  (+1 -1)

 MRegisterInfo.h |    2 +-
 1 files changed, 1 insertion(+), 1 deletion(-)


Index: llvm/include/llvm/Target/MRegisterInfo.h
diff -u llvm/include/llvm/Target/MRegisterInfo.h:1.87 llvm/include/llvm/Target/MRegisterInfo.h:1.88
--- llvm/include/llvm/Target/MRegisterInfo.h:1.87	Mon Jan 22 18:51:23 2007
+++ llvm/include/llvm/Target/MRegisterInfo.h	Wed Jan 24 12:45:12 2007
@@ -456,7 +456,7 @@
   /// getInitialFrameState - Returns a list of machine moves that are assumed
   /// on entry to all functions.  Note that LabelID is ignored (assumed to be
   /// the beginning of the function.)
-  virtual void getInitialFrameState(std::vector &Moves) const;
+  virtual void getInitialFrameState(std::vector &Moves) const;
 };
 
 // This is useful when building DenseMaps keyed on virtual registers





From jlaskey at apple.com  Wed Jan 24 12:45:38 2007
From: jlaskey at apple.com (Jim Laskey)
Date: Wed, 24 Jan 2007 12:45:38 -0600
Subject: [llvm-commits] CVS: llvm/include/llvm/CodeGen/MachineDebugInfo.h
	MachineLocation.h
Message-ID: <200701241845.l0OIjcR9020907@zion.cs.uiuc.edu>



Changes in directory llvm/include/llvm/CodeGen:

MachineDebugInfo.h updated: 1.47 -> 1.48
MachineLocation.h updated: 1.2 -> 1.3
---
Log message:

Repair debug frames as a prelude to eh_frames.  Switched to using MachineMoves
by value so that clean up is less confusing (these vectors tend to be small.)


---
Diffs of the changes:  (+10 -4)

 MachineDebugInfo.h |    4 ++--
 MachineLocation.h  |   10 ++++++++--
 2 files changed, 10 insertions(+), 4 deletions(-)


Index: llvm/include/llvm/CodeGen/MachineDebugInfo.h
diff -u llvm/include/llvm/CodeGen/MachineDebugInfo.h:1.47 llvm/include/llvm/CodeGen/MachineDebugInfo.h:1.48
--- llvm/include/llvm/CodeGen/MachineDebugInfo.h:1.47	Thu Nov 30 08:35:45 2006
+++ llvm/include/llvm/CodeGen/MachineDebugInfo.h	Wed Jan 24 12:45:12 2007
@@ -985,7 +985,7 @@
   
   // FrameMoves - List of moves done by a function's prolog.  Used to construct
   // frame maps by debug consumers.
-  std::vector FrameMoves;
+  std::vector FrameMoves;
 
 public:
   MachineDebugInfo();
@@ -1145,7 +1145,7 @@
   
   /// getFrameMoves - Returns a reference to a list of moves done in the current
   /// function's prologue.  Used to construct frame maps for debug comsumers.
-  std::vector &getFrameMoves() { return FrameMoves; }
+  std::vector &getFrameMoves() { return FrameMoves; }
 
 }; // End class MachineDebugInfo
 


Index: llvm/include/llvm/CodeGen/MachineLocation.h
diff -u llvm/include/llvm/CodeGen/MachineLocation.h:1.2 llvm/include/llvm/CodeGen/MachineLocation.h:1.3
--- llvm/include/llvm/CodeGen/MachineLocation.h:1.2	Fri Apr  7 11:34:45 2006
+++ llvm/include/llvm/CodeGen/MachineLocation.h	Wed Jan 24 12:45:12 2007
@@ -79,10 +79,16 @@
   unsigned LabelID;                     // Label ID number for post-instruction
                                         // address when result of move takes
                                         // effect.
-  const MachineLocation Destination;    // Move to location.
-  const MachineLocation Source;         // Move from location.
+  MachineLocation Destination;          // Move to location.
+  MachineLocation Source;               // Move from location.
   
 public:
+  MachineMove()
+  : LabelID(0)
+  , Destination()
+  , Source()
+  {}
+
   MachineMove(unsigned ID, MachineLocation &D, MachineLocation &S)
   : LabelID(ID)
   , Destination(D)





From jlaskey at apple.com  Wed Jan 24 12:45:38 2007
From: jlaskey at apple.com (Jim Laskey)
Date: Wed, 24 Jan 2007 12:45:38 -0600
Subject: [llvm-commits] CVS: llvm/lib/Target/MRegisterInfo.cpp
Message-ID: <200701241845.l0OIjcJv020912@zion.cs.uiuc.edu>



Changes in directory llvm/lib/Target:

MRegisterInfo.cpp updated: 1.17 -> 1.18
---
Log message:

Repair debug frames as a prelude to eh_frames.  Switched to using MachineMoves
by value so that clean up is less confusing (these vectors tend to be small.)


---
Diffs of the changes:  (+1 -1)

 MRegisterInfo.cpp |    2 +-
 1 files changed, 1 insertion(+), 1 deletion(-)


Index: llvm/lib/Target/MRegisterInfo.cpp
diff -u llvm/lib/Target/MRegisterInfo.cpp:1.17 llvm/lib/Target/MRegisterInfo.cpp:1.18
--- llvm/lib/Target/MRegisterInfo.cpp:1.17	Fri Nov 17 15:19:15 2006
+++ llvm/lib/Target/MRegisterInfo.cpp	Wed Jan 24 12:45:13 2007
@@ -64,7 +64,7 @@
 /// getInitialFrameState - Returns a list of machine moves that are assumed
 /// on entry to a function.
 void
-MRegisterInfo::getInitialFrameState(std::vector &Moves) const {
+MRegisterInfo::getInitialFrameState(std::vector &Moves) const {
   // Default is to do nothing.
 }
 





From jlaskey at apple.com  Wed Jan 24 12:45:38 2007
From: jlaskey at apple.com (Jim Laskey)
Date: Wed, 24 Jan 2007 12:45:38 -0600
Subject: [llvm-commits] CVS: llvm/lib/CodeGen/DwarfWriter.cpp
	MachineDebugInfo.cpp
Message-ID: <200701241845.l0OIjcnO020919@zion.cs.uiuc.edu>



Changes in directory llvm/lib/CodeGen:

DwarfWriter.cpp updated: 1.112 -> 1.113
MachineDebugInfo.cpp updated: 1.69 -> 1.70
---
Log message:

Repair debug frames as a prelude to eh_frames.  Switched to using MachineMoves
by value so that clean up is less confusing (these vectors tend to be small.)


---
Diffs of the changes:  (+28 -16)

 DwarfWriter.cpp      |   43 ++++++++++++++++++++++++++++---------------
 MachineDebugInfo.cpp |    1 -
 2 files changed, 28 insertions(+), 16 deletions(-)


Index: llvm/lib/CodeGen/DwarfWriter.cpp
diff -u llvm/lib/CodeGen/DwarfWriter.cpp:1.112 llvm/lib/CodeGen/DwarfWriter.cpp:1.113
--- llvm/lib/CodeGen/DwarfWriter.cpp:1.112	Wed Jan 24 07:12:32 2007
+++ llvm/lib/CodeGen/DwarfWriter.cpp	Wed Jan 24 12:45:13 2007
@@ -2112,16 +2112,25 @@
   /// EmitFrameMoves - Emit frame instructions to describe the layout of the
   /// frame.
   void EmitFrameMoves(const char *BaseLabel, unsigned BaseLabelID,
-                                   std::vector &Moves) {
+                                   std::vector &Moves) {
+    int stackGrowth =
+        Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
+          TargetFrameInfo::StackGrowsUp ?
+            TAI->getAddressSize() : -TAI->getAddressSize();
+
     for (unsigned i = 0, N = Moves.size(); i < N; ++i) {
-      MachineMove *Move = Moves[i];
-      unsigned LabelID = DebugInfo->MappedLabel(Move->getLabelID());
+      MachineMove &Move = Moves[i];
+      unsigned LabelID = Move.getLabelID();
       
-      // Throw out move if the label is invalid.
-      if (!LabelID) continue;
+      if (LabelID) {
+        LabelID = DebugInfo->MappedLabel(LabelID);
       
-      const MachineLocation &Dst = Move->getDestination();
-      const MachineLocation &Src = Move->getSource();
+        // Throw out move if the label is invalid.
+        if (!LabelID) continue;
+      }
+      
+      const MachineLocation &Dst = Move.getDestination();
+      const MachineLocation &Src = Move.getSource();
       
       // Advance row if new location.
       if (BaseLabel && LabelID && BaseLabelID != LabelID) {
@@ -2134,11 +2143,6 @@
         BaseLabel = "loc";
       }
       
-      int stackGrowth =
-          Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
-            TargetFrameInfo::StackGrowsUp ?
-              TAI->getAddressSize() : -TAI->getAddressSize();
-
       // If advancing cfa.
       if (Dst.isRegister() && Dst.getRegister() == MachineLocation::VirtualFP) {
         if (!Src.isRegister()) {
@@ -2159,6 +2163,16 @@
         } else {
           assert(0 && "Machine move no supported yet.");
         }
+      } else if (Src.isRegister() &&
+        Src.getRegister() == MachineLocation::VirtualFP) {
+        if (Dst.isRegister()) {
+          EmitInt8(DW_CFA_def_cfa_register);
+          EOL("DW_CFA_def_cfa_register");
+          EmitULEB128Bytes(RI->getDwarfRegNum(Dst.getRegister()));
+          EOL("Register");
+        } else {
+          assert(0 && "Machine move no supported yet.");
+        }
       } else {
         unsigned Reg = RI->getDwarfRegNum(Src.getRegister());
         int Offset = Dst.getOffset() / stackGrowth;
@@ -2433,10 +2447,9 @@
     EmitSLEB128Bytes(stackGrowth); EOL("CIE Data Alignment Factor");   
     EmitInt8(RI->getDwarfRegNum(RI->getRARegister())); EOL("CIE RA Column");
     
-    std::vector Moves;
+    std::vector Moves;
     RI->getInitialFrameState(Moves);
     EmitFrameMoves(NULL, 0, Moves);
-    for (unsigned i = 0, N = Moves.size(); i < N; ++i) delete Moves[i];
 
     Asm->EmitAlignment(2);
     EmitLabel("frame_common_end", 0);
@@ -2467,7 +2480,7 @@
                    "func_begin", SubprogramCount);
     EOL("FDE address range");
     
-    std::vector &Moves = DebugInfo->getFrameMoves();
+    std::vector &Moves = DebugInfo->getFrameMoves();
     
     EmitFrameMoves("func_begin", SubprogramCount, Moves);
     


Index: llvm/lib/CodeGen/MachineDebugInfo.cpp
diff -u llvm/lib/CodeGen/MachineDebugInfo.cpp:1.69 llvm/lib/CodeGen/MachineDebugInfo.cpp:1.70
--- llvm/lib/CodeGen/MachineDebugInfo.cpp:1.69	Thu Jan 11 22:24:45 2007
+++ llvm/lib/CodeGen/MachineDebugInfo.cpp	Wed Jan 24 12:45:13 2007
@@ -1505,7 +1505,6 @@
   }
   
   // Clean up frame info.
-  for (unsigned i = 0, N = FrameMoves.size(); i < N; ++i) delete FrameMoves[i];
   FrameMoves.clear();
 }
 





From jlaskey at apple.com  Wed Jan 24 12:45:38 2007
From: jlaskey at apple.com (Jim Laskey)
Date: Wed, 24 Jan 2007 12:45:38 -0600
Subject: [llvm-commits] CVS: llvm/lib/Target/PowerPC/PPCRegisterInfo.cpp
	PPCRegisterInfo.h
Message-ID: <200701241845.l0OIjcuT020924@zion.cs.uiuc.edu>



Changes in directory llvm/lib/Target/PowerPC:

PPCRegisterInfo.cpp updated: 1.96 -> 1.97
PPCRegisterInfo.h updated: 1.22 -> 1.23
---
Log message:

Repair debug frames as a prelude to eh_frames.  Switched to using MachineMoves
by value so that clean up is less confusing (these vectors tend to be small.)


---
Diffs of the changes:  (+44 -16)

 PPCRegisterInfo.cpp |   58 ++++++++++++++++++++++++++++++++++++++--------------
 PPCRegisterInfo.h   |    2 -
 2 files changed, 44 insertions(+), 16 deletions(-)


Index: llvm/lib/Target/PowerPC/PPCRegisterInfo.cpp
diff -u llvm/lib/Target/PowerPC/PPCRegisterInfo.cpp:1.96 llvm/lib/Target/PowerPC/PPCRegisterInfo.cpp:1.97
--- llvm/lib/Target/PowerPC/PPCRegisterInfo.cpp:1.96	Mon Jan 22 18:55:21 2007
+++ llvm/lib/Target/PowerPC/PPCRegisterInfo.cpp	Wed Jan 24 12:45:13 2007
@@ -762,6 +762,10 @@
   MachineFrameInfo *MFI = MF.getFrameInfo();
   MachineDebugInfo *DebugInfo = MFI->getMachineDebugInfo();
   
+  // Prepare for debug frame info.
+  bool hasInfo = DebugInfo && DebugInfo->hasInfo();
+  unsigned FrameLabelId = 0;
+  
   // Scan the prolog, looking for an UPDATE_VRSAVE instruction.  If we find it,
   // process it.
   for (unsigned i = 0; MBBI != MBB.end(); ++i, ++MBBI) {
@@ -821,6 +825,12 @@
   unsigned TargetAlign = MF.getTarget().getFrameInfo()->getStackAlignment();
   unsigned MaxAlign = MFI->getMaxAlignment();
 
+  if (hasInfo) {
+    // Mark effective beginning of when frame pointer becomes valid.
+    FrameLabelId = DebugInfo->NextLabelID();
+    BuildMI(MBB, MBBI, TII.get(PPC::DWARF_LABEL)).addImm(FrameLabelId);
+  }
+  
   // Adjust stack pointer: r1 += NegFrameSize.
   // If there is a preferred stack alignment, align R1 now
   if (!IsPPC64) {
@@ -866,26 +876,44 @@
     }
   }
   
-  if (DebugInfo && DebugInfo->hasInfo()) {
-    std::vector &Moves = DebugInfo->getFrameMoves();
-    unsigned LabelID = DebugInfo->NextLabelID();
+  if (hasInfo) {
+    std::vector &Moves = DebugInfo->getFrameMoves();
     
-    // Mark effective beginning of when frame pointer becomes valid.
-    BuildMI(MBB, MBBI, TII.get(PPC::DWARF_LABEL)).addImm(LabelID);
+    if (NegFrameSize) {
+      // Show update of SP.
+      MachineLocation SPDst(MachineLocation::VirtualFP);
+      MachineLocation SPSrc(MachineLocation::VirtualFP, NegFrameSize);
+      Moves.push_back(MachineMove(FrameLabelId, SPDst, SPSrc));
+    } else {
+      MachineLocation SP(IsPPC64 ? PPC::X31 : PPC::R31);
+      Moves.push_back(MachineMove(FrameLabelId, SP, SP));
+    }
     
-    // Show update of SP.
-    MachineLocation SPDst(MachineLocation::VirtualFP);
-    MachineLocation SPSrc(MachineLocation::VirtualFP, NegFrameSize);
-    Moves.push_back(new MachineMove(LabelID, SPDst, SPSrc));
+    if (HasFP) {
+      MachineLocation FPDst(MachineLocation::VirtualFP, FPOffset);
+      MachineLocation FPSrc(IsPPC64 ? PPC::X31 : PPC::R31);
+      Moves.push_back(MachineMove(FrameLabelId, FPDst, FPSrc));
+    }
 
     // Add callee saved registers to move list.
     const std::vector &CSI = MFI->getCalleeSavedInfo();
     for (unsigned I = 0, E = CSI.size(); I != E; ++I) {
-      MachineLocation CSDst(MachineLocation::VirtualFP,
-                            MFI->getObjectOffset(CSI[I].getFrameIdx()));
-      MachineLocation CSSrc(CSI[I].getReg());
-      Moves.push_back(new MachineMove(LabelID, CSDst, CSSrc));
+      int Offset = MFI->getObjectOffset(CSI[I].getFrameIdx());
+      unsigned Reg = CSI[I].getReg();
+      if (Reg == PPC::LR || Reg == PPC::LR8) continue;
+      MachineLocation CSDst(MachineLocation::VirtualFP, Offset);
+      MachineLocation CSSrc(Reg);
+      Moves.push_back(MachineMove(FrameLabelId, CSDst, CSSrc));
     }
+    
+    // Mark effective beginning of when frame pointer is ready.
+    unsigned ReadyLabelId = DebugInfo->NextLabelID();
+    BuildMI(MBB, MBBI, TII.get(PPC::DWARF_LABEL)).addImm(ReadyLabelId);
+    
+    MachineLocation FPDst(HasFP ? (IsPPC64 ? PPC::X31 : PPC::R31) :
+                                  (IsPPC64 ? PPC::X1 : PPC::R1));
+    MachineLocation FPSrc(MachineLocation::VirtualFP);
+    Moves.push_back(MachineMove(ReadyLabelId, FPDst, FPSrc));
   }
 
   // If there is a frame pointer, copy R1 into R31
@@ -983,12 +1011,12 @@
     return hasFP(MF) ? PPC::X31 : PPC::X1;
 }
 
-void PPCRegisterInfo::getInitialFrameState(std::vector &Moves)
+void PPCRegisterInfo::getInitialFrameState(std::vector &Moves)
                                                                          const {
   // Initial state of the frame pointer is R1.
   MachineLocation Dst(MachineLocation::VirtualFP);
   MachineLocation Src(PPC::R1, 0);
-  Moves.push_back(new MachineMove(0, Dst, Src));
+  Moves.push_back(MachineMove(0, Dst, Src));
 }
 
 #include "PPCGenRegisterInfo.inc"


Index: llvm/lib/Target/PowerPC/PPCRegisterInfo.h
diff -u llvm/lib/Target/PowerPC/PPCRegisterInfo.h:1.22 llvm/lib/Target/PowerPC/PPCRegisterInfo.h:1.23
--- llvm/lib/Target/PowerPC/PPCRegisterInfo.h:1.22	Mon Jan 22 18:55:21 2007
+++ llvm/lib/Target/PowerPC/PPCRegisterInfo.h	Wed Jan 24 12:45:13 2007
@@ -81,7 +81,7 @@
   // Debug information queries.
   unsigned getRARegister() const;
   unsigned getFrameRegister(MachineFunction &MF) const;
-  void getInitialFrameState(std::vector &Moves) const;
+  void getInitialFrameState(std::vector &Moves) const;
 };
 
 } // end namespace llvm





From jlaskey at apple.com  Wed Jan 24 12:51:13 2007
From: jlaskey at apple.com (Jim Laskey)
Date: Wed, 24 Jan 2007 12:51:13 -0600
Subject: [llvm-commits] CVS: llvm/lib/Target/X86/X86RegisterInfo.cpp
Message-ID: <200701241851.l0OIpDaj021035@zion.cs.uiuc.edu>



Changes in directory llvm/lib/Target/X86:

X86RegisterInfo.cpp updated: 1.194 -> 1.195
---
Log message:

80 columns

---
Diffs of the changes:  (+8 -4)

 X86RegisterInfo.cpp |   12 ++++++++----
 1 files changed, 8 insertions(+), 4 deletions(-)


Index: llvm/lib/Target/X86/X86RegisterInfo.cpp
diff -u llvm/lib/Target/X86/X86RegisterInfo.cpp:1.194 llvm/lib/Target/X86/X86RegisterInfo.cpp:1.195
--- llvm/lib/Target/X86/X86RegisterInfo.cpp:1.194	Tue Jan 23 03:38:11 2007
+++ llvm/lib/Target/X86/X86RegisterInfo.cpp	Wed Jan 24 12:50:57 2007
@@ -926,7 +926,8 @@
           unsigned Opc = (Amount < 128) ?
             (Is64Bit ? X86::ADD64ri8 : X86::ADD32ri8) :
             (Is64Bit ? X86::ADD64ri32 : X86::ADD32ri);
-          New = BuildMI(TII.get(Opc),  StackPtr).addReg(StackPtr).addImm(Amount);
+          New = BuildMI(TII.get(Opc),  StackPtr)
+                        .addReg(StackPtr).addImm(Amount);
         }
       }
 
@@ -1044,7 +1045,8 @@
   // If it's main() on Cygwin\Mingw32 we should align stack as well
   if (Fn->hasExternalLinkage() && Fn->getName() == "main" &&
       Subtarget->isTargetCygMing()) {
-    MI= BuildMI(TII.get(X86::AND32ri), X86::ESP).addReg(X86::ESP).addImm(-Align);
+    MI= BuildMI(TII.get(X86::AND32ri), X86::ESP)
+                .addReg(X86::ESP).addImm(-Align);
     MBB.insert(MBBI, MI);
 
     // Probe the stack
@@ -1104,12 +1106,14 @@
         unsigned Opc = (NumBytes < 128) ?
           (Is64Bit ? X86::ADD64ri8 : X86::ADD32ri8) :
           (Is64Bit ? X86::ADD64ri32 : X86::ADD32ri);
-        BuildMI(MBB, MBBI, TII.get(Opc), StackPtr).addReg(StackPtr).addImm(NumBytes);
+        BuildMI(MBB, MBBI, TII.get(Opc), StackPtr)
+                .addReg(StackPtr).addImm(NumBytes);
       } else if ((int)NumBytes < 0) {
         unsigned Opc = (-NumBytes < 128) ?
           (Is64Bit ? X86::SUB64ri8 : X86::SUB32ri8) :
           (Is64Bit ? X86::SUB64ri32 : X86::SUB32ri);
-        BuildMI(MBB, MBBI, TII.get(Opc), StackPtr).addReg(StackPtr).addImm(-NumBytes);
+        BuildMI(MBB, MBBI, TII.get(Opc), StackPtr)
+                .addReg(StackPtr).addImm(-NumBytes);
       }
     }
   }





From jlaskey at apple.com  Wed Jan 24 13:15:40 2007
From: jlaskey at apple.com (Jim Laskey)
Date: Wed, 24 Jan 2007 13:15:40 -0600
Subject: [llvm-commits] CVS: llvm/lib/Target/X86/X86RegisterInfo.h
	X86RegisterInfo.cpp
Message-ID: <200701241915.l0OJFeEK021676@zion.cs.uiuc.edu>



Changes in directory llvm/lib/Target/X86:

X86RegisterInfo.h updated: 1.44 -> 1.45
X86RegisterInfo.cpp updated: 1.195 -> 1.196
---
Log message:

Call frames for intel.

---
Diffs of the changes:  (+52 -0)

 X86RegisterInfo.cpp |   51 +++++++++++++++++++++++++++++++++++++++++++++++++++
 X86RegisterInfo.h   |    1 +
 2 files changed, 52 insertions(+)


Index: llvm/lib/Target/X86/X86RegisterInfo.h
diff -u llvm/lib/Target/X86/X86RegisterInfo.h:1.44 llvm/lib/Target/X86/X86RegisterInfo.h:1.45
--- llvm/lib/Target/X86/X86RegisterInfo.h:1.44	Mon Jan 22 18:57:47 2007
+++ llvm/lib/Target/X86/X86RegisterInfo.h	Wed Jan 24 13:15:24 2007
@@ -94,6 +94,7 @@
   // Debug information queries.
   unsigned getRARegister() const;
   unsigned getFrameRegister(MachineFunction &MF) const;
+  void getInitialFrameState(std::vector &Moves) const;
 };
 
 // getX86SubSuperRegister - X86 utility function. It returns the sub or super


Index: llvm/lib/Target/X86/X86RegisterInfo.cpp
diff -u llvm/lib/Target/X86/X86RegisterInfo.cpp:1.195 llvm/lib/Target/X86/X86RegisterInfo.cpp:1.196
--- llvm/lib/Target/X86/X86RegisterInfo.cpp:1.195	Wed Jan 24 12:50:57 2007
+++ llvm/lib/Target/X86/X86RegisterInfo.cpp	Wed Jan 24 13:15:24 2007
@@ -995,6 +995,11 @@
   const Function* Fn = MF.getFunction();
   const X86Subtarget* Subtarget = &MF.getTarget().getSubtarget();
   MachineInstr *MI;
+  MachineDebugInfo *DebugInfo = MFI->getMachineDebugInfo();
+  
+  // Prepare for debug frame info.
+  bool hasInfo = DebugInfo && DebugInfo->hasInfo();
+  unsigned FrameLabelId = 0;
   
   // Get the number of bytes to allocate from the FrameInfo
   unsigned NumBytes = MFI->getStackSize();
@@ -1018,6 +1023,12 @@
     }
   }
 
+  if (hasInfo) {
+    // Mark effective beginning of when frame pointer becomes valid.
+    FrameLabelId = DebugInfo->NextLabelID();
+    BuildMI(MBB, MBBI, TII.get(X86::DWARF_LABEL)).addImm(FrameLabelId);
+  }
+  
   if (hasFP(MF)) {
     // Get the offset of the stack slot for the EBP register... which is
     // guaranteed to be the last slot by processFunctionBeforeFrameFinalized.
@@ -1042,6 +1053,38 @@
     MBB.insert(MBBI, MI);
   }
 
+  if (hasInfo) {
+    std::vector &Moves = DebugInfo->getFrameMoves();
+    
+    if (NumBytes) {
+      // Show update of SP.
+      MachineLocation SPDst(MachineLocation::VirtualFP);
+      MachineLocation SPSrc(MachineLocation::VirtualFP, -NumBytes);
+      Moves.push_back(MachineMove(FrameLabelId, SPDst, SPSrc));
+    } else {
+      MachineLocation SP(StackPtr);
+      Moves.push_back(MachineMove(FrameLabelId, SP, SP));
+    }
+
+    // Add callee saved registers to move list.
+    const std::vector &CSI = MFI->getCalleeSavedInfo();
+    for (unsigned I = 0, E = CSI.size(); I != E; ++I) {
+      int Offset = MFI->getObjectOffset(CSI[I].getFrameIdx());
+      unsigned Reg = CSI[I].getReg();
+      MachineLocation CSDst(MachineLocation::VirtualFP, Offset);
+      MachineLocation CSSrc(Reg);
+      Moves.push_back(MachineMove(FrameLabelId, CSDst, CSSrc));
+    }
+    
+    // Mark effective beginning of when frame pointer is ready.
+    unsigned ReadyLabelId = DebugInfo->NextLabelID();
+    BuildMI(MBB, MBBI, TII.get(X86::DWARF_LABEL)).addImm(ReadyLabelId);
+    
+    MachineLocation FPDst(hasFP(MF) ? FramePtr : StackPtr);
+    MachineLocation FPSrc(MachineLocation::VirtualFP);
+    Moves.push_back(MachineMove(ReadyLabelId, FPDst, FPSrc));
+  }
+
   // If it's main() on Cygwin\Mingw32 we should align stack as well
   if (Fn->hasExternalLinkage() && Fn->getName() == "main" &&
       Subtarget->isTargetCygMing()) {
@@ -1127,6 +1170,14 @@
   return hasFP(MF) ? FramePtr : StackPtr;
 }
 
+void X86RegisterInfo::getInitialFrameState(std::vector &Moves)
+                                                                         const {
+  // Initial state of the frame pointer is esp.
+  MachineLocation Dst(MachineLocation::VirtualFP);
+  MachineLocation Src(StackPtr, 0);
+  Moves.push_back(MachineMove(0, Dst, Src));
+}
+
 namespace llvm {
 unsigned getX86SubSuperRegister(unsigned Reg, MVT::ValueType VT, bool High) {
   switch (VT) {





From jlaskey at apple.com  Wed Jan 24 13:16:48 2007
From: jlaskey at apple.com (Jim Laskey)
Date: Wed, 24 Jan 2007 15:16:48 -0400
Subject: [llvm-commits] CVS: llvm/lib/Target/X86/X86RegisterInfo.h
	X86RegisterInfo.cpp
In-Reply-To: <200701241915.l0OJFeEK021676@zion.cs.uiuc.edu>
References: <200701241915.l0OJFeEK021676@zion.cs.uiuc.edu>
Message-ID: <4A25A2A2-C87E-4D56-8F51-27E07A1C8A4B@apple.com>

Evan and Reid - feel free to tweak this.  It shouldn't introduce  
problems.

On 24-Jan-07, at 03:15 PM, Jim Laskey wrote:

>
>
> Changes in directory llvm/lib/Target/X86:
>
> X86RegisterInfo.h updated: 1.44 -> 1.45
> X86RegisterInfo.cpp updated: 1.195 -> 1.196
> ---
> Log message:
>
> Call frames for intel.
>
> ---
> Diffs of the changes:  (+52 -0)
>
>  X86RegisterInfo.cpp |   51 ++++++++++++++++++++++++++++++++++++++++ 
> +++++++++++
>  X86RegisterInfo.h   |    1 +
>  2 files changed, 52 insertions(+)
>
>
> Index: llvm/lib/Target/X86/X86RegisterInfo.h
> diff -u llvm/lib/Target/X86/X86RegisterInfo.h:1.44 llvm/lib/Target/ 
> X86/X86RegisterInfo.h:1.45
> --- llvm/lib/Target/X86/X86RegisterInfo.h:1.44	Mon Jan 22 18:57:47  
> 2007
> +++ llvm/lib/Target/X86/X86RegisterInfo.h	Wed Jan 24 13:15:24 2007
> @@ -94,6 +94,7 @@
>    // Debug information queries.
>    unsigned getRARegister() const;
>    unsigned getFrameRegister(MachineFunction &MF) const;
> +  void getInitialFrameState(std::vector &Moves) const;
>  };
>
>  // getX86SubSuperRegister - X86 utility function. It returns the  
> sub or super
>
>
> Index: llvm/lib/Target/X86/X86RegisterInfo.cpp
> diff -u llvm/lib/Target/X86/X86RegisterInfo.cpp:1.195 llvm/lib/ 
> Target/X86/X86RegisterInfo.cpp:1.196
> --- llvm/lib/Target/X86/X86RegisterInfo.cpp:1.195	Wed Jan 24  
> 12:50:57 2007
> +++ llvm/lib/Target/X86/X86RegisterInfo.cpp	Wed Jan 24 13:15:24 2007
> @@ -995,6 +995,11 @@
>    const Function* Fn = MF.getFunction();
>    const X86Subtarget* Subtarget = &MF.getTarget 
> ().getSubtarget();
>    MachineInstr *MI;
> +  MachineDebugInfo *DebugInfo = MFI->getMachineDebugInfo();
> +
> +  // Prepare for debug frame info.
> +  bool hasInfo = DebugInfo && DebugInfo->hasInfo();
> +  unsigned FrameLabelId = 0;
>
>    // Get the number of bytes to allocate from the FrameInfo
>    unsigned NumBytes = MFI->getStackSize();
> @@ -1018,6 +1023,12 @@
>      }
>    }
>
> +  if (hasInfo) {
> +    // Mark effective beginning of when frame pointer becomes valid.
> +    FrameLabelId = DebugInfo->NextLabelID();
> +    BuildMI(MBB, MBBI, TII.get(X86::DWARF_LABEL)).addImm 
> (FrameLabelId);
> +  }
> +
>    if (hasFP(MF)) {
>      // Get the offset of the stack slot for the EBP register...  
> which is
>      // guaranteed to be the last slot by  
> processFunctionBeforeFrameFinalized.
> @@ -1042,6 +1053,38 @@
>      MBB.insert(MBBI, MI);
>    }
>
> +  if (hasInfo) {
> +    std::vector &Moves = DebugInfo->getFrameMoves();
> +
> +    if (NumBytes) {
> +      // Show update of SP.
> +      MachineLocation SPDst(MachineLocation::VirtualFP);
> +      MachineLocation SPSrc(MachineLocation::VirtualFP, -NumBytes);
> +      Moves.push_back(MachineMove(FrameLabelId, SPDst, SPSrc));
> +    } else {
> +      MachineLocation SP(StackPtr);
> +      Moves.push_back(MachineMove(FrameLabelId, SP, SP));
> +    }
> +
> +    // Add callee saved registers to move list.
> +    const std::vector &CSI = MFI- 
> >getCalleeSavedInfo();
> +    for (unsigned I = 0, E = CSI.size(); I != E; ++I) {
> +      int Offset = MFI->getObjectOffset(CSI[I].getFrameIdx());
> +      unsigned Reg = CSI[I].getReg();
> +      MachineLocation CSDst(MachineLocation::VirtualFP, Offset);
> +      MachineLocation CSSrc(Reg);
> +      Moves.push_back(MachineMove(FrameLabelId, CSDst, CSSrc));
> +    }
> +
> +    // Mark effective beginning of when frame pointer is ready.
> +    unsigned ReadyLabelId = DebugInfo->NextLabelID();
> +    BuildMI(MBB, MBBI, TII.get(X86::DWARF_LABEL)).addImm 
> (ReadyLabelId);
> +
> +    MachineLocation FPDst(hasFP(MF) ? FramePtr : StackPtr);
> +    MachineLocation FPSrc(MachineLocation::VirtualFP);
> +    Moves.push_back(MachineMove(ReadyLabelId, FPDst, FPSrc));
> +  }
> +
>    // If it's main() on Cygwin\Mingw32 we should align stack as well
>    if (Fn->hasExternalLinkage() && Fn->getName() == "main" &&
>        Subtarget->isTargetCygMing()) {
> @@ -1127,6 +1170,14 @@
>    return hasFP(MF) ? FramePtr : StackPtr;
>  }
>
> +void X86RegisterInfo::getInitialFrameState 
> (std::vector &Moves)
> +                                                                      
>     const {
> +  // Initial state of the frame pointer is esp.
> +  MachineLocation Dst(MachineLocation::VirtualFP);
> +  MachineLocation Src(StackPtr, 0);
> +  Moves.push_back(MachineMove(0, Dst, Src));
> +}
> +
>  namespace llvm {
>  unsigned getX86SubSuperRegister(unsigned Reg, MVT::ValueType VT,  
> bool High) {
>    switch (VT) {
>
>
>
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits

-------------- next part --------------
A non-text attachment was scrubbed...
Name: smime.p7s
Type: application/pkcs7-signature
Size: 2417 bytes
Desc: not available
Url : http://lists.cs.uiuc.edu/pipermail/llvm-commits/attachments/20070124/d610df08/attachment.bin 

From han at autoesl.com  Wed Jan 24 14:39:59 2007
From: han at autoesl.com (Guoling Han)
Date: Wed, 24 Jan 2007 14:39:59 -0600
Subject: [llvm-commits] CVS:
	llvm-test/SingleSource/UnitTests/Integer/arith.c field.c
	offset.reference_output union-struct.c union2.c
	union2.reference_output
Message-ID: <200701242039.l0OKdxfe023562@zion.cs.uiuc.edu>



Changes in directory llvm-test/SingleSource/UnitTests/Integer:

arith.c updated: 1.6 -> 1.7
field.c updated: 1.5 -> 1.6
offset.reference_output updated: 1.1 -> 1.2
union-struct.c updated: 1.6 -> 1.7
union2.c updated: 1.5 -> 1.6
union2.reference_output updated: 1.1 -> 1.2
---
Log message:

We changed the outputs and reference outputs for these programs. This is mainly because the memory layout for bit-accurate types. For a n bit int type, it will occupy m bits where m is the nearest large number of power of 2. 



---
Diffs of the changes:  (+39 -19)

 arith.c                 |    2 +-
 field.c                 |   28 ++++++++++++++++++----------
 offset.reference_output |    2 +-
 union-struct.c          |    2 +-
 union2.c                |   21 +++++++++++++++------
 union2.reference_output |    3 +++
 6 files changed, 39 insertions(+), 19 deletions(-)


Index: llvm-test/SingleSource/UnitTests/Integer/arith.c
diff -u llvm-test/SingleSource/UnitTests/Integer/arith.c:1.6 llvm-test/SingleSource/UnitTests/Integer/arith.c:1.7
--- llvm-test/SingleSource/UnitTests/Integer/arith.c:1.6	Mon Jan 22 18:17:21 2007
+++ llvm-test/SingleSource/UnitTests/Integer/arith.c	Wed Jan 24 14:39:44 2007
@@ -43,7 +43,7 @@
   l = j / k;
   temp = l;
   printf( "temp = %hd\n", temp);
-  j *= (-176);
+  j *= (-176); // after truncation, the value should be -384
   l = j / k;
   temp = l;
   printf( "temp = %hd\n", temp);


Index: llvm-test/SingleSource/UnitTests/Integer/field.c
diff -u llvm-test/SingleSource/UnitTests/Integer/field.c:1.5 llvm-test/SingleSource/UnitTests/Integer/field.c:1.6
--- llvm-test/SingleSource/UnitTests/Integer/field.c:1.5	Mon Jan 22 18:17:21 2007
+++ llvm-test/SingleSource/UnitTests/Integer/field.c	Wed Jan 24 14:39:44 2007
@@ -9,6 +9,8 @@
 // data layout of the field should be the same as the corresponding
 // struct using bit accurate types.
 //
+// Note: we assume that sizeof(x-bit int) = round up x to the most
+// nearest 2^n. 
 //===----------------------------------------------------------------------===//
 
 
@@ -24,9 +26,9 @@
 typedef char __attribute__ ((bitwidth(7))) char7;
 typedef short __attribute__ ((bitwidth(17))) short17;
 
-typedef struct myStruct{int i; unsigned char c:7; int s:17; char c2;} myStruct;
+typedef struct myStruct{int i; char c:7; int s:17; char c2;} myStruct;
 
-typedef struct myStruct2{int32 i; int7 c;  int17 s; int8 c2;} myStruct2;
+typedef struct myStruct2{int32 i;  int17 s; int7 c; int8 c2;} myStruct2;
 
 int main()
 {
@@ -36,20 +38,26 @@
   void* ptr, *ptr1, *ptr2, *ptr3;
   unsigned int offset, offset1;
 
-  ptr = &(x.i);
-  ptr1 = &(x.c2);
+  // ptr = &(x.i);
+  // ptr1 = &(x.c2);
 
   ptr2 = &(y.i);
   ptr3 = &(y.c2);
 
-  offset = ptr1 - ptr;
+  //offset = ptr1 - ptr;
   offset1 = ptr3 - ptr2;
     
-  if(offset != offset1) 
-    printf("error: offset=%x, offset1=%x\n", offset, offset1);
-  if(sizeof(myStruct) != sizeof(myStruct2))
-    printf("error2: sizeof myStruct = %d, sizeof myStruct2 = %d\n",
-           sizeof(myStruct), sizeof(myStruct2));
+  if(offset1 != 2*sizeof(int) + sizeof(char))
+    printf("error:  offset1=%x\n", offset1);
+
+  x.c = -1;
+  y.c = -1;
+  if(x.c != y.c)
+    printf("error: x.c = %x, y.c = %x\n", x.c, y.c);
+  
+  //if(sizeof(myStruct) != sizeof(myStruct2))
+  //  printf("error2: sizeof myStruct = %d, sizeof myStruct2 = %d\n",
+  //         sizeof(myStruct), sizeof(myStruct2));
 
   return 0;
 }


Index: llvm-test/SingleSource/UnitTests/Integer/offset.reference_output
diff -u llvm-test/SingleSource/UnitTests/Integer/offset.reference_output:1.1 llvm-test/SingleSource/UnitTests/Integer/offset.reference_output:1.2
--- llvm-test/SingleSource/UnitTests/Integer/offset.reference_output:1.1	Thu Jan 18 20:22:46 2007
+++ llvm-test/SingleSource/UnitTests/Integer/offset.reference_output	Wed Jan 24 14:39:44 2007
@@ -1,2 +1,2 @@
-5
+8
 exit 0


Index: llvm-test/SingleSource/UnitTests/Integer/union-struct.c
diff -u llvm-test/SingleSource/UnitTests/Integer/union-struct.c:1.6 llvm-test/SingleSource/UnitTests/Integer/union-struct.c:1.7
--- llvm-test/SingleSource/UnitTests/Integer/union-struct.c:1.6	Mon Jan 22 18:17:21 2007
+++ llvm-test/SingleSource/UnitTests/Integer/union-struct.c	Wed Jan 24 14:39:44 2007
@@ -27,7 +27,7 @@
 
 int main()
 {
-  if( sizeof(struct Blend_Map_Entry) == 5 * sizeof(int) )
+  if( sizeof(struct Blend_Map_Entry) != 5 * sizeof(int) )
     printf("error: %d\n", sizeof(struct Blend_Map_Entry));
   return 0;
 }


Index: llvm-test/SingleSource/UnitTests/Integer/union2.c
diff -u llvm-test/SingleSource/UnitTests/Integer/union2.c:1.5 llvm-test/SingleSource/UnitTests/Integer/union2.c:1.6
--- llvm-test/SingleSource/UnitTests/Integer/union2.c:1.5	Mon Jan 22 18:17:21 2007
+++ llvm-test/SingleSource/UnitTests/Integer/union2.c	Wed Jan 24 14:39:44 2007
@@ -8,6 +8,10 @@
 // This is a test for union type. By assigning values to different
 // fields, we can check whether the assignment is correctly performed.
 //
+// Note: In the current implementation, a 9-bit data will also occupy
+// 2 bytes. So for this example, storing value to the 9-bit field will
+// change the two bytes of the memory.
+//
 //===----------------------------------------------------------------------===//
 
 
@@ -21,12 +25,17 @@
 myStruct test(myUnion u)
 {
   myStruct x;
-
-  u.i31 = 0;
-  u.i = 0xffff;
-  int9* ptr = &(u.i9);
-  *ptr= 0x00;
-
+  int9* ptr;
+  
+  u.i31 = -1;
+  u.i = 0x0;
+  ptr = &(u.i9);
+  *ptr= -1;
+
+  printf("u.i = %hd\n", u.i);
+  printf("u.i9 = %hd\n", u.i9);
+  printf("u.i31 = %d\n", u.i31);
+ 
   x.ptr = ptr;
   x.i = u.i;
 


Index: llvm-test/SingleSource/UnitTests/Integer/union2.reference_output
diff -u llvm-test/SingleSource/UnitTests/Integer/union2.reference_output:1.1 llvm-test/SingleSource/UnitTests/Integer/union2.reference_output:1.2
--- llvm-test/SingleSource/UnitTests/Integer/union2.reference_output:1.1	Thu Jan 18 20:22:46 2007
+++ llvm-test/SingleSource/UnitTests/Integer/union2.reference_output	Wed Jan 24 14:39:44 2007
@@ -1 +1,4 @@
+u.i = 511
+u.i9 = -1
+u.i31 = -65025
 exit 0





From alenhar2 at cs.uiuc.edu  Wed Jan 24 15:09:31 2007
From: alenhar2 at cs.uiuc.edu (Andrew Lenharth)
Date: Wed, 24 Jan 2007 15:09:31 -0600
Subject: [llvm-commits] CVS: llvm/lib/Target/Alpha/Alpha.td
	AlphaAsmPrinter.cpp AlphaISelDAGToDAG.cpp
	AlphaISelLowering.cpp AlphaISelLowering.h AlphaInstrInfo.td
	AlphaSubtarget.cpp AlphaSubtarget.h
Message-ID: <200701242109.l0OL9Vcr024156@zion.cs.uiuc.edu>



Changes in directory llvm/lib/Target/Alpha:

Alpha.td updated: 1.11 -> 1.12
AlphaAsmPrinter.cpp updated: 1.61 -> 1.62
AlphaISelDAGToDAG.cpp updated: 1.67 -> 1.68
AlphaISelLowering.cpp updated: 1.76 -> 1.77
AlphaISelLowering.h updated: 1.23 -> 1.24
AlphaInstrInfo.td updated: 1.136 -> 1.137
AlphaSubtarget.cpp updated: 1.7 -> 1.8
AlphaSubtarget.h updated: 1.5 -> 1.6
---
Log message:

FTOIT and ITOFT are bit converts, and if we drop 21264s, are always available

---
Diffs of the changes:  (+17 -73)

 Alpha.td              |    8 ++------
 AlphaAsmPrinter.cpp   |    7 +++----
 AlphaISelDAGToDAG.cpp |   35 ++++-------------------------------
 AlphaISelLowering.cpp |   27 ++++-----------------------
 AlphaISelLowering.h   |    2 +-
 AlphaInstrInfo.td     |    6 ++----
 AlphaSubtarget.cpp    |    2 +-
 AlphaSubtarget.h      |    3 ---
 8 files changed, 17 insertions(+), 73 deletions(-)


Index: llvm/lib/Target/Alpha/Alpha.td
diff -u llvm/lib/Target/Alpha/Alpha.td:1.11 llvm/lib/Target/Alpha/Alpha.td:1.12
--- llvm/lib/Target/Alpha/Alpha.td:1.11	Wed May 17 19:11:53 2006
+++ llvm/lib/Target/Alpha/Alpha.td	Wed Jan 24 15:09:16 2007
@@ -22,8 +22,6 @@
 
 def FeatureCIX : SubtargetFeature<"CIX", "HasCT", "true",
                                   "Enable CIX extentions">;
-def FeatureFIX : SubtargetFeature<"FIX", "HasF2I", "true",
-                                  "Enable FIX extentions">;
 
 //===----------------------------------------------------------------------===//
 // Register File Description
@@ -54,10 +52,8 @@
 //===----------------------------------------------------------------------===//
 
 def : Processor<"generic", Alpha21264Itineraries, []>;
-def : Processor<"pca56"  , Alpha21264Itineraries, []>;
-def : Processor<"ev56"   , Alpha21264Itineraries, []>;
-def : Processor<"ev6"    , Alpha21264Itineraries, [FeatureFIX]>;
-def : Processor<"ev67"   , Alpha21264Itineraries, [FeatureFIX, FeatureCIX]>;
+def : Processor<"ev6"    , Alpha21264Itineraries, []>;
+def : Processor<"ev67"   , Alpha21264Itineraries, [FeatureCIX]>;
 
 //===----------------------------------------------------------------------===//
 // The Alpha Target


Index: llvm/lib/Target/Alpha/AlphaAsmPrinter.cpp
diff -u llvm/lib/Target/Alpha/AlphaAsmPrinter.cpp:1.61 llvm/lib/Target/Alpha/AlphaAsmPrinter.cpp:1.62
--- llvm/lib/Target/Alpha/AlphaAsmPrinter.cpp:1.61	Wed Jan 24 01:03:39 2007
+++ llvm/lib/Target/Alpha/AlphaAsmPrinter.cpp	Wed Jan 24 15:09:16 2007
@@ -190,11 +190,10 @@
 bool AlphaAsmPrinter::doInitialization(Module &M)
 {
   AsmPrinter::doInitialization(M);
-  if(TM.getSubtarget().hasF2I() 
-     || TM.getSubtarget().hasCT())
-    O << "\t.arch ev6\n";
+  if(TM.getSubtarget().hasCT())
+    O << "\t.arch ev6\n"; //This might need to be ev67, so leave this test here
   else
-    O << "\t.arch ev56\n";
+    O << "\t.arch ev6\n";
   O << "\t.set noat\n";
   return false;
 }


Index: llvm/lib/Target/Alpha/AlphaISelDAGToDAG.cpp
diff -u llvm/lib/Target/Alpha/AlphaISelDAGToDAG.cpp:1.67 llvm/lib/Target/Alpha/AlphaISelDAGToDAG.cpp:1.68
--- llvm/lib/Target/Alpha/AlphaISelDAGToDAG.cpp:1.67	Wed Jan 24 12:43:14 2007
+++ llvm/lib/Target/Alpha/AlphaISelDAGToDAG.cpp	Wed Jan 24 15:09:16 2007
@@ -394,24 +394,10 @@
       default: break;
       }
 
-      SDOperand LD;
-      if (AlphaLowering.hasITOF()) {
-        LD = CurDAG->getNode(AlphaISD::FTOIT_, MVT::i64, SDOperand(cmp, 0));
-      } else {
-        int FrameIdx =
-          CurDAG->getMachineFunction().getFrameInfo()->CreateStackObject(8, 8);
-        SDOperand FI = CurDAG->getFrameIndex(FrameIdx, MVT::i64);
-        SDOperand ST =
-          SDOperand(CurDAG->getTargetNode(Alpha::STT, MVT::Other, 
-                                          SDOperand(cmp, 0), FI,
-                                          CurDAG->getRegister(Alpha::R31, MVT::i64)), 0);
-        LD = SDOperand(CurDAG->getTargetNode(Alpha::LDQ, MVT::i64, FI, 
-                                             CurDAG->getRegister(Alpha::R31, MVT::i64),
-                                             ST), 0);
-      }
+      SDNode* LD = CurDAG->getTargetNode(Alpha::FTOIT, MVT::i64, SDOperand(cmp, 0));
       return CurDAG->getTargetNode(Alpha::CMPULT, MVT::i64, 
                                    CurDAG->getRegister(Alpha::R31, MVT::i64),
-                                   LD);
+                                   SDOperand(LD,0));
     }
     break;
 
@@ -424,7 +410,6 @@
       // so that things like this can be caught in fall though code
       //move int to fp
       bool isDouble = N->getValueType(0) == MVT::f64;
-      SDOperand LD;
       SDOperand cond = N->getOperand(0);
       SDOperand TV = N->getOperand(1);
       SDOperand FV = N->getOperand(2);
@@ -432,21 +417,9 @@
       AddToISelQueue(TV);
       AddToISelQueue(FV);
       
-      if (AlphaLowering.hasITOF()) {
-	LD = CurDAG->getNode(AlphaISD::ITOFT_, MVT::f64, cond);
-      } else {
-	int FrameIdx =
-	  CurDAG->getMachineFunction().getFrameInfo()->CreateStackObject(8, 8);
-	SDOperand FI = CurDAG->getFrameIndex(FrameIdx, MVT::i64);
-	SDOperand ST =
-          SDOperand(CurDAG->getTargetNode(Alpha::STQ, MVT::Other,
-                                          cond, FI, CurDAG->getRegister(Alpha::R31, MVT::i64)), 0);
-	LD = SDOperand(CurDAG->getTargetNode(Alpha::LDT, MVT::f64, FI,
-                                             CurDAG->getRegister(Alpha::R31, MVT::i64),
-                                             ST), 0);
-      }
+      SDNode* LD = CurDAG->getTargetNode(Alpha::ITOFT, MVT::f64, cond);
       return CurDAG->getTargetNode(isDouble?Alpha::FCMOVNET:Alpha::FCMOVNES,
-                                   MVT::f64, FV, TV, LD);
+                                   MVT::f64, FV, TV, SDOperand(LD,0));
     }
     break;
 


Index: llvm/lib/Target/Alpha/AlphaISelLowering.cpp
diff -u llvm/lib/Target/Alpha/AlphaISelLowering.cpp:1.76 llvm/lib/Target/Alpha/AlphaISelLowering.cpp:1.77
--- llvm/lib/Target/Alpha/AlphaISelLowering.cpp:1.76	Sat Dec 30 23:55:36 2006
+++ llvm/lib/Target/Alpha/AlphaISelLowering.cpp	Wed Jan 24 15:09:16 2007
@@ -104,6 +104,8 @@
   
   setOperationAction(ISD::SETCC, MVT::f32, Promote);
 
+  setOperationAction(ISD::BIT_CONVERT, MVT::f32, Promote);
+
   // We don't have line number support yet.
   setOperationAction(ISD::LOCATION, MVT::Other, Expand);
   setOperationAction(ISD::DEBUG_LOC, MVT::Other, Expand);
@@ -143,15 +145,11 @@
   setJumpBufAlignment(16);
 
   computeRegisterProperties();
-
-  useITOF = TM.getSubtarget().hasF2I();
 }
 
 const char *AlphaTargetLowering::getTargetNodeName(unsigned Opcode) const {
   switch (Opcode) {
   default: return 0;
-  case AlphaISD::ITOFT_: return "Alpha::ITOFT_";
-  case AlphaISD::FTOIT_: return "Alpha::FTOIT_";
   case AlphaISD::CVTQT_: return "Alpha::CVTQT_";
   case AlphaISD::CVTQS_: return "Alpha::CVTQS_";
   case AlphaISD::CVTTQ_: return "Alpha::CVTTQ_";
@@ -398,16 +396,7 @@
            "Unhandled SINT_TO_FP type in custom expander!");
     SDOperand LD;
     bool isDouble = MVT::f64 == Op.getValueType();
-    if (useITOF) {
-      LD = DAG.getNode(AlphaISD::ITOFT_, MVT::f64, Op.getOperand(0));
-    } else {
-      int FrameIdx =
-        DAG.getMachineFunction().getFrameInfo()->CreateStackObject(8, 8);
-      SDOperand FI = DAG.getFrameIndex(FrameIdx, MVT::i64);
-      SDOperand ST = DAG.getStore(DAG.getEntryNode(),
-                                  Op.getOperand(0), FI, NULL, 0);
-      LD = DAG.getLoad(MVT::f64, ST, FI, NULL, 0);
-      }
+    LD = DAG.getNode(ISD::BIT_CONVERT, MVT::f64, Op.getOperand(0));
     SDOperand FP = DAG.getNode(isDouble?AlphaISD::CVTQT_:AlphaISD::CVTQS_,
                                isDouble?MVT::f64:MVT::f32, LD);
     return FP;
@@ -421,15 +410,7 @@
     
     src = DAG.getNode(AlphaISD::CVTTQ_, MVT::f64, src);
 
-    if (useITOF) {
-      return DAG.getNode(AlphaISD::FTOIT_, MVT::i64, src);
-    } else {
-      int FrameIdx =
-        DAG.getMachineFunction().getFrameInfo()->CreateStackObject(8, 8);
-      SDOperand FI = DAG.getFrameIndex(FrameIdx, MVT::i64);
-      SDOperand ST = DAG.getStore(DAG.getEntryNode(), src, FI, NULL, 0);
-      return DAG.getLoad(MVT::i64, ST, FI, NULL, 0);
-      }
+    return DAG.getNode(ISD::BIT_CONVERT, MVT::i64, src);
   }
   case ISD::ConstantPool: {
     ConstantPoolSDNode *CP = cast(Op);


Index: llvm/lib/Target/Alpha/AlphaISelLowering.h
diff -u llvm/lib/Target/Alpha/AlphaISelLowering.h:1.23 llvm/lib/Target/Alpha/AlphaISelLowering.h:1.24
--- llvm/lib/Target/Alpha/AlphaISelLowering.h:1.23	Sat Dec 30 23:55:36 2006
+++ llvm/lib/Target/Alpha/AlphaISelLowering.h	Wed Jan 24 15:09:16 2007
@@ -27,7 +27,7 @@
       // Start the numbering where the builting ops and target ops leave off.
       FIRST_NUMBER = ISD::BUILTIN_OP_END+Alpha::INSTRUCTION_LIST_END,
       //These corrospond to the identical Instruction
-      ITOFT_, FTOIT_, CVTQT_, CVTQS_, CVTTQ_,
+      CVTQT_, CVTQS_, CVTTQ_,
 
       /// GPRelHi/GPRelLo - These represent the high and low 16-bit
       /// parts of a global address respectively.


Index: llvm/lib/Target/Alpha/AlphaInstrInfo.td
diff -u llvm/lib/Target/Alpha/AlphaInstrInfo.td:1.136 llvm/lib/Target/Alpha/AlphaInstrInfo.td:1.137
--- llvm/lib/Target/Alpha/AlphaInstrInfo.td:1.136	Thu Dec  7 11:39:14 2006
+++ llvm/lib/Target/Alpha/AlphaInstrInfo.td	Wed Jan 24 15:09:16 2007
@@ -19,8 +19,6 @@
 def SDTFPUnaryOpUnC  : SDTypeProfile<1, 1, [
   SDTCisFP<1>, SDTCisFP<0>
 ]>;
-def Alpha_itoft   : SDNode<"AlphaISD::ITOFT_",    SDTIntToFPOp, []>;
-def Alpha_ftoit   : SDNode<"AlphaISD::FTOIT_",    SDTFPToIntOp, []>;
 def Alpha_cvtqt   : SDNode<"AlphaISD::CVTQT_",    SDTFPUnaryOpUnC, []>;
 def Alpha_cvtqs   : SDNode<"AlphaISD::CVTQS_",    SDTFPUnaryOpUnC, []>;
 def Alpha_cvttq   : SDNode<"AlphaISD::CVTTQ_"  ,  SDTFPUnaryOp, []>;
@@ -745,12 +743,12 @@
 def FTOIS : FPForm<0x1C, 0x078, "ftois $RA,$RC",[], s_ftoi>; //Floating to integer move, S_floating
 let OperandList = (ops GPRC:$RC, F8RC:$RA), Fb = 31 in 
 def FTOIT : FPForm<0x1C, 0x070, "ftoit $RA,$RC",
-        [(set GPRC:$RC, (Alpha_ftoit F8RC:$RA))], s_ftoi>; //Floating to integer move
+        [(set GPRC:$RC, (bitconvert F8RC:$RA))], s_ftoi>; //Floating to integer move
 let OperandList = (ops F4RC:$RC, GPRC:$RA), Fb = 31 in 
 def ITOFS : FPForm<0x14, 0x004, "itofs $RA,$RC",[], s_itof>; //Integer to floating move, S_floating
 let OperandList = (ops F8RC:$RC, GPRC:$RA), Fb = 31 in 
 def ITOFT : FPForm<0x14, 0x024, "itoft $RA,$RC",
-        [(set F8RC:$RC, (Alpha_itoft GPRC:$RA))], s_itof>; //Integer to floating move
+        [(set F8RC:$RC, (bitconvert GPRC:$RA))], s_itof>; //Integer to floating move
 
 
 let OperandList = (ops F4RC:$RC, F8RC:$RB), Fa = 31 in 


Index: llvm/lib/Target/Alpha/AlphaSubtarget.cpp
diff -u llvm/lib/Target/Alpha/AlphaSubtarget.cpp:1.7 llvm/lib/Target/Alpha/AlphaSubtarget.cpp:1.8
--- llvm/lib/Target/Alpha/AlphaSubtarget.cpp:1.7	Wed Oct 26 12:30:34 2005
+++ llvm/lib/Target/Alpha/AlphaSubtarget.cpp	Wed Jan 24 15:09:16 2007
@@ -17,7 +17,7 @@
 using namespace llvm;
 
 AlphaSubtarget::AlphaSubtarget(const Module &M, const std::string &FS)
-  : HasF2I(false), HasCT(false) {
+  : HasCT(false) {
   std::string CPU = "generic";
 
   // Parse features string.


Index: llvm/lib/Target/Alpha/AlphaSubtarget.h
diff -u llvm/lib/Target/Alpha/AlphaSubtarget.h:1.5 llvm/lib/Target/Alpha/AlphaSubtarget.h:1.6
--- llvm/lib/Target/Alpha/AlphaSubtarget.h:1.5	Thu Mar  9 11:16:45 2006
+++ llvm/lib/Target/Alpha/AlphaSubtarget.h	Wed Jan 24 15:09:16 2007
@@ -25,8 +25,6 @@
 class AlphaSubtarget : public TargetSubtarget {
 protected:
 
-  /// Used by the ISel to turn in optimizations for POWER4-derived architectures
-  bool HasF2I;
   bool HasCT;
 
   InstrItineraryData InstrItins;
@@ -41,7 +39,6 @@
   /// subtarget options.  Definition of function is auto generated by tblgen.
   void ParseSubtargetFeatures(const std::string &FS, const std::string &CPU);
 
-  bool hasF2I() const { return HasF2I; }
   bool hasCT() const { return HasCT; }
 };
 } // End llvm namespace





From andrewl at lenharth.org  Wed Jan 24 15:19:26 2007
From: andrewl at lenharth.org (Andrew Lenharth)
Date: Wed, 24 Jan 2007 15:19:26 -0600
Subject: [llvm-commits] CVS: llvm/lib/Target/Alpha/Alpha.td
	AlphaAsmPrinter.cpp AlphaISelDAGToDAG.cpp
	AlphaISelLowering.cpp AlphaISelLowering.h AlphaInstrInfo.td
	AlphaSubtarget.cpp AlphaSubtarget.h
In-Reply-To: <200701242109.l0OL9Vcr024156@zion.cs.uiuc.edu>
References: <200701242109.l0OL9Vcr024156@zion.cs.uiuc.edu>
Message-ID: <85dfcd7f0701241319s4fa0099es4d072da385dfb1c@mail.gmail.com>

Err, um, I meant 21164.  dropping 21264 would be bad...

On 1/24/07, Andrew Lenharth  wrote:
>
>
> Changes in directory llvm/lib/Target/Alpha:
>
> Alpha.td updated: 1.11 -> 1.12
> AlphaAsmPrinter.cpp updated: 1.61 -> 1.62
> AlphaISelDAGToDAG.cpp updated: 1.67 -> 1.68
> AlphaISelLowering.cpp updated: 1.76 -> 1.77
> AlphaISelLowering.h updated: 1.23 -> 1.24
> AlphaInstrInfo.td updated: 1.136 -> 1.137
> AlphaSubtarget.cpp updated: 1.7 -> 1.8
> AlphaSubtarget.h updated: 1.5 -> 1.6
> ---
> Log message:
>
> FTOIT and ITOFT are bit converts, and if we drop 21264s, are always available
>
> ---
> Diffs of the changes:  (+17 -73)
>
>  Alpha.td              |    8 ++------
>  AlphaAsmPrinter.cpp   |    7 +++----
>  AlphaISelDAGToDAG.cpp |   35 ++++-------------------------------
>  AlphaISelLowering.cpp |   27 ++++-----------------------
>  AlphaISelLowering.h   |    2 +-
>  AlphaInstrInfo.td     |    6 ++----
>  AlphaSubtarget.cpp    |    2 +-
>  AlphaSubtarget.h      |    3 ---
>  8 files changed, 17 insertions(+), 73 deletions(-)
>
>
> Index: llvm/lib/Target/Alpha/Alpha.td
> diff -u llvm/lib/Target/Alpha/Alpha.td:1.11 llvm/lib/Target/Alpha/Alpha.td:1.12
> --- llvm/lib/Target/Alpha/Alpha.td:1.11 Wed May 17 19:11:53 2006
> +++ llvm/lib/Target/Alpha/Alpha.td      Wed Jan 24 15:09:16 2007
> @@ -22,8 +22,6 @@
>
>  def FeatureCIX : SubtargetFeature<"CIX", "HasCT", "true",
>                                    "Enable CIX extentions">;
> -def FeatureFIX : SubtargetFeature<"FIX", "HasF2I", "true",
> -                                  "Enable FIX extentions">;
>
>  //===----------------------------------------------------------------------===//
>  // Register File Description
> @@ -54,10 +52,8 @@
>  //===----------------------------------------------------------------------===//
>
>  def : Processor<"generic", Alpha21264Itineraries, []>;
> -def : Processor<"pca56"  , Alpha21264Itineraries, []>;
> -def : Processor<"ev56"   , Alpha21264Itineraries, []>;
> -def : Processor<"ev6"    , Alpha21264Itineraries, [FeatureFIX]>;
> -def : Processor<"ev67"   , Alpha21264Itineraries, [FeatureFIX, FeatureCIX]>;
> +def : Processor<"ev6"    , Alpha21264Itineraries, []>;
> +def : Processor<"ev67"   , Alpha21264Itineraries, [FeatureCIX]>;
>
>  //===----------------------------------------------------------------------===//
>  // The Alpha Target
>
>
> Index: llvm/lib/Target/Alpha/AlphaAsmPrinter.cpp
> diff -u llvm/lib/Target/Alpha/AlphaAsmPrinter.cpp:1.61 llvm/lib/Target/Alpha/AlphaAsmPrinter.cpp:1.62
> --- llvm/lib/Target/Alpha/AlphaAsmPrinter.cpp:1.61      Wed Jan 24 01:03:39 2007
> +++ llvm/lib/Target/Alpha/AlphaAsmPrinter.cpp   Wed Jan 24 15:09:16 2007
> @@ -190,11 +190,10 @@
>  bool AlphaAsmPrinter::doInitialization(Module &M)
>  {
>    AsmPrinter::doInitialization(M);
> -  if(TM.getSubtarget().hasF2I()
> -     || TM.getSubtarget().hasCT())
> -    O << "\t.arch ev6\n";
> +  if(TM.getSubtarget().hasCT())
> +    O << "\t.arch ev6\n"; //This might need to be ev67, so leave this test here
>    else
> -    O << "\t.arch ev56\n";
> +    O << "\t.arch ev6\n";
>    O << "\t.set noat\n";
>    return false;
>  }
>
>
> Index: llvm/lib/Target/Alpha/AlphaISelDAGToDAG.cpp
> diff -u llvm/lib/Target/Alpha/AlphaISelDAGToDAG.cpp:1.67 llvm/lib/Target/Alpha/AlphaISelDAGToDAG.cpp:1.68
> --- llvm/lib/Target/Alpha/AlphaISelDAGToDAG.cpp:1.67    Wed Jan 24 12:43:14 2007
> +++ llvm/lib/Target/Alpha/AlphaISelDAGToDAG.cpp Wed Jan 24 15:09:16 2007
> @@ -394,24 +394,10 @@
>        default: break;
>        }
>
> -      SDOperand LD;
> -      if (AlphaLowering.hasITOF()) {
> -        LD = CurDAG->getNode(AlphaISD::FTOIT_, MVT::i64, SDOperand(cmp, 0));
> -      } else {
> -        int FrameIdx =
> -          CurDAG->getMachineFunction().getFrameInfo()->CreateStackObject(8, 8);
> -        SDOperand FI = CurDAG->getFrameIndex(FrameIdx, MVT::i64);
> -        SDOperand ST =
> -          SDOperand(CurDAG->getTargetNode(Alpha::STT, MVT::Other,
> -                                          SDOperand(cmp, 0), FI,
> -                                          CurDAG->getRegister(Alpha::R31, MVT::i64)), 0);
> -        LD = SDOperand(CurDAG->getTargetNode(Alpha::LDQ, MVT::i64, FI,
> -                                             CurDAG->getRegister(Alpha::R31, MVT::i64),
> -                                             ST), 0);
> -      }
> +      SDNode* LD = CurDAG->getTargetNode(Alpha::FTOIT, MVT::i64, SDOperand(cmp, 0));
>        return CurDAG->getTargetNode(Alpha::CMPULT, MVT::i64,
>                                     CurDAG->getRegister(Alpha::R31, MVT::i64),
> -                                   LD);
> +                                   SDOperand(LD,0));
>      }
>      break;
>
> @@ -424,7 +410,6 @@
>        // so that things like this can be caught in fall though code
>        //move int to fp
>        bool isDouble = N->getValueType(0) == MVT::f64;
> -      SDOperand LD;
>        SDOperand cond = N->getOperand(0);
>        SDOperand TV = N->getOperand(1);
>        SDOperand FV = N->getOperand(2);
> @@ -432,21 +417,9 @@
>        AddToISelQueue(TV);
>        AddToISelQueue(FV);
>
> -      if (AlphaLowering.hasITOF()) {
> -       LD = CurDAG->getNode(AlphaISD::ITOFT_, MVT::f64, cond);
> -      } else {
> -       int FrameIdx =
> -         CurDAG->getMachineFunction().getFrameInfo()->CreateStackObject(8, 8);
> -       SDOperand FI = CurDAG->getFrameIndex(FrameIdx, MVT::i64);
> -       SDOperand ST =
> -          SDOperand(CurDAG->getTargetNode(Alpha::STQ, MVT::Other,
> -                                          cond, FI, CurDAG->getRegister(Alpha::R31, MVT::i64)), 0);
> -       LD = SDOperand(CurDAG->getTargetNode(Alpha::LDT, MVT::f64, FI,
> -                                             CurDAG->getRegister(Alpha::R31, MVT::i64),
> -                                             ST), 0);
> -      }
> +      SDNode* LD = CurDAG->getTargetNode(Alpha::ITOFT, MVT::f64, cond);
>        return CurDAG->getTargetNode(isDouble?Alpha::FCMOVNET:Alpha::FCMOVNES,
> -                                   MVT::f64, FV, TV, LD);
> +                                   MVT::f64, FV, TV, SDOperand(LD,0));
>      }
>      break;
>
>
>
> Index: llvm/lib/Target/Alpha/AlphaISelLowering.cpp
> diff -u llvm/lib/Target/Alpha/AlphaISelLowering.cpp:1.76 llvm/lib/Target/Alpha/AlphaISelLowering.cpp:1.77
> --- llvm/lib/Target/Alpha/AlphaISelLowering.cpp:1.76    Sat Dec 30 23:55:36 2006
> +++ llvm/lib/Target/Alpha/AlphaISelLowering.cpp Wed Jan 24 15:09:16 2007
> @@ -104,6 +104,8 @@
>
>    setOperationAction(ISD::SETCC, MVT::f32, Promote);
>
> +  setOperationAction(ISD::BIT_CONVERT, MVT::f32, Promote);
> +
>    // We don't have line number support yet.
>    setOperationAction(ISD::LOCATION, MVT::Other, Expand);
>    setOperationAction(ISD::DEBUG_LOC, MVT::Other, Expand);
> @@ -143,15 +145,11 @@
>    setJumpBufAlignment(16);
>
>    computeRegisterProperties();
> -
> -  useITOF = TM.getSubtarget().hasF2I();
>  }
>
>  const char *AlphaTargetLowering::getTargetNodeName(unsigned Opcode) const {
>    switch (Opcode) {
>    default: return 0;
> -  case AlphaISD::ITOFT_: return "Alpha::ITOFT_";
> -  case AlphaISD::FTOIT_: return "Alpha::FTOIT_";
>    case AlphaISD::CVTQT_: return "Alpha::CVTQT_";
>    case AlphaISD::CVTQS_: return "Alpha::CVTQS_";
>    case AlphaISD::CVTTQ_: return "Alpha::CVTTQ_";
> @@ -398,16 +396,7 @@
>             "Unhandled SINT_TO_FP type in custom expander!");
>      SDOperand LD;
>      bool isDouble = MVT::f64 == Op.getValueType();
> -    if (useITOF) {
> -      LD = DAG.getNode(AlphaISD::ITOFT_, MVT::f64, Op.getOperand(0));
> -    } else {
> -      int FrameIdx =
> -        DAG.getMachineFunction().getFrameInfo()->CreateStackObject(8, 8);
> -      SDOperand FI = DAG.getFrameIndex(FrameIdx, MVT::i64);
> -      SDOperand ST = DAG.getStore(DAG.getEntryNode(),
> -                                  Op.getOperand(0), FI, NULL, 0);
> -      LD = DAG.getLoad(MVT::f64, ST, FI, NULL, 0);
> -      }
> +    LD = DAG.getNode(ISD::BIT_CONVERT, MVT::f64, Op.getOperand(0));
>      SDOperand FP = DAG.getNode(isDouble?AlphaISD::CVTQT_:AlphaISD::CVTQS_,
>                                 isDouble?MVT::f64:MVT::f32, LD);
>      return FP;
> @@ -421,15 +410,7 @@
>
>      src = DAG.getNode(AlphaISD::CVTTQ_, MVT::f64, src);
>
> -    if (useITOF) {
> -      return DAG.getNode(AlphaISD::FTOIT_, MVT::i64, src);
> -    } else {
> -      int FrameIdx =
> -        DAG.getMachineFunction().getFrameInfo()->CreateStackObject(8, 8);
> -      SDOperand FI = DAG.getFrameIndex(FrameIdx, MVT::i64);
> -      SDOperand ST = DAG.getStore(DAG.getEntryNode(), src, FI, NULL, 0);
> -      return DAG.getLoad(MVT::i64, ST, FI, NULL, 0);
> -      }
> +    return DAG.getNode(ISD::BIT_CONVERT, MVT::i64, src);
>    }
>    case ISD::ConstantPool: {
>      ConstantPoolSDNode *CP = cast(Op);
>
>
> Index: llvm/lib/Target/Alpha/AlphaISelLowering.h
> diff -u llvm/lib/Target/Alpha/AlphaISelLowering.h:1.23 llvm/lib/Target/Alpha/AlphaISelLowering.h:1.24
> --- llvm/lib/Target/Alpha/AlphaISelLowering.h:1.23      Sat Dec 30 23:55:36 2006
> +++ llvm/lib/Target/Alpha/AlphaISelLowering.h   Wed Jan 24 15:09:16 2007
> @@ -27,7 +27,7 @@
>        // Start the numbering where the builting ops and target ops leave off.
>        FIRST_NUMBER = ISD::BUILTIN_OP_END+Alpha::INSTRUCTION_LIST_END,
>        //These corrospond to the identical Instruction
> -      ITOFT_, FTOIT_, CVTQT_, CVTQS_, CVTTQ_,
> +      CVTQT_, CVTQS_, CVTTQ_,
>
>        /// GPRelHi/GPRelLo - These represent the high and low 16-bit
>        /// parts of a global address respectively.
>
>
> Index: llvm/lib/Target/Alpha/AlphaInstrInfo.td
> diff -u llvm/lib/Target/Alpha/AlphaInstrInfo.td:1.136 llvm/lib/Target/Alpha/AlphaInstrInfo.td:1.137
> --- llvm/lib/Target/Alpha/AlphaInstrInfo.td:1.136       Thu Dec  7 11:39:14 2006
> +++ llvm/lib/Target/Alpha/AlphaInstrInfo.td     Wed Jan 24 15:09:16 2007
> @@ -19,8 +19,6 @@
>  def SDTFPUnaryOpUnC  : SDTypeProfile<1, 1, [
>    SDTCisFP<1>, SDTCisFP<0>
>  ]>;
> -def Alpha_itoft   : SDNode<"AlphaISD::ITOFT_",    SDTIntToFPOp, []>;
> -def Alpha_ftoit   : SDNode<"AlphaISD::FTOIT_",    SDTFPToIntOp, []>;
>  def Alpha_cvtqt   : SDNode<"AlphaISD::CVTQT_",    SDTFPUnaryOpUnC, []>;
>  def Alpha_cvtqs   : SDNode<"AlphaISD::CVTQS_",    SDTFPUnaryOpUnC, []>;
>  def Alpha_cvttq   : SDNode<"AlphaISD::CVTTQ_"  ,  SDTFPUnaryOp, []>;
> @@ -745,12 +743,12 @@
>  def FTOIS : FPForm<0x1C, 0x078, "ftois $RA,$RC",[], s_ftoi>; //Floating to integer move, S_floating
>  let OperandList = (ops GPRC:$RC, F8RC:$RA), Fb = 31 in
>  def FTOIT : FPForm<0x1C, 0x070, "ftoit $RA,$RC",
> -        [(set GPRC:$RC, (Alpha_ftoit F8RC:$RA))], s_ftoi>; //Floating to integer move
> +        [(set GPRC:$RC, (bitconvert F8RC:$RA))], s_ftoi>; //Floating to integer move
>  let OperandList = (ops F4RC:$RC, GPRC:$RA), Fb = 31 in
>  def ITOFS : FPForm<0x14, 0x004, "itofs $RA,$RC",[], s_itof>; //Integer to floating move, S_floating
>  let OperandList = (ops F8RC:$RC, GPRC:$RA), Fb = 31 in
>  def ITOFT : FPForm<0x14, 0x024, "itoft $RA,$RC",
> -        [(set F8RC:$RC, (Alpha_itoft GPRC:$RA))], s_itof>; //Integer to floating move
> +        [(set F8RC:$RC, (bitconvert GPRC:$RA))], s_itof>; //Integer to floating move
>
>
>  let OperandList = (ops F4RC:$RC, F8RC:$RB), Fa = 31 in
>
>
> Index: llvm/lib/Target/Alpha/AlphaSubtarget.cpp
> diff -u llvm/lib/Target/Alpha/AlphaSubtarget.cpp:1.7 llvm/lib/Target/Alpha/AlphaSubtarget.cpp:1.8
> --- llvm/lib/Target/Alpha/AlphaSubtarget.cpp:1.7        Wed Oct 26 12:30:34 2005
> +++ llvm/lib/Target/Alpha/AlphaSubtarget.cpp    Wed Jan 24 15:09:16 2007
> @@ -17,7 +17,7 @@
>  using namespace llvm;
>
>  AlphaSubtarget::AlphaSubtarget(const Module &M, const std::string &FS)
> -  : HasF2I(false), HasCT(false) {
> +  : HasCT(false) {
>    std::string CPU = "generic";
>
>    // Parse features string.
>
>
> Index: llvm/lib/Target/Alpha/AlphaSubtarget.h
> diff -u llvm/lib/Target/Alpha/AlphaSubtarget.h:1.5 llvm/lib/Target/Alpha/AlphaSubtarget.h:1.6
> --- llvm/lib/Target/Alpha/AlphaSubtarget.h:1.5  Thu Mar  9 11:16:45 2006
> +++ llvm/lib/Target/Alpha/AlphaSubtarget.h      Wed Jan 24 15:09:16 2007
> @@ -25,8 +25,6 @@
>  class AlphaSubtarget : public TargetSubtarget {
>  protected:
>
> -  /// Used by the ISel to turn in optimizations for POWER4-derived architectures
> -  bool HasF2I;
>    bool HasCT;
>
>    InstrItineraryData InstrItins;
> @@ -41,7 +39,6 @@
>    /// subtarget options.  Definition of function is auto generated by tblgen.
>    void ParseSubtargetFeatures(const std::string &FS, const std::string &CPU);
>
> -  bool hasF2I() const { return HasF2I; }
>    bool hasCT() const { return HasCT; }
>  };
>  } // End llvm namespace
>
>
>
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
>


From sabre at nondot.org  Wed Jan 24 20:52:49 2007
From: sabre at nondot.org (Chris Lattner)
Date: Wed, 24 Jan 2007 20:52:49 -0600
Subject: [llvm-commits] CVS:
	llvm/test/CFrontend/2007-01-24-InlineAsmCModifier.c
Message-ID: <200701250252.l0P2qnqF031202@zion.cs.uiuc.edu>



Changes in directory llvm/test/CFrontend:

2007-01-24-InlineAsmCModifier.c added (r1.1)
---
Log message:

new testcase


---
Diffs of the changes:  (+9 -0)

 2007-01-24-InlineAsmCModifier.c |    9 +++++++++
 1 files changed, 9 insertions(+)


Index: llvm/test/CFrontend/2007-01-24-InlineAsmCModifier.c
diff -c /dev/null llvm/test/CFrontend/2007-01-24-InlineAsmCModifier.c:1.1
*** /dev/null	Wed Jan 24 20:52:43 2007
--- llvm/test/CFrontend/2007-01-24-InlineAsmCModifier.c	Wed Jan 24 20:52:33 2007
***************
*** 0 ****
--- 1,9 ----
+ // Verify that the %c modifier works and strips off any prefixes from immediates.
+ // RUN: %llvmgcc -S %s -o - | llvm-as | llc | grep 'pickANumber: 789514'
+ 
+ void foo() {
+   __asm__         volatile("/* " "pickANumber" ": %c0 */"::"i"(0xC0C0A));
+   
+   // Check that non-c modifiers work also (not greped for above).
+    __asm__         volatile("/* " "pickANumber2 " ": %0 */"::"i"(123));
+ }





From sabre at nondot.org  Wed Jan 24 20:53:06 2007
From: sabre at nondot.org (Chris Lattner)
Date: Wed, 24 Jan 2007 20:53:06 -0600
Subject: [llvm-commits] CVS: llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp
Message-ID: <200701250253.l0P2r6lr031255@zion.cs.uiuc.edu>



Changes in directory llvm/lib/Target/PowerPC:

PPCAsmPrinter.cpp updated: 1.228 -> 1.229
---
Log message:

Fix test/CFrontend/2007-01-24-InlineAsmCModifier.c on PPC


---
Diffs of the changes:  (+4 -0)

 PPCAsmPrinter.cpp |    4 ++++
 1 files changed, 4 insertions(+)


Index: llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp
diff -u llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp:1.228 llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp:1.229
--- llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp:1.228	Sun Jan 14 00:37:54 2007
+++ llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp	Wed Jan 24 20:52:50 2007
@@ -412,6 +412,10 @@
     
     switch (ExtraCode[0]) {
     default: return true;  // Unknown modifier.
+    case 'c': // Don't print "$" before a global var name or constant.
+      // PPC never has a prefix.
+      printOperand(MI, OpNo);
+      return false;
     case 'L': // Write second word of DImode reference.  
       // Verify that this operand has two consecutive registers.
       if (!MI->getOperand(OpNo).isRegister() ||





From sabre at nondot.org  Wed Jan 24 20:53:40 2007
From: sabre at nondot.org (Chris Lattner)
Date: Wed, 24 Jan 2007 20:53:40 -0600
Subject: [llvm-commits] CVS: llvm/lib/Target/X86/X86ATTAsmPrinter.cpp
Message-ID: <200701250253.l0P2resM031273@zion.cs.uiuc.edu>



Changes in directory llvm/lib/Target/X86:

X86ATTAsmPrinter.cpp updated: 1.93 -> 1.94
---
Log message:

Fix test/CFrontend/2007-01-24-InlineAsmCModifier.c on X86.  The %c modifier
says that no $ prefix should be emitted on X86.


---
Diffs of the changes:  (+3 -2)

 X86ATTAsmPrinter.cpp |    5 +++--
 1 files changed, 3 insertions(+), 2 deletions(-)


Index: llvm/lib/Target/X86/X86ATTAsmPrinter.cpp
diff -u llvm/lib/Target/X86/X86ATTAsmPrinter.cpp:1.93 llvm/lib/Target/X86/X86ATTAsmPrinter.cpp:1.94
--- llvm/lib/Target/X86/X86ATTAsmPrinter.cpp:1.93	Thu Jan 18 16:27:12 2007
+++ llvm/lib/Target/X86/X86ATTAsmPrinter.cpp	Wed Jan 24 20:53:24 2007
@@ -219,7 +219,8 @@
   }
 
   case MachineOperand::MO_Immediate:
-    if (!Modifier || strcmp(Modifier, "debug") != 0)
+    if (!Modifier ||
+        (strcmp(Modifier, "debug") && strcmp(Modifier, "mem")))
       O << '$';
     O << MO.getImmedValue();
     return;
@@ -491,7 +492,7 @@
     
     switch (ExtraCode[0]) {
     default: return true;  // Unknown modifier.
-    case 'c': // Don't print "$" before a global var name.
+    case 'c': // Don't print "$" before a global var name or constant.
       printOperand(MI, OpNo, "mem");
       return false;
     case 'b': // Print QImode register





From evan.cheng at apple.com  Wed Jan 24 21:07:42 2007
From: evan.cheng at apple.com (Evan Cheng)
Date: Wed, 24 Jan 2007 21:07:42 -0600
Subject: [llvm-commits] CVS: llvm/lib/Target/ARM/ARMAsmPrinter.cpp
	ARMMachineFunctionInfo.h ARMRegisterInfo.h
Message-ID: <200701250307.l0P37gKT031593@zion.cs.uiuc.edu>



Changes in directory llvm/lib/Target/ARM:

ARMAsmPrinter.cpp updated: 1.46 -> 1.47
ARMMachineFunctionInfo.h updated: 1.2 -> 1.3
ARMRegisterInfo.h updated: 1.6 -> 1.7
---
Log message:

Getting rid uses of evil std::set<>

---
Diffs of the changes:  (+39 -23)

 ARMAsmPrinter.cpp        |    1 
 ARMMachineFunctionInfo.h |   60 ++++++++++++++++++++++++++++++-----------------
 ARMRegisterInfo.h        |    1 
 3 files changed, 39 insertions(+), 23 deletions(-)


Index: llvm/lib/Target/ARM/ARMAsmPrinter.cpp
diff -u llvm/lib/Target/ARM/ARMAsmPrinter.cpp:1.46 llvm/lib/Target/ARM/ARMAsmPrinter.cpp:1.47
--- llvm/lib/Target/ARM/ARMAsmPrinter.cpp:1.46	Tue Jan 23 16:59:13 2007
+++ llvm/lib/Target/ARM/ARMAsmPrinter.cpp	Wed Jan 24 21:07:27 2007
@@ -37,7 +37,6 @@
 #include "llvm/Support/MathExtras.h"
 #include 
 #include 
-#include 
 using namespace llvm;
 
 STATISTIC(EmittedInsts, "Number of machine instrs printed");


Index: llvm/lib/Target/ARM/ARMMachineFunctionInfo.h
diff -u llvm/lib/Target/ARM/ARMMachineFunctionInfo.h:1.2 llvm/lib/Target/ARM/ARMMachineFunctionInfo.h:1.3
--- llvm/lib/Target/ARM/ARMMachineFunctionInfo.h:1.2	Fri Jan 19 20:09:25 2007
+++ llvm/lib/Target/ARM/ARMMachineFunctionInfo.h	Wed Jan 24 21:07:27 2007
@@ -60,9 +60,9 @@
 
   /// GPRCS1Frames, GPRCS2Frames, DPRCSFrames - Keeps track of frame indices
   /// which belong to these spill areas.
-  std::set GPRCS1Frames;
-  std::set GPRCS2Frames;
-  std::set DPRCSFrames;
+  std::vector GPRCS1Frames;
+  std::vector GPRCS2Frames;
+  std::vector DPRCSFrames;
 
   /// JumpTableUId - Unique id for jumptables.
   ///
@@ -107,24 +107,42 @@
   void setGPRCalleeSavedArea2Size(unsigned s) { GPRCS2Size = s; }
   void setDPRCalleeSavedAreaSize(unsigned s)  { DPRCSSize = s; }
 
-  bool isGPRCalleeSavedArea1Frame(unsigned fi) const {
-    return GPRCS1Frames.count(fi);
-  }
-  bool isGPRCalleeSavedArea2Frame(unsigned fi) const {
-    return GPRCS2Frames.count(fi);
-  }
-  bool isDPRCalleeSavedAreaFrame(unsigned fi) const {
-    return DPRCSFrames.count(fi);
-  }
-
-  void addGPRCalleeSavedArea1Frame(unsigned fi) {
-    GPRCS1Frames.insert(fi);
-  }
-  void addGPRCalleeSavedArea2Frame(unsigned fi) {
-    GPRCS2Frames.insert(fi);
-  }
-  void addDPRCalleeSavedAreaFrame(unsigned fi) {
-    DPRCSFrames.insert(fi);
+  bool isGPRCalleeSavedArea1Frame(int fi) const {
+    if (fi < 0 || fi >= (int)GPRCS1Frames.size())
+      return false;
+    return GPRCS1Frames[fi];
+  }
+  bool isGPRCalleeSavedArea2Frame(int fi) const {
+    if (fi < 0 || fi >= (int)GPRCS2Frames.size())
+      return false;
+    return GPRCS2Frames[fi];
+  }
+  bool isDPRCalleeSavedAreaFrame(int fi) const {
+    if (fi < 0 || fi >= (int)DPRCSFrames.size())
+      return false;
+    return DPRCSFrames[fi];
+  }
+
+  void addGPRCalleeSavedArea1Frame(int fi) {
+    if (fi >= 0) {
+      if (fi >= (int)GPRCS1Frames.size())
+        GPRCS1Frames.resize(fi+1);
+      GPRCS1Frames[fi] = true;
+    }
+  }
+  void addGPRCalleeSavedArea2Frame(int fi) {
+    if (fi >= 0) {
+      if (fi >= (int)GPRCS2Frames.size())
+        GPRCS2Frames.resize(fi+1);
+      GPRCS2Frames[fi] = true;
+    }
+  }
+  void addDPRCalleeSavedAreaFrame(int fi) {
+    if (fi >= 0) {
+      if (fi >= (int)DPRCSFrames.size())
+        DPRCSFrames.resize(fi+1);
+      DPRCSFrames[fi] = true;
+    }
   }
 
   unsigned createJumpTableUId() {


Index: llvm/lib/Target/ARM/ARMRegisterInfo.h
diff -u llvm/lib/Target/ARM/ARMRegisterInfo.h:1.6 llvm/lib/Target/ARM/ARMRegisterInfo.h:1.7
--- llvm/lib/Target/ARM/ARMRegisterInfo.h:1.6	Mon Jan 22 18:52:44 2007
+++ llvm/lib/Target/ARM/ARMRegisterInfo.h	Wed Jan 24 21:07:27 2007
@@ -17,7 +17,6 @@
 
 #include "llvm/Target/MRegisterInfo.h"
 #include "ARMGenRegisterInfo.h.inc"
-#include 
 
 namespace llvm {
   class TargetInstrInfo;





From evan.cheng at apple.com  Wed Jan 24 21:13:02 2007
From: evan.cheng at apple.com (Evan Cheng)
Date: Wed, 24 Jan 2007 21:13:02 -0600
Subject: [llvm-commits] CVS: llvm/lib/Target/ARM/ARMConstantIslandPass.cpp
Message-ID: <200701250313.l0P3D2Jc031697@zion.cs.uiuc.edu>



Changes in directory llvm/lib/Target/ARM:

ARMConstantIslandPass.cpp updated: 1.2 -> 1.3
---
Log message:

Added (preliminary) branch shortening capability to constantpool island pass.

---
Diffs of the changes:  (+130 -7)

 ARMConstantIslandPass.cpp |  137 +++++++++++++++++++++++++++++++++++++++++++---
 1 files changed, 130 insertions(+), 7 deletions(-)


Index: llvm/lib/Target/ARM/ARMConstantIslandPass.cpp
diff -u llvm/lib/Target/ARM/ARMConstantIslandPass.cpp:1.2 llvm/lib/Target/ARM/ARMConstantIslandPass.cpp:1.3
--- llvm/lib/Target/ARM/ARMConstantIslandPass.cpp:1.2	Wed Jan 24 02:53:17 2007
+++ llvm/lib/Target/ARM/ARMConstantIslandPass.cpp	Wed Jan 24 21:12:46 2007
@@ -15,6 +15,7 @@
 
 #define DEBUG_TYPE "arm-cp-islands"
 #include "ARM.h"
+#include "ARMMachineFunctionInfo.h"
 #include "ARMInstrInfo.h"
 #include "llvm/CodeGen/MachineConstantPool.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
@@ -72,13 +73,30 @@
     /// constant pools and their max displacement.
     std::vector CPUsers;
     
+    /// ImmBranch - One per immediate branch, keeping the machine instruction
+    /// pointer, conditional or unconditional, the max displacement,
+    /// and (if isCond is true) the corresponding unconditional branch
+    /// opcode.
+    struct ImmBranch {
+      MachineInstr *MI;
+      bool isCond;
+      int UncondBr;
+      unsigned MaxDisp;
+      ImmBranch(MachineInstr *mi, bool cond, int ubr, unsigned maxdisp)
+        : MI(mi), isCond(cond), UncondBr(ubr), MaxDisp(maxdisp) {}
+    };
+
+    /// Branches - Keep track of all the immediate branche instructions.
+    ///
+    std::vector ImmBranches;
+
     const TargetInstrInfo *TII;
     const TargetAsmInfo   *TAI;
   public:
     virtual bool runOnMachineFunction(MachineFunction &Fn);
 
     virtual const char *getPassName() const {
-      return "ARM constant island placement pass";
+      return "ARM constant island placement and branch shortening pass";
     }
     
   private:
@@ -87,16 +105,18 @@
     void InitialFunctionScan(MachineFunction &Fn,
                              const std::vector &CPEMIs);
     void SplitBlockBeforeInstr(MachineInstr *MI);
-    bool HandleConstantPoolUser(MachineFunction &Fn, CPUser &U);
     void UpdateForInsertedWaterBlock(MachineBasicBlock *NewBB);
+    bool HandleConstantPoolUser(MachineFunction &Fn, CPUser &U);
+    bool ShortenImmediateBranch(MachineFunction &Fn, ImmBranch &Br);
 
     unsigned GetInstSize(MachineInstr *MI) const;
     unsigned GetOffsetOf(MachineInstr *MI) const;
+    unsigned GetOffsetOf(MachineBasicBlock *MBB) const;
   };
 }
 
-/// createARMLoadStoreOptimizationPass - returns an instance of the load / store
-/// optimization pass.
+/// createARMConstantIslandPass - returns an instance of the constpool
+/// island pass.
 FunctionPass *llvm::createARMConstantIslandPass() {
   return new ARMConstantIslands();
 }
@@ -133,11 +153,14 @@
     MadeChange = false;
     for (unsigned i = 0, e = CPUsers.size(); i != e; ++i)
       MadeChange |= HandleConstantPoolUser(Fn, CPUsers[i]);
+    for (unsigned i = 0, e = ImmBranches.size(); i != e; ++i)
+      MadeChange |= ShortenImmediateBranch(Fn, ImmBranches[i]);
   } while (MadeChange);
   
   BBSizes.clear();
   WaterList.clear();
   CPUsers.clear();
+  ImmBranches.clear();
     
   return true;
 }
@@ -208,6 +231,37 @@
       // Add instruction size to MBBSize.
       MBBSize += GetInstSize(I);
 
+      int Opc = I->getOpcode();
+      if (TII->isBranch(Opc)) {
+        bool isCond = false;
+        unsigned Bits = 0;
+        unsigned Scale = 1;
+        int UOpc = Opc;
+        switch (Opc) {
+        default: break; // Ignore JT branches
+        case ARM::Bcc:
+          isCond = true;
+          UOpc = ARM::B;
+          // Fallthrough
+        case ARM::B:
+          Bits = 24;
+          Scale = 4;
+          break;
+        case ARM::tBcc:
+          isCond = true;
+          UOpc = ARM::tB;
+          Bits = 8;
+          Scale = 2;
+          break;
+        case ARM::tB:
+          Bits = 11;
+          Scale = 2;
+          break;
+        }
+        unsigned MaxDisp = (1 << (Bits-1)) * Scale;
+        ImmBranches.push_back(ImmBranch(I, isCond, UOpc, MaxDisp));
+      }
+
       // Scan the instructions for constant pool operands.
       for (unsigned op = 0, e = I->getNumOperands(); op != e; ++op)
         if (I->getOperand(op).isConstantPoolIndex()) {
@@ -336,6 +390,18 @@
   }
 }
 
+/// GetOffsetOf - Return the current offset of the specified machine BB
+/// from the start of the function.  This offset changes as stuff is moved
+/// around inside the function.
+unsigned ARMConstantIslands::GetOffsetOf(MachineBasicBlock *MBB) const {
+  // Sum block sizes before MBB.
+  unsigned Offset = 0;  
+  for (unsigned BB = 0, e = MBB->getNumber(); BB != e; ++BB)
+    Offset += BBSizes[BB];
+
+  return Offset;
+}
+
 /// CompareMBBNumbers - Little predicate function to sort the WaterList by MBB
 /// ID.
 static bool CompareMBBNumbers(const MachineBasicBlock *LHS,
@@ -368,6 +434,8 @@
 /// account for this change.
 void ARMConstantIslands::SplitBlockBeforeInstr(MachineInstr *MI) {
   MachineBasicBlock *OrigBB = MI->getParent();
+  const ARMFunctionInfo *AFI = OrigBB->getParent()->getInfo();
+  bool isThumb = AFI->isThumbFunction();
 
   // Create a new MBB for the code after the OrigBB.
   MachineBasicBlock *NewBB = new MachineBasicBlock(OrigBB->getBasicBlock());
@@ -378,7 +446,7 @@
   NewBB->splice(NewBB->end(), OrigBB, MI, OrigBB->end());
   
   // Add an unconditional branch from OrigBB to NewBB.
-  BuildMI(OrigBB, TII->get(ARM::B)).addMBB(NewBB);
+  BuildMI(OrigBB, TII->get(isThumb ? ARM::tB : ARM::B)).addMBB(NewBB);
   NumSplit++;
   
   // Update the CFG.  All succs of OrigBB are now succs of NewBB.
@@ -409,8 +477,8 @@
   BBSizes[NewBB->getNumber()] = NewBBSize;
   
   // We removed instructions from UserMBB, subtract that off from its size.
-  // Add 4 to the block to count the unconditional branch we added to it.
-  BBSizes[OrigBB->getNumber()] -= NewBBSize-4;
+  // Add 2 or 4 to the block to count the unconditional branch we added to it.
+  BBSizes[OrigBB->getNumber()] -= NewBBSize - (isThumb ? 2 : 4);
 }
 
 /// HandleConstantPoolUser - Analyze the specified user, checking to see if it
@@ -491,3 +559,58 @@
   return true;
 }
 
+bool
+ARMConstantIslands::ShortenImmediateBranch(MachineFunction &Fn, ImmBranch &Br) {
+  MachineInstr *MI = Br.MI;
+  MachineBasicBlock *DestBB = MI->getOperand(0).getMachineBasicBlock();
+
+  unsigned BrOffset   = GetOffsetOf(MI);
+  unsigned DestOffset = GetOffsetOf(DestBB);
+
+  // Check to see if the destination BB is in range.
+  if (BrOffset < DestOffset) {
+    if (DestOffset - BrOffset < Br.MaxDisp)
+      return false;
+  } else {
+    if (BrOffset - DestOffset <= Br.MaxDisp)
+      return false;
+  }
+
+  if (!Br.isCond) {
+    // Unconditional branch. We have to insert a branch somewhere to perform
+    // a two level branch (branch to branch). FIXME: not yet implemented.
+    assert(false && "Can't handle unconditional branch yet!");
+    return false;
+  }
+
+  // Otherwise, add a unconditional branch to the destination and 
+  // invert the branch condition to jump over it:
+  // blt L1
+  // =>
+  // bge L2
+  // b   L1
+  // L2:
+  ARMCC::CondCodes CC = (ARMCC::CondCodes)MI->getOperand(1).getImmedValue();
+  CC = ARMCC::getOppositeCondition(CC);
+
+  // If the branch is at the end of its MBB and that has a fall-through block,
+  // direct the updated conditional branch to the fall-through block. Otherwise,
+  // split the MBB before the next instruction.
+  MachineBasicBlock *MBB = MI->getParent();
+  if (&MBB->back() != MI || !BBHasFallthrough(MBB))
+    SplitBlockBeforeInstr(MI);
+  MachineBasicBlock *NextBB = next(MachineFunction::iterator(MBB));
+
+  // Insert a unconditional branch and replace the conditional branch.
+  // Also update the ImmBranch as well as adding a new entry for the new branch.
+  BuildMI(MBB, TII->get(MI->getOpcode())).addMBB(NextBB).addImm((unsigned)CC);
+  Br.MI = &MBB->back();
+  BuildMI(MBB, TII->get(Br.UncondBr)).addMBB(DestBB);
+  unsigned MaxDisp = (Br.UncondBr == ARM::tB) ? (1<<10)*2 : (1<<23)*4;
+  ImmBranches.push_back(ImmBranch(&MBB->back(), false, Br.UncondBr, MaxDisp));
+  MI->eraseFromParent();
+
+  // Increase the size of MBB to account for the new unconditional branch.
+  BBSizes[MBB->getNumber()] += GetInstSize(&MBB->back());
+  return true;
+}





From jlaskey at apple.com  Thu Jan 25 09:12:21 2007
From: jlaskey at apple.com (Jim Laskey)
Date: Thu, 25 Jan 2007 09:12:21 -0600
Subject: [llvm-commits] CVS: llvm/include/llvm/CodeGen/AsmPrinter.h
Message-ID: <200701251512.l0PFCLpZ020804@zion.cs.uiuc.edu>



Changes in directory llvm/include/llvm/CodeGen:

AsmPrinter.h updated: 1.59 -> 1.60
---
Log message:

Migrate print routines to asm to be shared by exception handling.


---
Diffs of the changes:  (+62 -0)

 AsmPrinter.h |   62 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 files changed, 62 insertions(+)


Index: llvm/include/llvm/CodeGen/AsmPrinter.h
diff -u llvm/include/llvm/CodeGen/AsmPrinter.h:1.59 llvm/include/llvm/CodeGen/AsmPrinter.h:1.60
--- llvm/include/llvm/CodeGen/AsmPrinter.h:1.59	Wed Jan 24 07:12:32 2007
+++ llvm/include/llvm/CodeGen/AsmPrinter.h	Thu Jan 25 09:12:02 2007
@@ -175,6 +175,68 @@
     bool EmitSpecialLLVMGlobal(const GlobalVariable *GV);
     
   public:
+    //===------------------------------------------------------------------===//
+    /// LEB 128 number encoding.
+
+    /// PrintULEB128 - Print a series of hexidecimal values(separated by commas)
+    /// representing an unsigned leb128 value.
+    void PrintULEB128(unsigned Value) const;
+
+    /// SizeULEB128 - Compute the number of bytes required for an unsigned
+    /// leb128 value.
+    static unsigned SizeULEB128(unsigned Value);
+
+    /// PrintSLEB128 - Print a series of hexidecimal values(separated by commas)
+    /// representing a signed leb128 value.
+    void PrintSLEB128(int Value) const;
+
+    /// SizeSLEB128 - Compute the number of bytes required for a signed leb128
+    /// value.
+    static unsigned SizeSLEB128(int Value);
+    
+    //===------------------------------------------------------------------===//
+    // Emission and print routines
+    //
+
+    /// PrintHex - Print a value as a hexidecimal value.
+    ///
+    void PrintHex(int Value) const;
+
+    /// EOL - Print a newline character to asm stream.  If a comment is present
+    /// then it will be printed first.  Comments should not contain '\n'.
+    void EOL(const std::string &Comment) const;
+    
+    /// EmitULEB128Bytes - Emit an assembler byte data directive to compose an
+    /// unsigned leb128 value.
+    void EmitULEB128Bytes(unsigned Value) const;
+    
+    /// EmitSLEB128Bytes - print an assembler byte data directive to compose a
+    /// signed leb128 value.
+    void EmitSLEB128Bytes(int Value) const;
+    
+    /// EmitInt8 - Emit a byte directive and value.
+    ///
+    void EmitInt8(int Value) const;
+
+    /// EmitInt16 - Emit a short directive and value.
+    ///
+    void EmitInt16(int Value) const;
+
+    /// EmitInt32 - Emit a long directive and value.
+    ///
+    void EmitInt32(int Value) const;
+
+    /// EmitInt64 - Emit a long long directive and value.
+    ///
+    void EmitInt64(uint64_t Value) const;
+
+    /// EmitString - Emit a string with quotes and a null terminator.
+    /// Special characters are emitted properly.
+    /// \literal (Eg. '\t') \endliteral
+    void EmitString(const std::string &String) const;
+    
+    //===------------------------------------------------------------------===//
+
     /// EmitAlignment - Emit an alignment directive to the specified power of
     /// two boundary.  For example, if you pass in 3 here, you will get an 8
     /// byte alignment.  If a global value is specified, and if that global has





From jlaskey at apple.com  Thu Jan 25 09:12:21 2007
From: jlaskey at apple.com (Jim Laskey)
Date: Thu, 25 Jan 2007 09:12:21 -0600
Subject: [llvm-commits] CVS: llvm/lib/CodeGen/AsmPrinter.cpp DwarfWriter.cpp
Message-ID: <200701251512.l0PFCLW7020811@zion.cs.uiuc.edu>



Changes in directory llvm/lib/CodeGen:

AsmPrinter.cpp updated: 1.138 -> 1.139
DwarfWriter.cpp updated: 1.113 -> 1.114
---
Log message:

Migrate print routines to asm to be shared by exception handling.


---
Diffs of the changes:  (+382 -369)

 AsmPrinter.cpp  |  223 ++++++++++++++++++++---
 DwarfWriter.cpp |  528 +++++++++++++++++++-------------------------------------
 2 files changed, 382 insertions(+), 369 deletions(-)


Index: llvm/lib/CodeGen/AsmPrinter.cpp
diff -u llvm/lib/CodeGen/AsmPrinter.cpp:1.138 llvm/lib/CodeGen/AsmPrinter.cpp:1.139
--- llvm/lib/CodeGen/AsmPrinter.cpp:1.138	Mon Jan 22 18:36:17 2007
+++ llvm/lib/CodeGen/AsmPrinter.cpp	Thu Jan 25 09:12:02 2007
@@ -18,6 +18,7 @@
 #include "llvm/Module.h"
 #include "llvm/CodeGen/MachineConstantPool.h"
 #include "llvm/CodeGen/MachineJumpTableInfo.h"
+#include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Mangler.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/Streams.h"
@@ -28,6 +29,9 @@
 #include 
 using namespace llvm;
 
+static cl::opt
+AsmVerbose("asm-verbose", cl::Hidden, cl::desc("Add comments to directives."));
+
 AsmPrinter::AsmPrinter(std::ostream &o, TargetMachine &tm,
                        const TargetAsmInfo *T)
 : FunctionNumber(0), O(o), TM(tm), TAI(T)
@@ -366,6 +370,196 @@
   return LinkName;
 }
 
+//===----------------------------------------------------------------------===//
+/// LEB 128 number encoding.
+
+/// PrintULEB128 - Print a series of hexidecimal values (separated by commas)
+/// representing an unsigned leb128 value.
+void AsmPrinter::PrintULEB128(unsigned Value) const {
+  do {
+    unsigned Byte = Value & 0x7f;
+    Value >>= 7;
+    if (Value) Byte |= 0x80;
+    O << "0x" << std::hex << Byte << std::dec;
+    if (Value) O << ", ";
+  } while (Value);
+}
+
+/// SizeULEB128 - Compute the number of bytes required for an unsigned leb128
+/// value.
+unsigned AsmPrinter::SizeULEB128(unsigned Value) {
+  unsigned Size = 0;
+  do {
+    Value >>= 7;
+    Size += sizeof(int8_t);
+  } while (Value);
+  return Size;
+}
+
+/// PrintSLEB128 - Print a series of hexidecimal values (separated by commas)
+/// representing a signed leb128 value.
+void AsmPrinter::PrintSLEB128(int Value) const {
+  int Sign = Value >> (8 * sizeof(Value) - 1);
+  bool IsMore;
+  
+  do {
+    unsigned Byte = Value & 0x7f;
+    Value >>= 7;
+    IsMore = Value != Sign || ((Byte ^ Sign) & 0x40) != 0;
+    if (IsMore) Byte |= 0x80;
+    O << "0x" << std::hex << Byte << std::dec;
+    if (IsMore) O << ", ";
+  } while (IsMore);
+}
+
+/// SizeSLEB128 - Compute the number of bytes required for a signed leb128
+/// value.
+unsigned AsmPrinter::SizeSLEB128(int Value) {
+  unsigned Size = 0;
+  int Sign = Value >> (8 * sizeof(Value) - 1);
+  bool IsMore;
+  
+  do {
+    unsigned Byte = Value & 0x7f;
+    Value >>= 7;
+    IsMore = Value != Sign || ((Byte ^ Sign) & 0x40) != 0;
+    Size += sizeof(int8_t);
+  } while (IsMore);
+  return Size;
+}
+
+//===--------------------------------------------------------------------===//
+// Emission and print routines
+//
+
+/// PrintHex - Print a value as a hexidecimal value.
+///
+void AsmPrinter::PrintHex(int Value) const { 
+  O << "0x" << std::hex << Value << std::dec;
+}
+
+/// EOL - Print a newline character to asm stream.  If a comment is present
+/// then it will be printed first.  Comments should not contain '\n'.
+void AsmPrinter::EOL(const std::string &Comment) const {
+  if (AsmVerbose && !Comment.empty()) {
+    O << "\t"
+      << TAI->getCommentString()
+      << " "
+      << Comment;
+  }
+  O << "\n";
+}
+
+/// EmitULEB128Bytes - Emit an assembler byte data directive to compose an
+/// unsigned leb128 value.
+void AsmPrinter::EmitULEB128Bytes(unsigned Value) const {
+  if (TAI->hasLEB128()) {
+    O << "\t.uleb128\t"
+      << Value;
+  } else {
+    O << TAI->getData8bitsDirective();
+    PrintULEB128(Value);
+  }
+}
+
+/// EmitSLEB128Bytes - print an assembler byte data directive to compose a
+/// signed leb128 value.
+void AsmPrinter::EmitSLEB128Bytes(int Value) const {
+  if (TAI->hasLEB128()) {
+    O << "\t.sleb128\t"
+      << Value;
+  } else {
+    O << TAI->getData8bitsDirective();
+    PrintSLEB128(Value);
+  }
+}
+
+/// EmitInt8 - Emit a byte directive and value.
+///
+void AsmPrinter::EmitInt8(int Value) const {
+  O << TAI->getData8bitsDirective();
+  PrintHex(Value & 0xFF);
+}
+
+/// EmitInt16 - Emit a short directive and value.
+///
+void AsmPrinter::EmitInt16(int Value) const {
+  O << TAI->getData16bitsDirective();
+  PrintHex(Value & 0xFFFF);
+}
+
+/// EmitInt32 - Emit a long directive and value.
+///
+void AsmPrinter::EmitInt32(int Value) const {
+  O << TAI->getData32bitsDirective();
+  PrintHex(Value);
+}
+
+/// EmitInt64 - Emit a long long directive and value.
+///
+void AsmPrinter::EmitInt64(uint64_t Value) const {
+  if (TAI->getData64bitsDirective()) {
+    O << TAI->getData64bitsDirective();
+    PrintHex(Value);
+  } else {
+    if (TM.getTargetData()->isBigEndian()) {
+      EmitInt32(unsigned(Value >> 32)); O << "\n";
+      EmitInt32(unsigned(Value));
+    } else {
+      EmitInt32(unsigned(Value)); O << "\n";
+      EmitInt32(unsigned(Value >> 32));
+    }
+  }
+}
+
+/// toOctal - Convert the low order bits of X into an octal digit.
+///
+static inline char toOctal(int X) {
+  return (X&7)+'0';
+}
+
+/// printStringChar - Print a char, escaped if necessary.
+///
+static void printStringChar(std::ostream &O, unsigned char C) {
+  if (C == '"') {
+    O << "\\\"";
+  } else if (C == '\\') {
+    O << "\\\\";
+  } else if (isprint(C)) {
+    O << C;
+  } else {
+    switch(C) {
+    case '\b': O << "\\b"; break;
+    case '\f': O << "\\f"; break;
+    case '\n': O << "\\n"; break;
+    case '\r': O << "\\r"; break;
+    case '\t': O << "\\t"; break;
+    default:
+      O << '\\';
+      O << toOctal(C >> 6);
+      O << toOctal(C >> 3);
+      O << toOctal(C >> 0);
+      break;
+    }
+  }
+}
+
+/// EmitString - Emit a string with quotes and a null terminator.
+/// Special characters are emitted properly.
+/// \literal (Eg. '\t') \endliteral
+void AsmPrinter::EmitString(const std::string &String) const {
+  O << TAI->getAsciiDirective()
+    << "\"";
+  for (unsigned i = 0, N = String.size(); i < N; ++i) {
+    unsigned char C = String[i];
+    printStringChar(O, C);
+  }
+  O << "\\0\"";
+}
+
+
+//===----------------------------------------------------------------------===//
+
 // EmitAlignment - Emit an alignment directive to the specified power of two.
 void AsmPrinter::EmitAlignment(unsigned NumBits, const GlobalValue *GV) const {
   if (GV && GV->getAlignment())
@@ -486,12 +680,6 @@
   }
 }
 
-/// toOctal - Convert the low order bits of X into an octal digit.
-///
-static inline char toOctal(int X) {
-  return (X&7)+'0';
-}
-
 /// printAsCString - Print the specified array as a C compatible string, only if
 /// the predicate isString is true.
 ///
@@ -503,28 +691,7 @@
   for (unsigned i = 0; i != LastElt; ++i) {
     unsigned char C =
         (unsigned char)cast(CVA->getOperand(i))->getZExtValue();
-
-    if (C == '"') {
-      O << "\\\"";
-    } else if (C == '\\') {
-      O << "\\\\";
-    } else if (isprint(C)) {
-      O << C;
-    } else {
-      switch(C) {
-      case '\b': O << "\\b"; break;
-      case '\f': O << "\\f"; break;
-      case '\n': O << "\\n"; break;
-      case '\r': O << "\\r"; break;
-      case '\t': O << "\\t"; break;
-      default:
-        O << '\\';
-        O << toOctal(C >> 6);
-        O << toOctal(C >> 3);
-        O << toOctal(C >> 0);
-        break;
-      }
-    }
+    printStringChar(O, C);
   }
   O << "\"";
 }


Index: llvm/lib/CodeGen/DwarfWriter.cpp
diff -u llvm/lib/CodeGen/DwarfWriter.cpp:1.113 llvm/lib/CodeGen/DwarfWriter.cpp:1.114
--- llvm/lib/CodeGen/DwarfWriter.cpp:1.113	Wed Jan 24 12:45:13 2007
+++ llvm/lib/CodeGen/DwarfWriter.cpp	Thu Jan 25 09:12:02 2007
@@ -57,64 +57,6 @@
 class DIEValue;
 
 //===----------------------------------------------------------------------===//
-/// LEB 128 number encoding.
-
-/// PrintULEB128 - Print a series of hexidecimal values (separated by commas)
-/// representing an unsigned leb128 value.
-static void PrintULEB128(std::ostream &O, unsigned Value) {
-  do {
-    unsigned Byte = Value & 0x7f;
-    Value >>= 7;
-    if (Value) Byte |= 0x80;
-    O << "0x" << std::hex << Byte << std::dec;
-    if (Value) O << ", ";
-  } while (Value);
-}
-
-/// SizeULEB128 - Compute the number of bytes required for an unsigned leb128
-/// value.
-static unsigned SizeULEB128(unsigned Value) {
-  unsigned Size = 0;
-  do {
-    Value >>= 7;
-    Size += sizeof(int8_t);
-  } while (Value);
-  return Size;
-}
-
-/// PrintSLEB128 - Print a series of hexidecimal values (separated by commas)
-/// representing a signed leb128 value.
-static void PrintSLEB128(std::ostream &O, int Value) {
-  int Sign = Value >> (8 * sizeof(Value) - 1);
-  bool IsMore;
-  
-  do {
-    unsigned Byte = Value & 0x7f;
-    Value >>= 7;
-    IsMore = Value != Sign || ((Byte ^ Sign) & 0x40) != 0;
-    if (IsMore) Byte |= 0x80;
-    O << "0x" << std::hex << Byte << std::dec;
-    if (IsMore) O << ", ";
-  } while (IsMore);
-}
-
-/// SizeSLEB128 - Compute the number of bytes required for a signed leb128
-/// value.
-static unsigned SizeSLEB128(int Value) {
-  unsigned Size = 0;
-  int Sign = Value >> (8 * sizeof(Value) - 1);
-  bool IsMore;
-  
-  do {
-    unsigned Byte = Value & 0x7f;
-    Value >>= 7;
-    IsMore = Value != Sign || ((Byte ^ Sign) & 0x40) != 0;
-    Size += sizeof(int8_t);
-  } while (IsMore);
-  return Size;
-}
-
-//===----------------------------------------------------------------------===//
 /// DWLabel - Labels are used to track locations in the assembler file.
 /// Labels appear in the form debug_, where the tag is a
 /// category of label (Ex. location) and number is a value unique in that
@@ -429,23 +371,7 @@
   
   /// SizeOf - Determine size of integer value in bytes.
   ///
-  virtual unsigned SizeOf(const Dwarf &DW, unsigned Form) const {
-    switch (Form) {
-    case DW_FORM_flag:  // Fall thru
-    case DW_FORM_ref1:  // Fall thru
-    case DW_FORM_data1: return sizeof(int8_t);
-    case DW_FORM_ref2:  // Fall thru
-    case DW_FORM_data2: return sizeof(int16_t);
-    case DW_FORM_ref4:  // Fall thru
-    case DW_FORM_data4: return sizeof(int32_t);
-    case DW_FORM_ref8:  // Fall thru
-    case DW_FORM_data8: return sizeof(int64_t);
-    case DW_FORM_udata: return SizeULEB128(Integer);
-    case DW_FORM_sdata: return SizeSLEB128(Integer);
-    default: assert(0 && "DIE Value form not supported yet"); break;
-    }
-    return 0;
-  }
+  virtual unsigned SizeOf(const Dwarf &DW, unsigned Form) const;
   
   /// Profile - Used to gather unique data for the value folding set.
   ///
@@ -924,122 +850,9 @@
 public:
 
   //===--------------------------------------------------------------------===//
-  // Emission and print routines
+  // Accessors.
   //
-
-  /// PrintHex - Print a value as a hexidecimal value.
-  ///
-  void PrintHex(int Value) const { 
-    O << "0x" << std::hex << Value << std::dec;
-  }
-
-  /// EOL - Print a newline character to asm stream.  If a comment is present
-  /// then it will be printed first.  Comments should not contain '\n'.
-  void EOL(const std::string &Comment) const {
-    if (DwarfVerbose && !Comment.empty()) {
-      O << "\t"
-        << TAI->getCommentString()
-        << " "
-        << Comment;
-    }
-    O << "\n";
-  }
-  
-  /// EmitULEB128Bytes - Emit an assembler byte data directive to compose an
-  /// unsigned leb128 value.
-  void EmitULEB128Bytes(unsigned Value) const {
-    if (TAI->hasLEB128()) {
-      O << "\t.uleb128\t"
-        << Value;
-    } else {
-      O << TAI->getData8bitsDirective();
-      PrintULEB128(O, Value);
-    }
-  }
-  
-  /// EmitSLEB128Bytes - print an assembler byte data directive to compose a
-  /// signed leb128 value.
-  void EmitSLEB128Bytes(int Value) const {
-    if (TAI->hasLEB128()) {
-      O << "\t.sleb128\t"
-        << Value;
-    } else {
-      O << TAI->getData8bitsDirective();
-      PrintSLEB128(O, Value);
-    }
-  }
-  
-  /// EmitInt8 - Emit a byte directive and value.
-  ///
-  void EmitInt8(int Value) const {
-    O << TAI->getData8bitsDirective();
-    PrintHex(Value & 0xFF);
-  }
-
-  /// EmitInt16 - Emit a short directive and value.
-  ///
-  void EmitInt16(int Value) const {
-    O << TAI->getData16bitsDirective();
-    PrintHex(Value & 0xFFFF);
-  }
-
-  /// EmitInt32 - Emit a long directive and value.
-  ///
-  void EmitInt32(int Value) const {
-    O << TAI->getData32bitsDirective();
-    PrintHex(Value);
-  }
-
-  /// EmitInt64 - Emit a long long directive and value.
-  ///
-  void EmitInt64(uint64_t Value) const {
-    if (TAI->getData64bitsDirective()) {
-      O << TAI->getData64bitsDirective();
-      PrintHex(Value);
-    } else {
-      if (TD->isBigEndian()) {
-        EmitInt32(unsigned(Value >> 32)); O << "\n";
-        EmitInt32(unsigned(Value));
-      } else {
-        EmitInt32(unsigned(Value)); O << "\n";
-        EmitInt32(unsigned(Value >> 32));
-      }
-    }
-  }
-
-  /// EmitString - Emit a string with quotes and a null terminator.
-  /// Special characters are emitted properly.
-  /// \literal (Eg. '\t') \endliteral
-  void EmitString(const std::string &String) const {
-    O << TAI->getAsciiDirective()
-      << "\"";
-    for (unsigned i = 0, N = String.size(); i < N; ++i) {
-      unsigned char C = String[i];
-      
-      if (!isascii(C) || iscntrl(C)) {
-        switch(C) {
-        case '\b': O << "\\b"; break;
-        case '\f': O << "\\f"; break;
-        case '\n': O << "\\n"; break;
-        case '\r': O << "\\r"; break;
-        case '\t': O << "\\t"; break;
-        default:
-          O << '\\';
-          O << char('0' + ((C >> 6) & 7));
-          O << char('0' + ((C >> 3) & 7));
-          O << char('0' + ((C >> 0) & 7));
-          break;
-        }
-      } else if (C == '\"') {
-        O << "\\\"";
-      } else if (C == '\'') {
-        O << "\\\'";
-      } else {
-       O << C;
-      }
-    }
-    O << "\\0\"";
-  }
+  AsmPrinter *getAsm() const { return Asm; }
 
   /// PrintLabelName - Print label name in form used by Dwarf writer.
   ///
@@ -2005,12 +1818,12 @@
     O << "\n";
 
     // Emit the code (index) for the abbreviation.
-    EmitULEB128Bytes(AbbrevNumber);
-    EOL(std::string("Abbrev [" +
-        utostr(AbbrevNumber) +
-        "] 0x" + utohexstr(Die->getOffset()) +
-        ":0x" + utohexstr(Die->getSize()) + " " +
-        TagString(Abbrev->getTag())));
+    Asm->EmitULEB128Bytes(AbbrevNumber);
+    Asm->EOL(std::string("Abbrev [" +
+             utostr(AbbrevNumber) +
+             "] 0x" + utohexstr(Die->getOffset()) +
+             ":0x" + utohexstr(Die->getSize()) + " " +
+             TagString(Abbrev->getTag())));
     
     const std::vector &Values = Die->getValues();
     const std::vector &AbbrevData = Abbrev->getData();
@@ -2023,7 +1836,7 @@
       
       switch (Attr) {
       case DW_AT_sibling: {
-        EmitInt32(Die->SiblingOffset());
+        Asm->EmitInt32(Die->SiblingOffset());
         break;
       }
       default: {
@@ -2033,7 +1846,7 @@
       }
       }
       
-      EOL(AttributeString(Attr));
+      Asm->EOL(AttributeString(Attr));
     }
     
     // Emit the DIE children if any.
@@ -2044,7 +1857,7 @@
         EmitDIE(Children[j]);
       }
       
-      EmitInt8(0); EOL("End Of Children Mark");
+      Asm->EmitInt8(0); Asm->EOL("End Of Children Mark");
     }
   }
 
@@ -2068,7 +1881,7 @@
     Die->setOffset(Offset);
     
     // Start the size with the size of abbreviation code.
-    Offset += SizeULEB128(AbbrevNumber);
+    Offset += Asm->SizeULEB128(AbbrevNumber);
     
     const std::vector &Values = Die->getValues();
     const std::vector &AbbrevData = Abbrev->getData();
@@ -2134,10 +1947,10 @@
       
       // Advance row if new location.
       if (BaseLabel && LabelID && BaseLabelID != LabelID) {
-        EmitInt8(DW_CFA_advance_loc4);
-        EOL("DW_CFA_advance_loc4");
+        Asm->EmitInt8(DW_CFA_advance_loc4);
+        Asm->EOL("DW_CFA_advance_loc4");
         EmitDifference("loc", LabelID, BaseLabel, BaseLabelID, true);
-        EOL("");
+        Asm->EOL("");
         
         BaseLabelID = LabelID;
         BaseLabel = "loc";
@@ -2147,29 +1960,29 @@
       if (Dst.isRegister() && Dst.getRegister() == MachineLocation::VirtualFP) {
         if (!Src.isRegister()) {
           if (Src.getRegister() == MachineLocation::VirtualFP) {
-            EmitInt8(DW_CFA_def_cfa_offset);
-            EOL("DW_CFA_def_cfa_offset");
+            Asm->EmitInt8(DW_CFA_def_cfa_offset);
+            Asm->EOL("DW_CFA_def_cfa_offset");
           } else {
-            EmitInt8(DW_CFA_def_cfa);
-            EOL("DW_CFA_def_cfa");
-            EmitULEB128Bytes(RI->getDwarfRegNum(Src.getRegister()));
-            EOL("Register");
+            Asm->EmitInt8(DW_CFA_def_cfa);
+            Asm->EOL("DW_CFA_def_cfa");
+            Asm->EmitULEB128Bytes(RI->getDwarfRegNum(Src.getRegister()));
+            Asm->EOL("Register");
           }
           
           int Offset = Src.getOffset() / stackGrowth;
           
-          EmitULEB128Bytes(Offset);
-          EOL("Offset");
+          Asm->EmitULEB128Bytes(Offset);
+          Asm->EOL("Offset");
         } else {
           assert(0 && "Machine move no supported yet.");
         }
       } else if (Src.isRegister() &&
         Src.getRegister() == MachineLocation::VirtualFP) {
         if (Dst.isRegister()) {
-          EmitInt8(DW_CFA_def_cfa_register);
-          EOL("DW_CFA_def_cfa_register");
-          EmitULEB128Bytes(RI->getDwarfRegNum(Dst.getRegister()));
-          EOL("Register");
+          Asm->EmitInt8(DW_CFA_def_cfa_register);
+          Asm->EOL("DW_CFA_def_cfa_register");
+          Asm->EmitULEB128Bytes(RI->getDwarfRegNum(Dst.getRegister()));
+          Asm->EOL("Register");
         } else {
           assert(0 && "Machine move no supported yet.");
         }
@@ -2178,24 +1991,24 @@
         int Offset = Dst.getOffset() / stackGrowth;
         
         if (Offset < 0) {
-          EmitInt8(DW_CFA_offset_extended_sf);
-          EOL("DW_CFA_offset_extended_sf");
-          EmitULEB128Bytes(Reg);
-          EOL("Reg");
-          EmitSLEB128Bytes(Offset);
-          EOL("Offset");
+          Asm->EmitInt8(DW_CFA_offset_extended_sf);
+          Asm->EOL("DW_CFA_offset_extended_sf");
+          Asm->EmitULEB128Bytes(Reg);
+          Asm->EOL("Reg");
+          Asm->EmitSLEB128Bytes(Offset);
+          Asm->EOL("Offset");
         } else if (Reg < 64) {
-          EmitInt8(DW_CFA_offset + Reg);
-          EOL("DW_CFA_offset + Reg");
-          EmitULEB128Bytes(Offset);
-          EOL("Offset");
+          Asm->EmitInt8(DW_CFA_offset + Reg);
+          Asm->EOL("DW_CFA_offset + Reg");
+          Asm->EmitULEB128Bytes(Offset);
+          Asm->EOL("Offset");
         } else {
-          EmitInt8(DW_CFA_offset_extended);
-          EOL("DW_CFA_offset_extended");
-          EmitULEB128Bytes(Reg);
-          EOL("Reg");
-          EmitULEB128Bytes(Offset);
-          EOL("Offset");
+          Asm->EmitInt8(DW_CFA_offset_extended);
+          Asm->EOL("DW_CFA_offset_extended");
+          Asm->EmitULEB128Bytes(Reg);
+          Asm->EOL("Reg");
+          Asm->EmitULEB128Bytes(Offset);
+          Asm->EOL("Offset");
         }
       }
     }
@@ -2218,17 +2031,18 @@
                            sizeof(int8_t) +  // Pointer Size (in bytes)
                            sizeof(int32_t);  // FIXME - extra pad for gdb bug.
                            
-    EmitInt32(ContentSize);  EOL("Length of Compilation Unit Info");
-    EmitInt16(DWARF_VERSION); EOL("DWARF version number");
+    Asm->EmitInt32(ContentSize);  Asm->EOL("Length of Compilation Unit Info");
+    Asm->EmitInt16(DWARF_VERSION); Asm->EOL("DWARF version number");
     EmitDifference("abbrev_begin", 0, "section_abbrev", 0, true);
-    EOL("Offset Into Abbrev. Section");
-    EmitInt8(TAI->getAddressSize()); EOL("Address Size (in bytes)");
+    Asm->EOL("Offset Into Abbrev. Section");
+    Asm->EmitInt8(TAI->getAddressSize()); Asm->EOL("Address Size (in bytes)");
   
     EmitDIE(Die);
-    EmitInt8(0); EOL("Extra Pad For GDB"); // FIXME - extra pad for gdb bug.
-    EmitInt8(0); EOL("Extra Pad For GDB"); // FIXME - extra pad for gdb bug.
-    EmitInt8(0); EOL("Extra Pad For GDB"); // FIXME - extra pad for gdb bug.
-    EmitInt8(0); EOL("Extra Pad For GDB"); // FIXME - extra pad for gdb bug.
+    // FIXME - extra padding for gdb bug.
+    Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
+    Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
+    Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
+    Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
     EmitLabel("info_end", Unit->getID());
     
     O << "\n";
@@ -2250,7 +2064,8 @@
         const DIEAbbrev *Abbrev = Abbreviations[i];
         
         // Emit the abbrevations code (base 1 index.)
-        EmitULEB128Bytes(Abbrev->getNumber()); EOL("Abbreviation Code");
+        Asm->EmitULEB128Bytes(Abbrev->getNumber());
+        Asm->EOL("Abbreviation Code");
         
         // Emit the abbreviations data.
         Abbrev->Emit(*this);
@@ -2278,35 +2093,35 @@
     // Construct the section header.
     
     EmitDifference("line_end", 0, "line_begin", 0, true);
-    EOL("Length of Source Line Info");
+    Asm->EOL("Length of Source Line Info");
     EmitLabel("line_begin", 0);
     
-    EmitInt16(DWARF_VERSION); EOL("DWARF version number");
+    Asm->EmitInt16(DWARF_VERSION); Asm->EOL("DWARF version number");
     
     EmitDifference("line_prolog_end", 0, "line_prolog_begin", 0, true);
-    EOL("Prolog Length");
+    Asm->EOL("Prolog Length");
     EmitLabel("line_prolog_begin", 0);
     
-    EmitInt8(1); EOL("Minimum Instruction Length");
+    Asm->EmitInt8(1); Asm->EOL("Minimum Instruction Length");
 
-    EmitInt8(1); EOL("Default is_stmt_start flag");
+    Asm->EmitInt8(1); Asm->EOL("Default is_stmt_start flag");
 
-    EmitInt8(MinLineDelta);  EOL("Line Base Value (Special Opcodes)");
+    Asm->EmitInt8(MinLineDelta); Asm->EOL("Line Base Value (Special Opcodes)");
     
-    EmitInt8(MaxLineDelta); EOL("Line Range Value (Special Opcodes)");
+    Asm->EmitInt8(MaxLineDelta); Asm->EOL("Line Range Value (Special Opcodes)");
 
-    EmitInt8(-MinLineDelta); EOL("Special Opcode Base");
+    Asm->EmitInt8(-MinLineDelta); Asm->EOL("Special Opcode Base");
     
     // Line number standard opcode encodings argument count
-    EmitInt8(0); EOL("DW_LNS_copy arg count");
-    EmitInt8(1); EOL("DW_LNS_advance_pc arg count");
-    EmitInt8(1); EOL("DW_LNS_advance_line arg count");
-    EmitInt8(1); EOL("DW_LNS_set_file arg count");
-    EmitInt8(1); EOL("DW_LNS_set_column arg count");
-    EmitInt8(0); EOL("DW_LNS_negate_stmt arg count");
-    EmitInt8(0); EOL("DW_LNS_set_basic_block arg count");
-    EmitInt8(0); EOL("DW_LNS_const_add_pc arg count");
-    EmitInt8(1); EOL("DW_LNS_fixed_advance_pc arg count");
+    Asm->EmitInt8(0); Asm->EOL("DW_LNS_copy arg count");
+    Asm->EmitInt8(1); Asm->EOL("DW_LNS_advance_pc arg count");
+    Asm->EmitInt8(1); Asm->EOL("DW_LNS_advance_line arg count");
+    Asm->EmitInt8(1); Asm->EOL("DW_LNS_set_file arg count");
+    Asm->EmitInt8(1); Asm->EOL("DW_LNS_set_column arg count");
+    Asm->EmitInt8(0); Asm->EOL("DW_LNS_negate_stmt arg count");
+    Asm->EmitInt8(0); Asm->EOL("DW_LNS_set_basic_block arg count");
+    Asm->EmitInt8(0); Asm->EOL("DW_LNS_const_add_pc arg count");
+    Asm->EmitInt8(1); Asm->EOL("DW_LNS_fixed_advance_pc arg count");
 
     const UniqueVector &Directories = DebugInfo->getDirectories();
     const UniqueVector
@@ -2315,20 +2130,24 @@
     // Emit directories.
     for (unsigned DirectoryID = 1, NDID = Directories.size();
                   DirectoryID <= NDID; ++DirectoryID) {
-      EmitString(Directories[DirectoryID]); EOL("Directory");
+      Asm->EmitString(Directories[DirectoryID]); Asm->EOL("Directory");
     }
-    EmitInt8(0); EOL("End of directories");
+    Asm->EmitInt8(0); Asm->EOL("End of directories");
     
     // Emit files.
     for (unsigned SourceID = 1, NSID = SourceFiles.size();
                  SourceID <= NSID; ++SourceID) {
       const SourceFileInfo &SourceFile = SourceFiles[SourceID];
-      EmitString(SourceFile.getName()); EOL("Source");
-      EmitULEB128Bytes(SourceFile.getDirectoryID());  EOL("Directory #");
-      EmitULEB128Bytes(0);  EOL("Mod date");
-      EmitULEB128Bytes(0);  EOL("File size");
+      Asm->EmitString(SourceFile.getName());
+      Asm->EOL("Source");
+      Asm->EmitULEB128Bytes(SourceFile.getDirectoryID());
+      Asm->EOL("Directory #");
+      Asm->EmitULEB128Bytes(0);
+      Asm->EOL("Mod date");
+      Asm->EmitULEB128Bytes(0);
+      Asm->EOL("File size");
     }
-    EmitInt8(0); EOL("End of files");
+    Asm->EmitInt8(0); Asm->EOL("End of files");
     
     EmitLabel("line_prolog_end", 0);
     
@@ -2366,16 +2185,16 @@
         }
 
         // Define the line address.
-        EmitInt8(0); EOL("Extended Op");
-        EmitInt8(TAI->getAddressSize() + 1); EOL("Op size");
-        EmitInt8(DW_LNE_set_address); EOL("DW_LNE_set_address");
-        EmitReference("loc",  LabelID); EOL("Location label");
+        Asm->EmitInt8(0); Asm->EOL("Extended Op");
+        Asm->EmitInt8(TAI->getAddressSize() + 1); Asm->EOL("Op size");
+        Asm->EmitInt8(DW_LNE_set_address); Asm->EOL("DW_LNE_set_address");
+        EmitReference("loc",  LabelID); Asm->EOL("Location label");
         
         // If change of source, then switch to the new source.
         if (Source != LineInfo.getSourceID()) {
           Source = LineInfo.getSourceID();
-          EmitInt8(DW_LNS_set_file); EOL("DW_LNS_set_file");
-          EmitULEB128Bytes(Source); EOL("New Source");
+          Asm->EmitInt8(DW_LNS_set_file); Asm->EOL("DW_LNS_set_file");
+          Asm->EmitULEB128Bytes(Source); Asm->EOL("New Source");
         }
         
         // If change of line.
@@ -2390,29 +2209,29 @@
           // If delta is small enough and in range...
           if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
             // ... then use fast opcode.
-            EmitInt8(Delta - MinLineDelta); EOL("Line Delta");
+            Asm->EmitInt8(Delta - MinLineDelta); Asm->EOL("Line Delta");
           } else {
             // ... otherwise use long hand.
-            EmitInt8(DW_LNS_advance_line); EOL("DW_LNS_advance_line");
-            EmitSLEB128Bytes(Offset); EOL("Line Offset");
-            EmitInt8(DW_LNS_copy); EOL("DW_LNS_copy");
+            Asm->EmitInt8(DW_LNS_advance_line); Asm->EOL("DW_LNS_advance_line");
+            Asm->EmitSLEB128Bytes(Offset); Asm->EOL("Line Offset");
+            Asm->EmitInt8(DW_LNS_copy); Asm->EOL("DW_LNS_copy");
           }
         } else {
           // Copy the previous row (different address or source)
-          EmitInt8(DW_LNS_copy); EOL("DW_LNS_copy");
+          Asm->EmitInt8(DW_LNS_copy); Asm->EOL("DW_LNS_copy");
         }
       }
 
       // Define last address of section.
-      EmitInt8(0); EOL("Extended Op");
-      EmitInt8(TAI->getAddressSize() + 1); EOL("Op size");
-      EmitInt8(DW_LNE_set_address); EOL("DW_LNE_set_address");
-      EmitReference("section_end", j + 1); EOL("Section end label");
+      Asm->EmitInt8(0); Asm->EOL("Extended Op");
+      Asm->EmitInt8(TAI->getAddressSize() + 1); Asm->EOL("Op size");
+      Asm->EmitInt8(DW_LNE_set_address); Asm->EOL("DW_LNE_set_address");
+      EmitReference("section_end", j + 1); Asm->EOL("Section end label");
 
       // Mark end of matrix.
-      EmitInt8(0); EOL("DW_LNE_end_sequence");
-      EmitULEB128Bytes(1);  O << "\n";
-      EmitInt8(1); O << "\n";
+      Asm->EmitInt8(0); Asm->EOL("DW_LNE_end_sequence");
+      Asm->EmitULEB128Bytes(1);  O << "\n";
+      Asm->EmitInt8(1); O << "\n";
     }
     
     EmitLabel("line_end", 0);
@@ -2437,15 +2256,21 @@
     EmitLabel("frame_common", 0);
     EmitDifference("frame_common_end", 0,
                    "frame_common_begin", 0, true);
-    EOL("Length of Common Information Entry");
+    Asm->EOL("Length of Common Information Entry");
 
     EmitLabel("frame_common_begin", 0);
-    EmitInt32((int)DW_CIE_ID); EOL("CIE Identifier Tag");
-    EmitInt8(DW_CIE_VERSION); EOL("CIE Version");
-    EmitString("");  EOL("CIE Augmentation");
-    EmitULEB128Bytes(1); EOL("CIE Code Alignment Factor");
-    EmitSLEB128Bytes(stackGrowth); EOL("CIE Data Alignment Factor");   
-    EmitInt8(RI->getDwarfRegNum(RI->getRARegister())); EOL("CIE RA Column");
+    Asm->EmitInt32((int)DW_CIE_ID);
+    Asm->EOL("CIE Identifier Tag");
+    Asm->EmitInt8(DW_CIE_VERSION);
+    Asm->EOL("CIE Version");
+    Asm->EmitString("");
+    Asm->EOL("CIE Augmentation");
+    Asm->EmitULEB128Bytes(1);
+    Asm->EOL("CIE Code Alignment Factor");
+    Asm->EmitSLEB128Bytes(stackGrowth);
+    Asm->EOL("CIE Data Alignment Factor");   
+    Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister()));
+    Asm->EOL("CIE RA Column");
     
     std::vector Moves;
     RI->getInitialFrameState(Moves);
@@ -2468,17 +2293,18 @@
     
     EmitDifference("frame_end", SubprogramCount,
                    "frame_begin", SubprogramCount, true);
-    EOL("Length of Frame Information Entry");
+    Asm->EOL("Length of Frame Information Entry");
     
     EmitLabel("frame_begin", SubprogramCount);
     
     EmitDifference("frame_common", 0, "section_frame", 0, true);
-    EOL("FDE CIE offset");
+    Asm->EOL("FDE CIE offset");
 
-    EmitReference("func_begin", SubprogramCount); EOL("FDE initial location");
+    EmitReference("func_begin", SubprogramCount);
+    Asm->EOL("FDE initial location");
     EmitDifference("func_end", SubprogramCount,
                    "func_begin", SubprogramCount);
-    EOL("FDE address range");
+    Asm->EOL("FDE address range");
     
     std::vector &Moves = DebugInfo->getFrameMoves();
     
@@ -2500,17 +2326,17 @@
  
     EmitDifference("pubnames_end", Unit->getID(),
                    "pubnames_begin", Unit->getID(), true);
-    EOL("Length of Public Names Info");
+    Asm->EOL("Length of Public Names Info");
     
     EmitLabel("pubnames_begin", Unit->getID());
     
-    EmitInt16(DWARF_VERSION); EOL("DWARF Version");
+    Asm->EmitInt16(DWARF_VERSION); Asm->EOL("DWARF Version");
     
     EmitDifference("info_begin", Unit->getID(), "section_info", 0, true);
-    EOL("Offset of Compilation Unit Info");
+    Asm->EOL("Offset of Compilation Unit Info");
 
     EmitDifference("info_end", Unit->getID(), "info_begin", Unit->getID(),true);
-    EOL("Compilation Unit Length");
+    Asm->EOL("Compilation Unit Length");
     
     std::map &Globals = Unit->getGlobals();
     
@@ -2520,11 +2346,11 @@
       const std::string &Name = GI->first;
       DIE * Entity = GI->second;
       
-      EmitInt32(Entity->getOffset()); EOL("DIE offset");
-      EmitString(Name); EOL("External Name");
+      Asm->EmitInt32(Entity->getOffset()); Asm->EOL("DIE offset");
+      Asm->EmitString(Name); Asm->EOL("External Name");
     }
   
-    EmitInt32(0); EOL("End Mark");
+    Asm->EmitInt32(0); Asm->EOL("End Mark");
     EmitLabel("pubnames_end", Unit->getID());
   
     O << "\n";
@@ -2545,7 +2371,7 @@
         EmitLabel("string", StringID);
         // Emit the string itself.
         const std::string &String = StringPool[StringID];
-        EmitString(String); O << "\n";
+        Asm->EmitString(String); O << "\n";
       }
     
       O << "\n";
@@ -2572,26 +2398,26 @@
     CompileUnit *Unit = GetBaseCompileUnit(); 
       
     // Don't include size of length
-    EmitInt32(0x1c); EOL("Length of Address Ranges Info");
+    Asm->EmitInt32(0x1c); Asm->EOL("Length of Address Ranges Info");
     
-    EmitInt16(DWARF_VERSION); EOL("Dwarf Version");
+    Asm->EmitInt16(DWARF_VERSION); Asm->EOL("Dwarf Version");
     
     EmitReference("info_begin", Unit->getID());
-    EOL("Offset of Compilation Unit Info");
+    Asm->EOL("Offset of Compilation Unit Info");
 
-    EmitInt8(TAI->getAddressSize()); EOL("Size of Address");
+    Asm->EmitInt8(TAI->getAddressSize()); Asm->EOL("Size of Address");
 
-    EmitInt8(0); EOL("Size of Segment Descriptor");
+    Asm->EmitInt8(0); Asm->EOL("Size of Segment Descriptor");
 
-    EmitInt16(0);  EOL("Pad (1)");
-    EmitInt16(0);  EOL("Pad (2)");
+    Asm->EmitInt16(0);  Asm->EOL("Pad (1)");
+    Asm->EmitInt16(0);  Asm->EOL("Pad (2)");
 
     // Range 1
-    EmitReference("text_begin", 0); EOL("Address");
-    EmitDifference("text_end", 0, "text_begin", 0, true); EOL("Length");
+    EmitReference("text_begin", 0); Asm->EOL("Address");
+    EmitDifference("text_end", 0, "text_begin", 0, true); Asm->EOL("Length");
 
-    EmitInt32(0); EOL("EOM (1)");
-    EmitInt32(0); EOL("EOM (2)");
+    Asm->EmitInt32(0); Asm->EOL("EOM (1)");
+    Asm->EmitInt32(0); Asm->EOL("EOM (2)");
     
     O << "\n";
   #endif
@@ -2724,14 +2550,14 @@
     this->M = M;
     
     if (!ShouldEmitDwarf()) return;
-    EOL("Dwarf Begin Module");
+    Asm->EOL("Dwarf Begin Module");
   }
 
   /// EndModule - Emit all Dwarf sections that should come after the content.
   ///
   void EndModule() {
     if (!ShouldEmitDwarf()) return;
-    EOL("Dwarf End Module");
+    Asm->EOL("Dwarf End Module");
     
     // Standard sections final addresses.
     Asm->SwitchToTextSection(TAI->getTextSection());
@@ -2782,7 +2608,7 @@
     this->MF = MF;
     
     if (!ShouldEmitDwarf()) return;
-    EOL("Dwarf Begin Function");
+    Asm->EOL("Dwarf Begin Function");
 
     // Begin accumulating function debug information.
     DebugInfo->BeginFunction(MF);
@@ -2795,7 +2621,7 @@
   ///
   void EndFunction() {
     if (!ShouldEmitDwarf()) return;
-    EOL("Dwarf End Function");
+    Asm->EOL("Dwarf End Function");
     
     // Define end label for subprogram.
     EmitLabel("func_end", SubprogramCount);
@@ -2835,29 +2661,29 @@
 ///
 void DIEAbbrev::Emit(const Dwarf &DW) const {
   // Emit its Dwarf tag type.
-  DW.EmitULEB128Bytes(Tag);
-  DW.EOL(TagString(Tag));
+  DW.getAsm()->EmitULEB128Bytes(Tag);
+  DW.getAsm()->EOL(TagString(Tag));
   
   // Emit whether it has children DIEs.
-  DW.EmitULEB128Bytes(ChildrenFlag);
-  DW.EOL(ChildrenString(ChildrenFlag));
+  DW.getAsm()->EmitULEB128Bytes(ChildrenFlag);
+  DW.getAsm()->EOL(ChildrenString(ChildrenFlag));
   
   // For each attribute description.
   for (unsigned i = 0, N = Data.size(); i < N; ++i) {
     const DIEAbbrevData &AttrData = Data[i];
     
     // Emit attribute type.
-    DW.EmitULEB128Bytes(AttrData.getAttribute());
-    DW.EOL(AttributeString(AttrData.getAttribute()));
+    DW.getAsm()->EmitULEB128Bytes(AttrData.getAttribute());
+    DW.getAsm()->EOL(AttributeString(AttrData.getAttribute()));
     
     // Emit form type.
-    DW.EmitULEB128Bytes(AttrData.getForm());
-    DW.EOL(FormEncodingString(AttrData.getForm()));
+    DW.getAsm()->EmitULEB128Bytes(AttrData.getForm());
+    DW.getAsm()->EOL(FormEncodingString(AttrData.getForm()));
   }
 
   // Mark end of abbreviation.
-  DW.EmitULEB128Bytes(0); DW.EOL("EOM(1)");
-  DW.EmitULEB128Bytes(0); DW.EOL("EOM(2)");
+  DW.getAsm()->EmitULEB128Bytes(0); DW.getAsm()->EOL("EOM(1)");
+  DW.getAsm()->EmitULEB128Bytes(0); DW.getAsm()->EOL("EOM(2)");
 }
 
 #ifndef NDEBUG
@@ -2897,17 +2723,37 @@
   switch (Form) {
   case DW_FORM_flag:  // Fall thru
   case DW_FORM_ref1:  // Fall thru
-  case DW_FORM_data1: DW.EmitInt8(Integer);         break;
+  case DW_FORM_data1: DW.getAsm()->EmitInt8(Integer);         break;
   case DW_FORM_ref2:  // Fall thru
-  case DW_FORM_data2: DW.EmitInt16(Integer);        break;
+  case DW_FORM_data2: DW.getAsm()->EmitInt16(Integer);        break;
   case DW_FORM_ref4:  // Fall thru
-  case DW_FORM_data4: DW.EmitInt32(Integer);        break;
+  case DW_FORM_data4: DW.getAsm()->EmitInt32(Integer);        break;
   case DW_FORM_ref8:  // Fall thru
-  case DW_FORM_data8: DW.EmitInt64(Integer);        break;
-  case DW_FORM_udata: DW.EmitULEB128Bytes(Integer); break;
-  case DW_FORM_sdata: DW.EmitSLEB128Bytes(Integer); break;
+  case DW_FORM_data8: DW.getAsm()->EmitInt64(Integer);        break;
+  case DW_FORM_udata: DW.getAsm()->EmitULEB128Bytes(Integer); break;
+  case DW_FORM_sdata: DW.getAsm()->EmitSLEB128Bytes(Integer); break;
+  default: assert(0 && "DIE Value form not supported yet");   break;
+  }
+}
+
+/// SizeOf - Determine size of integer value in bytes.
+///
+unsigned DIEInteger::SizeOf(const Dwarf &DW, unsigned Form) const {
+  switch (Form) {
+  case DW_FORM_flag:  // Fall thru
+  case DW_FORM_ref1:  // Fall thru
+  case DW_FORM_data1: return sizeof(int8_t);
+  case DW_FORM_ref2:  // Fall thru
+  case DW_FORM_data2: return sizeof(int16_t);
+  case DW_FORM_ref4:  // Fall thru
+  case DW_FORM_data4: return sizeof(int32_t);
+  case DW_FORM_ref8:  // Fall thru
+  case DW_FORM_data8: return sizeof(int64_t);
+  case DW_FORM_udata: return DW.getAsm()->SizeULEB128(Integer);
+  case DW_FORM_sdata: return DW.getAsm()->SizeSLEB128(Integer);
   default: assert(0 && "DIE Value form not supported yet"); break;
   }
+  return 0;
 }
 
 //===----------------------------------------------------------------------===//
@@ -2915,7 +2761,7 @@
 /// EmitValue - Emit string value.
 ///
 void DIEString::EmitValue(const Dwarf &DW, unsigned Form) const {
-  DW.EmitString(String);
+  DW.getAsm()->EmitString(String);
 }
 
 //===----------------------------------------------------------------------===//
@@ -2967,7 +2813,7 @@
 /// EmitValue - Emit debug information entry offset.
 ///
 void DIEntry::EmitValue(const Dwarf &DW, unsigned Form) const {
-  DW.EmitInt32(Entry->getOffset());
+  DW.getAsm()->EmitInt32(Entry->getOffset());
 }
     
 //===----------------------------------------------------------------------===//
@@ -2989,17 +2835,17 @@
 ///
 void DIEBlock::EmitValue(const Dwarf &DW, unsigned Form) const {
   switch (Form) {
-  case DW_FORM_block1: DW.EmitInt8(Size);         break;
-  case DW_FORM_block2: DW.EmitInt16(Size);        break;
-  case DW_FORM_block4: DW.EmitInt32(Size);        break;
-  case DW_FORM_block:  DW.EmitULEB128Bytes(Size); break;
-  default: assert(0 && "Improper form for block"); break;
+  case DW_FORM_block1: DW.getAsm()->EmitInt8(Size);         break;
+  case DW_FORM_block2: DW.getAsm()->EmitInt16(Size);        break;
+  case DW_FORM_block4: DW.getAsm()->EmitInt32(Size);        break;
+  case DW_FORM_block:  DW.getAsm()->EmitULEB128Bytes(Size); break;
+  default: assert(0 && "Improper form for block");          break;
   }
   
   const std::vector &AbbrevData = Abbrev.getData();
 
   for (unsigned i = 0, N = Values.size(); i < N; ++i) {
-    DW.EOL("");
+    DW.getAsm()->EOL("");
     Values[i]->EmitValue(DW, AbbrevData[i].getForm());
   }
 }
@@ -3011,7 +2857,7 @@
   case DW_FORM_block1: return Size + sizeof(int8_t);
   case DW_FORM_block2: return Size + sizeof(int16_t);
   case DW_FORM_block4: return Size + sizeof(int32_t);
-  case DW_FORM_block: return Size + SizeULEB128(Size);
+  case DW_FORM_block: return Size + DW.getAsm()->SizeULEB128(Size);
   default: assert(0 && "Improper form for block"); break;
   }
   return 0;





From jlaskey at apple.com  Thu Jan 25 09:46:14 2007
From: jlaskey at apple.com (Jim Laskey)
Date: Thu, 25 Jan 2007 09:46:14 -0600
Subject: [llvm-commits] CVS: llvm/lib/CodeGen/DwarfWriter.cpp
Message-ID: <200701251546.l0PFkEqg021767@zion.cs.uiuc.edu>



Changes in directory llvm/lib/CodeGen:

DwarfWriter.cpp updated: 1.114 -> 1.115
---
Log message:

1. Remove dwarf-verbose option (now asm-verbose.)
2. Clean up end of lines.


---
Diffs of the changes:  (+24 -36)

 DwarfWriter.cpp |   60 ++++++++++++++++++++++----------------------------------
 1 files changed, 24 insertions(+), 36 deletions(-)


Index: llvm/lib/CodeGen/DwarfWriter.cpp
diff -u llvm/lib/CodeGen/DwarfWriter.cpp:1.114 llvm/lib/CodeGen/DwarfWriter.cpp:1.115
--- llvm/lib/CodeGen/DwarfWriter.cpp:1.114	Thu Jan 25 09:12:02 2007
+++ llvm/lib/CodeGen/DwarfWriter.cpp	Thu Jan 25 09:45:58 2007
@@ -36,10 +36,6 @@
 using namespace llvm;
 using namespace llvm::dwarf;
 
-static cl::opt
-DwarfVerbose("dwarf-verbose", cl::Hidden,
-                              cl::desc("Add comments to Dwarf directives."));
-
 namespace llvm {
   
 //===----------------------------------------------------------------------===//
@@ -1815,7 +1811,7 @@
     unsigned AbbrevNumber = Die->getAbbrevNumber();
     const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
     
-    O << "\n";
+    Asm->EOL("");
 
     // Emit the code (index) for the abbreviation.
     Asm->EmitULEB128Bytes(AbbrevNumber);
@@ -2045,7 +2041,7 @@
     Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
     EmitLabel("info_end", Unit->getID());
     
-    O << "\n";
+    Asm->EOL("");
   }
 
   /// EmitAbbreviations - Emit the abbreviation section.
@@ -2070,12 +2066,12 @@
         // Emit the abbreviations data.
         Abbrev->Emit(*this);
     
-        O << "\n";
+        Asm->EOL("");
       }
       
       EmitLabel("abbrev_end", 0);
     
-      O << "\n";
+      Asm->EOL("");
     }
   }
 
@@ -2156,12 +2152,7 @@
       // Isolate current sections line info.
       const std::vector &LineInfos = SectionSourceLines[j];
       
-      if (DwarfVerbose) {
-        O << "\t"
-          << TAI->getCommentString() << " "
-          << "Section "
-          << SectionMap[j + 1].c_str() << "\n";
-      }
+      Asm->EOL(std::string("Section ") + SectionMap[j + 1]);
 
       // Dwarf assumes we start with first line of first source file.
       unsigned Source = 1;
@@ -2173,16 +2164,13 @@
         unsigned LabelID = DebugInfo->MappedLabel(LineInfo.getLabelID());
         if (!LabelID) continue;
         
-        if (DwarfVerbose) {
-          unsigned SourceID = LineInfo.getSourceID();
-          const SourceFileInfo &SourceFile = SourceFiles[SourceID];
-          unsigned DirectoryID = SourceFile.getDirectoryID();
-          O << "\t"
-            << TAI->getCommentString() << " "
-            << Directories[DirectoryID]
-            << SourceFile.getName() << ":"
-            << LineInfo.getLine() << "\n"; 
-        }
+        unsigned SourceID = LineInfo.getSourceID();
+        const SourceFileInfo &SourceFile = SourceFiles[SourceID];
+        unsigned DirectoryID = SourceFile.getDirectoryID();
+        Asm->EOL(Directories[DirectoryID]
+          + SourceFile.getName()
+          + ":"
+          + utostr_32(LineInfo.getLine()));
 
         // Define the line address.
         Asm->EmitInt8(0); Asm->EOL("Extended Op");
@@ -2230,13 +2218,13 @@
 
       // Mark end of matrix.
       Asm->EmitInt8(0); Asm->EOL("DW_LNE_end_sequence");
-      Asm->EmitULEB128Bytes(1);  O << "\n";
-      Asm->EmitInt8(1); O << "\n";
+      Asm->EmitULEB128Bytes(1); Asm->EOL("");
+      Asm->EmitInt8(1); Asm->EOL("");
     }
     
     EmitLabel("line_end", 0);
     
-    O << "\n";
+    Asm->EOL("");
   }
     
   /// EmitInitialDebugFrame - Emit common frame info into a debug frame section.
@@ -2279,7 +2267,7 @@
     Asm->EmitAlignment(2);
     EmitLabel("frame_common_end", 0);
     
-    O << "\n";
+    Asm->EOL("");
   }
 
   /// EmitFunctionDebugFrame - Emit per function frame info into a debug frame
@@ -2313,7 +2301,7 @@
     Asm->EmitAlignment(2);
     EmitLabel("frame_end", SubprogramCount);
 
-    O << "\n";
+    Asm->EOL("");
   }
 
   /// EmitDebugPubNames - Emit visible names into a debug pubnames section.
@@ -2353,7 +2341,7 @@
     Asm->EmitInt32(0); Asm->EOL("End Mark");
     EmitLabel("pubnames_end", Unit->getID());
   
-    O << "\n";
+    Asm->EOL("");
   }
 
   /// EmitDebugStr - Emit visible names into a debug str section.
@@ -2371,10 +2359,10 @@
         EmitLabel("string", StringID);
         // Emit the string itself.
         const std::string &String = StringPool[StringID];
-        Asm->EmitString(String); O << "\n";
+        Asm->EmitString(String); Asm->EOL("");
       }
     
-      O << "\n";
+      Asm->EOL("");
     }
   }
 
@@ -2384,7 +2372,7 @@
     // Start the dwarf loc section.
     Asm->SwitchToDataSection(TAI->getDwarfLocSection());
     
-    O << "\n";
+    Asm->EOL("");
   }
 
   /// EmitDebugARanges - Emit visible names into a debug aranges section.
@@ -2419,7 +2407,7 @@
     Asm->EmitInt32(0); Asm->EOL("EOM (1)");
     Asm->EmitInt32(0); Asm->EOL("EOM (2)");
     
-    O << "\n";
+    Asm->EOL("");
   #endif
   }
 
@@ -2429,7 +2417,7 @@
     // Start the dwarf ranges section.
     Asm->SwitchToDataSection(TAI->getDwarfRangesSection());
     
-    O << "\n";
+    Asm->EOL("");
   }
 
   /// EmitDebugMacInfo - Emit visible names into a debug macinfo section.
@@ -2438,7 +2426,7 @@
     // Start the dwarf macinfo section.
     Asm->SwitchToDataSection(TAI->getDwarfMacInfoSection());
     
-    O << "\n";
+    Asm->EOL("");
   }
 
   /// ConstructCompileUnitDIEs - Create a compile unit DIE for each source and





From sabre at nondot.org  Thu Jan 25 11:38:42 2007
From: sabre at nondot.org (Chris Lattner)
Date: Thu, 25 Jan 2007 11:38:42 -0600
Subject: [llvm-commits] CVS: llvm/lib/Transforms/IPO/ExtractFunction.cpp
Message-ID: <200701251738.l0PHcgvL023963@zion.cs.uiuc.edu>



Changes in directory llvm/lib/Transforms/IPO:

ExtractFunction.cpp updated: 1.14 -> 1.15
---
Log message:

Make llvm-extract preserve the callingconv of prototypes in the extracted
code.


---
Diffs of the changes:  (+1 -0)

 ExtractFunction.cpp |    1 +
 1 files changed, 1 insertion(+)


Index: llvm/lib/Transforms/IPO/ExtractFunction.cpp
diff -u llvm/lib/Transforms/IPO/ExtractFunction.cpp:1.14 llvm/lib/Transforms/IPO/ExtractFunction.cpp:1.15
--- llvm/lib/Transforms/IPO/ExtractFunction.cpp:1.14	Fri Oct 20 16:35:41 2006
+++ llvm/lib/Transforms/IPO/ExtractFunction.cpp	Thu Jan 25 11:38:26 2007
@@ -70,6 +70,7 @@
           Function *New = new Function(I->getFunctionType(),
                                        GlobalValue::ExternalLinkage,
                                        I->getName());
+          New->setCallingConv(I->getCallingConv());
           I->setName("");  // Remove Old name
 
           // If it's not the named function, delete the body of the function





From evan.cheng at apple.com  Thu Jan 25 13:44:08 2007
From: evan.cheng at apple.com (Evan Cheng)
Date: Thu, 25 Jan 2007 13:44:08 -0600
Subject: [llvm-commits] CVS: llvm/lib/Target/ARM/ARMConstantIslandPass.cpp
Message-ID: <200701251944.l0PJi8eC026156@zion.cs.uiuc.edu>



Changes in directory llvm/lib/Target/ARM:

ARMConstantIslandPass.cpp updated: 1.3 -> 1.4
---
Log message:

Doh. Skip JT branches.

---
Diffs of the changes:  (+2 -1)

 ARMConstantIslandPass.cpp |    3 ++-
 1 files changed, 2 insertions(+), 1 deletion(-)


Index: llvm/lib/Target/ARM/ARMConstantIslandPass.cpp
diff -u llvm/lib/Target/ARM/ARMConstantIslandPass.cpp:1.3 llvm/lib/Target/ARM/ARMConstantIslandPass.cpp:1.4
--- llvm/lib/Target/ARM/ARMConstantIslandPass.cpp:1.3	Wed Jan 24 21:12:46 2007
+++ llvm/lib/Target/ARM/ARMConstantIslandPass.cpp	Thu Jan 25 13:43:52 2007
@@ -238,7 +238,8 @@
         unsigned Scale = 1;
         int UOpc = Opc;
         switch (Opc) {
-        default: break; // Ignore JT branches
+        default:
+          continue;  // Ignore JT branches
         case ARM::Bcc:
           isCond = true;
           UOpc = ARM::B;





From lauro.venancio at gmail.com  Thu Jan 25 14:11:20 2007
From: lauro.venancio at gmail.com (Lauro Ramos Venancio)
Date: Thu, 25 Jan 2007 14:11:20 -0600
Subject: [llvm-commits] CVS: llvm/lib/Target/ARM/ARMAsmPrinter.cpp
Message-ID: <200701252011.l0PKBKU9026675@zion.cs.uiuc.edu>



Changes in directory llvm/lib/Target/ARM:

ARMAsmPrinter.cpp updated: 1.47 -> 1.48
---
Log message:

Fix elf object definition. 


---
Diffs of the changes:  (+1 -1)

 ARMAsmPrinter.cpp |    2 +-
 1 files changed, 1 insertion(+), 1 deletion(-)


Index: llvm/lib/Target/ARM/ARMAsmPrinter.cpp
diff -u llvm/lib/Target/ARM/ARMAsmPrinter.cpp:1.47 llvm/lib/Target/ARM/ARMAsmPrinter.cpp:1.48
--- llvm/lib/Target/ARM/ARMAsmPrinter.cpp:1.47	Wed Jan 24 21:07:27 2007
+++ llvm/lib/Target/ARM/ARMAsmPrinter.cpp	Thu Jan 25 14:11:04 2007
@@ -725,7 +725,7 @@
       if (const char *Directive = TAI->getHiddenDirective())
         O << Directive << name << "\n";
     if (Subtarget->isTargetELF())
-      O << "\t.type " << name << ", at object\n";
+      O << "\t.type " << name << ",%object\n";
     
     if (C->isNullValue()) {
       if (I->hasExternalLinkage()) {





From lauro.venancio at gmail.com  Thu Jan 25 15:54:38 2007
From: lauro.venancio at gmail.com (Lauro Ramos Venancio)
Date: Thu, 25 Jan 2007 18:54:38 -0300
Subject: [llvm-commits] [patch] Intruction Constraint DestReg!=SrcReg (for
	review)
Message-ID: <9c10c9f0701251354h301eb289ia694c8c13ab8f8ff@mail.gmail.com>

This patch implements the instruction constraint DestReg!=SrcReg. It
is needed by ARM backend.

A sample of use of this constraint is following:

class RegConstraint {
  string Constraints = C;
}

// AI_orr - Defines a (op r, r) pattern.
class AI_orr
  : AI<(ops GPR:$dst, GPR:$a, GPR:$b),
       !strconcat(opc, " $dst, $a, $b"),
       [(set GPR:$dst, (opnode GPR:$a, GPR:$b))]>,
        RegConstraint<"$dst != $a">;


Lauro
-------------- next part --------------
A non-text attachment was scrubbed...
Name: constraint.patch
Type: text/x-patch
Size: 13126 bytes
Desc: not available
Url : http://lists.cs.uiuc.edu/pipermail/llvm-commits/attachments/20070125/395f45d9/attachment.bin 

From lauro.venancio at gmail.com  Thu Jan 25 16:11:23 2007
From: lauro.venancio at gmail.com (Lauro Ramos Venancio)
Date: Thu, 25 Jan 2007 16:11:23 -0600
Subject: [llvm-commits] CVS: llvm/test/CodeGen/ARM/fcopysign.ll
Message-ID: <200701252211.l0PMBNB9004615@zion.cs.uiuc.edu>



Changes in directory llvm/test/CodeGen/ARM:

fcopysign.ll updated: 1.4 -> 1.5
---
Log message:

fix fcopysign test


---
Diffs of the changes:  (+4 -4)

 fcopysign.ll |    8 ++++----
 1 files changed, 4 insertions(+), 4 deletions(-)


Index: llvm/test/CodeGen/ARM/fcopysign.ll
diff -u llvm/test/CodeGen/ARM/fcopysign.ll:1.4 llvm/test/CodeGen/ARM/fcopysign.ll:1.5
--- llvm/test/CodeGen/ARM/fcopysign.ll:1.4	Fri Jan 19 03:20:23 2007
+++ llvm/test/CodeGen/ARM/fcopysign.ll	Thu Jan 25 16:11:02 2007
@@ -1,7 +1,7 @@
-; RUN: llvm-as < fcopysign.ll | llc -march=arm &&
-; RUN: llvm-as < fcopysign.ll | llc -march=arm | grep bic | wc -l | grep 2 &&
-; RUN: llvm-as < fcopysign.ll | llc -march=arm -mattr=+v6,+vfp2 &&
-; RUN: llvm-as < fcopysign.ll | llc -march=arm -mattr=+v6,+vfp2 | grep fneg | wc -l | grep 2
+; RUN: llvm-as < %s | llc -march=arm &&
+; RUN: llvm-as < %s | llc -march=arm | grep bic | wc -l | grep 2 &&
+; RUN: llvm-as < %s | llc -march=arm -mattr=+v6,+vfp2 &&
+; RUN: llvm-as < %s | llc -march=arm -mattr=+v6,+vfp2 | grep fneg | wc -l | grep 2
 
 define float %test1(float %x, double %y) {
 	%tmp = fpext float %x to double





From evan.cheng at apple.com  Thu Jan 25 16:13:00 2007
From: evan.cheng at apple.com (Evan Cheng)
Date: Thu, 25 Jan 2007 16:13:00 -0600
Subject: [llvm-commits] CVS: llvm/lib/CodeGen/PrologEpilogInserter.cpp
Message-ID: <200701252213.l0PMD0so005059@zion.cs.uiuc.edu>



Changes in directory llvm/lib/CodeGen:

PrologEpilogInserter.cpp updated: 1.66 -> 1.67
---
Log message:

Added a MRegisterInfo hook that tells PEI the target is responsible for
rounding the stack frame to a multiple of stack alignment.

---
Diffs of the changes:  (+3 -2)

 PrologEpilogInserter.cpp |    5 +++--
 1 files changed, 3 insertions(+), 2 deletions(-)


Index: llvm/lib/CodeGen/PrologEpilogInserter.cpp
diff -u llvm/lib/CodeGen/PrologEpilogInserter.cpp:1.66 llvm/lib/CodeGen/PrologEpilogInserter.cpp:1.67
--- llvm/lib/CodeGen/PrologEpilogInserter.cpp:1.66	Tue Jan 23 03:36:03 2007
+++ llvm/lib/CodeGen/PrologEpilogInserter.cpp	Thu Jan 25 16:12:41 2007
@@ -389,11 +389,12 @@
   // Round up the size to a multiple of the alignment, but only if there are
   // calls or alloca's in the function.  This ensures that any calls to
   // subroutines have their stack frames suitable aligned.
-  if (FFI->hasCalls() || FFI->hasVarSizedObjects()) {
+  const MRegisterInfo *RegInfo = Fn.getTarget().getRegisterInfo();
+  if (!RegInfo->targetHandlesStackFrameRounding() &&
+      (FFI->hasCalls() || FFI->hasVarSizedObjects())) {
     // When we have no frame pointer, we reserve argument space for call sites
     // in the function immediately on entry to the current function. This
     // eliminates the need for add/sub sp brackets around call sites.
-    const MRegisterInfo *RegInfo = Fn.getTarget().getRegisterInfo();
     if (!RegInfo->hasFP(Fn))
       Offset += FFI->getMaxCallFrameSize();
 





From evan.cheng at apple.com  Thu Jan 25 16:13:00 2007
From: evan.cheng at apple.com (Evan Cheng)
Date: Thu, 25 Jan 2007 16:13:00 -0600
Subject: [llvm-commits] CVS: llvm/include/llvm/Target/MRegisterInfo.h
Message-ID: <200701252213.l0PMD0uh005064@zion.cs.uiuc.edu>



Changes in directory llvm/include/llvm/Target:

MRegisterInfo.h updated: 1.88 -> 1.89
---
Log message:

Added a MRegisterInfo hook that tells PEI the target is responsible for
rounding the stack frame to a multiple of stack alignment.

---
Diffs of the changes:  (+6 -0)

 MRegisterInfo.h |    6 ++++++
 1 files changed, 6 insertions(+)


Index: llvm/include/llvm/Target/MRegisterInfo.h
diff -u llvm/include/llvm/Target/MRegisterInfo.h:1.88 llvm/include/llvm/Target/MRegisterInfo.h:1.89
--- llvm/include/llvm/Target/MRegisterInfo.h:1.88	Wed Jan 24 12:45:12 2007
+++ llvm/include/llvm/Target/MRegisterInfo.h	Thu Jan 25 16:12:41 2007
@@ -367,6 +367,12 @@
     return 0;
   }
 
+  /// targetHandlesStackFrameRounding - Returns true if the target is responsible
+  /// for rounding up the stack frame (probably at emitPrologue time).
+  virtual bool targetHandlesStackFrameRounding() const {
+    return false;
+  }
+
   /// hasFP - Return true if the specified function should have a dedicated frame
   /// pointer register. For most targets this is true only if the function has
   /// variable sized allocas or if frame pointer elimination is disabled.





From evan.cheng at apple.com  Thu Jan 25 16:25:20 2007
From: evan.cheng at apple.com (Evan Cheng)
Date: Thu, 25 Jan 2007 16:25:20 -0600
Subject: [llvm-commits] CVS: llvm/lib/Target/PowerPC/PPCRegisterInfo.cpp
	PPCRegisterInfo.h
Message-ID: <200701252225.l0PMPKG9005685@zion.cs.uiuc.edu>



Changes in directory llvm/lib/Target/PowerPC:

PPCRegisterInfo.cpp updated: 1.97 -> 1.98
PPCRegisterInfo.h updated: 1.23 -> 1.24
---
Log message:

- Tell PEI that PPC will handle stack frame rounding itself.
- Do not round up to max. alignment of stack object if it is > stack alignment.
  It will have to be handled with dynamic aligning code.

---
Diffs of the changes:  (+7 -7)

 PPCRegisterInfo.cpp |    9 ++-------
 PPCRegisterInfo.h   |    5 +++++
 2 files changed, 7 insertions(+), 7 deletions(-)


Index: llvm/lib/Target/PowerPC/PPCRegisterInfo.cpp
diff -u llvm/lib/Target/PowerPC/PPCRegisterInfo.cpp:1.97 llvm/lib/Target/PowerPC/PPCRegisterInfo.cpp:1.98
--- llvm/lib/Target/PowerPC/PPCRegisterInfo.cpp:1.97	Wed Jan 24 12:45:13 2007
+++ llvm/lib/Target/PowerPC/PPCRegisterInfo.cpp	Thu Jan 25 16:25:04 2007
@@ -451,9 +451,6 @@
   // Determine the maximum call stack size.  maxCallFrameSize may be
   // less than the minimum.
   unsigned maxCallFrameSize = MFI->getMaxCallFrameSize();
-  unsigned getMinCallFrameSize =
-    PPCFrameInfo::getMinCallFrameSize(LP64); 
-  maxCallFrameSize = std::max(maxCallFrameSize, getMinCallFrameSize);
   // Get the total frame size.
   unsigned FrameSize = MFI->getStackSize();
   
@@ -712,11 +709,9 @@
   
   // Get the alignments provided by the target, and the maximum alignment
   // (if any) of the fixed frame objects.
-  unsigned TargetAlign = MF.getTarget().getFrameInfo()->getStackAlignment();
   unsigned MaxAlign = MFI->getMaxAlignment();
-  unsigned Align = std::max(TargetAlign, MaxAlign);
-  assert(isPowerOf2_32(Align) && "Alignment is not power of 2");
-  unsigned AlignMask = Align - 1;  //
+  unsigned TargetAlign = MF.getTarget().getFrameInfo()->getStackAlignment();
+  unsigned AlignMask = TargetAlign - 1;  //
 
   // If we are a leaf function, and use up to 224 bytes of stack space,
   // don't have a frame pointer, calls, or dynamic alloca then we do not need


Index: llvm/lib/Target/PowerPC/PPCRegisterInfo.h
diff -u llvm/lib/Target/PowerPC/PPCRegisterInfo.h:1.23 llvm/lib/Target/PowerPC/PPCRegisterInfo.h:1.24
--- llvm/lib/Target/PowerPC/PPCRegisterInfo.h:1.23	Wed Jan 24 12:45:13 2007
+++ llvm/lib/Target/PowerPC/PPCRegisterInfo.h	Thu Jan 25 16:25:04 2007
@@ -58,6 +58,11 @@
 
   const TargetRegisterClass* const* getCalleeSavedRegClasses() const;
 
+  /// targetHandlesStackFrameRounding - Returns true if the target is
+  /// responsible for rounding up the stack frame (probably at emitPrologue
+  /// time).
+  bool targetHandlesStackFrameRounding() const { return true; }
+
   bool hasFP(const MachineFunction &MF) const;
 
   void eliminateCallFramePseudoInstr(MachineFunction &MF,





From dpatel at apple.com  Thu Jan 25 16:27:23 2007
From: dpatel at apple.com (Devang Patel)
Date: Thu, 25 Jan 2007 16:27:23 -0600
Subject: [llvm-commits] CVS: llvm/include/llvm/Pass.h
Message-ID: <200701252227.l0PMRNKc006914@zion.cs.uiuc.edu>



Changes in directory llvm/include/llvm:

Pass.h updated: 1.76 -> 1.77
---
Log message:

Remove dead code.


---
Diffs of the changes:  (+0 -7)

 Pass.h |    7 -------
 1 files changed, 7 deletions(-)


Index: llvm/include/llvm/Pass.h
diff -u llvm/include/llvm/Pass.h:1.76 llvm/include/llvm/Pass.h:1.77
--- llvm/include/llvm/Pass.h:1.76	Wed Jan 17 14:30:17 2007
+++ llvm/include/llvm/Pass.h	Thu Jan 25 16:27:00 2007
@@ -46,9 +46,7 @@
 class AnalysisUsage;
 class PassInfo;
 class ImmutablePass;
-template class PassManagerT;
 class BasicBlockPassManager;
-class FunctionPassManagerT;
 class ModulePassManager;
 class PMStack;
 class AnalysisResolver;
@@ -190,11 +188,6 @@
   template
   AnalysisType &getAnalysisID(const PassInfo *PI) const;
     
-private:
-  template friend class PassManagerT;
-  friend class ModulePassManager;
-  friend class FunctionPassManagerT;
-  friend class BasicBlockPassManager;
 };
 
 inline std::ostream &operator<<(std::ostream &OS, const Pass &P) {





From evan.cheng at apple.com  Thu Jan 25 16:28:53 2007
From: evan.cheng at apple.com (Evan Cheng)
Date: Thu, 25 Jan 2007 16:28:53 -0600
Subject: [llvm-commits] CVS: llvm/test/CodeGen/PowerPC/Frames-align.ll
Message-ID: <200701252228.l0PMSrK9007817@zion.cs.uiuc.edu>



Changes in directory llvm/test/CodeGen/PowerPC:

Frames-align.ll updated: 1.3 -> 1.4
---
Log message:

Fix test case.

---
Diffs of the changes:  (+1 -1)

 Frames-align.ll |    2 +-
 1 files changed, 1 insertion(+), 1 deletion(-)


Index: llvm/test/CodeGen/PowerPC/Frames-align.ll
diff -u llvm/test/CodeGen/PowerPC/Frames-align.ll:1.3 llvm/test/CodeGen/PowerPC/Frames-align.ll:1.4
--- llvm/test/CodeGen/PowerPC/Frames-align.ll:1.3	Wed Dec 20 18:01:42 2006
+++ llvm/test/CodeGen/PowerPC/Frames-align.ll	Thu Jan 25 16:28:32 2007
@@ -1,5 +1,5 @@
 ; RUN: llvm-upgrade < %s | llvm-as | llc -march=ppc32 -mtriple=powerpc-apple-darwin8 | grep 'rlwinm r0, r1, 0, 22, 31' &&
-; RUN: llvm-upgrade < %s | llvm-as | llc -march=ppc32 -mtriple=powerpc-apple-darwin8 | grep 'subfic r0, r0, -17408' &&
+; RUN: llvm-upgrade < %s | llvm-as | llc -march=ppc32 -mtriple=powerpc-apple-darwin8 | grep 'subfic r0, r0, -16448' &&
 ; RUN: llvm-upgrade < %s | llvm-as | llc -march=ppc64 -mtriple=powerpc-apple-darwin8 | grep 'rldicl r0, r1, 0, 54'
 
 





From jlaskey at apple.com  Thu Jan 25 16:40:29 2007
From: jlaskey at apple.com (Jim Laskey)
Date: Thu, 25 Jan 2007 18:40:29 -0400
Subject: [llvm-commits] CVS: llvm/lib/Target/PowerPC/PPCRegisterInfo.cpp
	PPCRegisterInfo.h
In-Reply-To: <200701252225.l0PMPKG9005685@zion.cs.uiuc.edu>
References: <200701252225.l0PMPKG9005685@zion.cs.uiuc.edu>
Message-ID: 


On 25-Jan-07, at 06:25 PM, Evan Cheng wrote:

> Index: llvm/lib/Target/PowerPC/PPCRegisterInfo.cpp
> diff -u llvm/lib/Target/PowerPC/PPCRegisterInfo.cpp:1.97 llvm/lib/ 
> Target/PowerPC/PPCRegisterInfo.cpp:1.98
> --- llvm/lib/Target/PowerPC/PPCRegisterInfo.cpp:1.97	Wed Jan 24  
> 12:45:13 2007
> +++ llvm/lib/Target/PowerPC/PPCRegisterInfo.cpp	Thu Jan 25 16:25:04  
> 2007
> @@ -451,9 +451,6 @@
>    // Determine the maximum call stack size.  maxCallFrameSize may be
>    // less than the minimum.
>    unsigned maxCallFrameSize = MFI->getMaxCallFrameSize();
> -  unsigned getMinCallFrameSize =
> -    PPCFrameInfo::getMinCallFrameSize(LP64);
> -  maxCallFrameSize = std::max(maxCallFrameSize, getMinCallFrameSize);
>    // Get the total frame size.
>    unsigned FrameSize = MFI->getStackSize();


Why did you remove this?

-- Jim
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://lists.cs.uiuc.edu/pipermail/llvm-commits/attachments/20070125/5efb044f/attachment.html 
-------------- next part --------------
A non-text attachment was scrubbed...
Name: smime.p7s
Type: application/pkcs7-signature
Size: 2417 bytes
Desc: not available
Url : http://lists.cs.uiuc.edu/pipermail/llvm-commits/attachments/20070125/5efb044f/attachment.bin 

From jlaskey at apple.com  Thu Jan 25 16:48:16 2007
From: jlaskey at apple.com (Jim Laskey)
Date: Thu, 25 Jan 2007 18:48:16 -0400
Subject: [llvm-commits] CVS: llvm/lib/Target/PowerPC/PPCRegisterInfo.cpp
	PPCRegisterInfo.h
In-Reply-To: 
References: <200701252225.l0PMPKG9005685@zion.cs.uiuc.edu>
	
Message-ID: 

NVM. I forgot this was redundant. -- Jim




On 25-Jan-07, at 06:40 PM, Jim Laskey wrote:

>
> On 25-Jan-07, at 06:25 PM, Evan Cheng wrote:
>
>> Index: llvm/lib/Target/PowerPC/PPCRegisterInfo.cpp
>> diff -u llvm/lib/Target/PowerPC/PPCRegisterInfo.cpp:1.97 llvm/lib/ 
>> Target/PowerPC/PPCRegisterInfo.cpp:1.98
>> --- llvm/lib/Target/PowerPC/PPCRegisterInfo.cpp:1.97	Wed Jan 24  
>> 12:45:13 2007
>> +++ llvm/lib/Target/PowerPC/PPCRegisterInfo.cpp	Thu Jan 25  
>> 16:25:04 2007
>> @@ -451,9 +451,6 @@
>>    // Determine the maximum call stack size.  maxCallFrameSize may be
>>    // less than the minimum.
>>    unsigned maxCallFrameSize = MFI->getMaxCallFrameSize();
>> -  unsigned getMinCallFrameSize =
>> -    PPCFrameInfo::getMinCallFrameSize(LP64);
>> -  maxCallFrameSize = std::max(maxCallFrameSize,  
>> getMinCallFrameSize);
>>    // Get the total frame size.
>>    unsigned FrameSize = MFI->getStackSize();
>
>
> Why did you remove this?
>
> -- Jim
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits

-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://lists.cs.uiuc.edu/pipermail/llvm-commits/attachments/20070125/2c5f747b/attachment.html 
-------------- next part --------------
A non-text attachment was scrubbed...
Name: smime.p7s
Type: application/pkcs7-signature
Size: 2417 bytes
Desc: not available
Url : http://lists.cs.uiuc.edu/pipermail/llvm-commits/attachments/20070125/2c5f747b/attachment.bin 

From evan.cheng at apple.com  Thu Jan 25 16:48:41 2007
From: evan.cheng at apple.com (Evan Cheng)
Date: Thu, 25 Jan 2007 16:48:41 -0600
Subject: [llvm-commits] CVS: llvm/lib/Target/PowerPC/PPCRegisterInfo.cpp
Message-ID: <200701252248.l0PMmfcv008843@zion.cs.uiuc.edu>



Changes in directory llvm/lib/Target/PowerPC:

PPCRegisterInfo.cpp updated: 1.98 -> 1.99
---
Log message:

Fix comment.

---
Diffs of the changes:  (+1 -2)

 PPCRegisterInfo.cpp |    3 +--
 1 files changed, 1 insertion(+), 2 deletions(-)


Index: llvm/lib/Target/PowerPC/PPCRegisterInfo.cpp
diff -u llvm/lib/Target/PowerPC/PPCRegisterInfo.cpp:1.98 llvm/lib/Target/PowerPC/PPCRegisterInfo.cpp:1.99
--- llvm/lib/Target/PowerPC/PPCRegisterInfo.cpp:1.98	Thu Jan 25 16:25:04 2007
+++ llvm/lib/Target/PowerPC/PPCRegisterInfo.cpp	Thu Jan 25 16:48:25 2007
@@ -448,8 +448,7 @@
   // Determine whether 64-bit pointers are used.
   bool LP64 = Subtarget.isPPC64();
 
-  // Determine the maximum call stack size.  maxCallFrameSize may be
-  // less than the minimum.
+  // Get the maximum call stack size.
   unsigned maxCallFrameSize = MFI->getMaxCallFrameSize();
   // Get the total frame size.
   unsigned FrameSize = MFI->getStackSize();





From evan.cheng at apple.com  Thu Jan 25 17:18:32 2007
From: evan.cheng at apple.com (Evan Cheng)
Date: Thu, 25 Jan 2007 17:18:32 -0600
Subject: [llvm-commits] CVS: llvm/lib/Target/ARM/ARMRegisterInfo.cpp
Message-ID: <200701252318.l0PNIWdT009345@zion.cs.uiuc.edu>



Changes in directory llvm/lib/Target/ARM:

ARMRegisterInfo.cpp updated: 1.40 -> 1.41
---
Log message:

I am an idiot.

---
Diffs of the changes:  (+1 -1)

 ARMRegisterInfo.cpp |    2 +-
 1 files changed, 1 insertion(+), 1 deletion(-)


Index: llvm/lib/Target/ARM/ARMRegisterInfo.cpp
diff -u llvm/lib/Target/ARM/ARMRegisterInfo.cpp:1.40 llvm/lib/Target/ARM/ARMRegisterInfo.cpp:1.41
--- llvm/lib/Target/ARM/ARMRegisterInfo.cpp:1.40	Tue Jan 23 03:37:21 2007
+++ llvm/lib/Target/ARM/ARMRegisterInfo.cpp	Thu Jan 25 17:18:16 2007
@@ -984,7 +984,7 @@
                  AFI->getGPRCalleeSavedArea2Size() +
                  AFI->getDPRCalleeSavedAreaSize());
     if (isThumb)
-      emitSPUpdate(MBB, MBBI, -NumBytes, isThumb, TII);
+      emitSPUpdate(MBB, MBBI, NumBytes, isThumb, TII);
     else {
       if (STI.isTargetDarwin()) {
         NumBytes = AFI->getFramePtrSpillOffset() - NumBytes;





From evan.cheng at apple.com  Thu Jan 25 17:19:17 2007
From: evan.cheng at apple.com (Evan Cheng)
Date: Thu, 25 Jan 2007 17:19:17 -0600
Subject: [llvm-commits] CVS: llvm/lib/Target/ARM/ARMConstantIslandPass.cpp
Message-ID: <200701252319.l0PNJH0a009368@zion.cs.uiuc.edu>



Changes in directory llvm/lib/Target/ARM:

ARMConstantIslandPass.cpp updated: 1.4 -> 1.5
---
Log message:

Add comment, fix typo, reduce memory usage, etc.

---
Diffs of the changes:  (+14 -9)

 ARMConstantIslandPass.cpp |   23 ++++++++++++++---------
 1 files changed, 14 insertions(+), 9 deletions(-)


Index: llvm/lib/Target/ARM/ARMConstantIslandPass.cpp
diff -u llvm/lib/Target/ARM/ARMConstantIslandPass.cpp:1.4 llvm/lib/Target/ARM/ARMConstantIslandPass.cpp:1.5
--- llvm/lib/Target/ARM/ARMConstantIslandPass.cpp:1.4	Thu Jan 25 13:43:52 2007
+++ llvm/lib/Target/ARM/ARMConstantIslandPass.cpp	Thu Jan 25 17:18:59 2007
@@ -79,14 +79,14 @@
     /// opcode.
     struct ImmBranch {
       MachineInstr *MI;
-      bool isCond;
+      unsigned MaxDisp : 31;
+      bool isCond : 1;
       int UncondBr;
-      unsigned MaxDisp;
-      ImmBranch(MachineInstr *mi, bool cond, int ubr, unsigned maxdisp)
-        : MI(mi), isCond(cond), UncondBr(ubr), MaxDisp(maxdisp) {}
+      ImmBranch(MachineInstr *mi, unsigned maxdisp, bool cond, int ubr)
+        : MI(mi), MaxDisp(maxdisp), isCond(cond), UncondBr(ubr) {}
     };
 
-    /// Branches - Keep track of all the immediate branche instructions.
+    /// Branches - Keep track of all the immediate branch instructions.
     ///
     std::vector ImmBranches;
 
@@ -107,7 +107,7 @@
     void SplitBlockBeforeInstr(MachineInstr *MI);
     void UpdateForInsertedWaterBlock(MachineBasicBlock *NewBB);
     bool HandleConstantPoolUser(MachineFunction &Fn, CPUser &U);
-    bool ShortenImmediateBranch(MachineFunction &Fn, ImmBranch &Br);
+    bool FixUpImmediateBranch(MachineFunction &Fn, ImmBranch &Br);
 
     unsigned GetInstSize(MachineInstr *MI) const;
     unsigned GetOffsetOf(MachineInstr *MI) const;
@@ -154,7 +154,7 @@
     for (unsigned i = 0, e = CPUsers.size(); i != e; ++i)
       MadeChange |= HandleConstantPoolUser(Fn, CPUsers[i]);
     for (unsigned i = 0, e = ImmBranches.size(); i != e; ++i)
-      MadeChange |= ShortenImmediateBranch(Fn, ImmBranches[i]);
+      MadeChange |= FixUpImmediateBranch(Fn, ImmBranches[i]);
   } while (MadeChange);
   
   BBSizes.clear();
@@ -260,7 +260,7 @@
           break;
         }
         unsigned MaxDisp = (1 << (Bits-1)) * Scale;
-        ImmBranches.push_back(ImmBranch(I, isCond, UOpc, MaxDisp));
+        ImmBranches.push_back(ImmBranch(I, MaxDisp, isCond, UOpc));
       }
 
       // Scan the instructions for constant pool operands.
@@ -560,8 +560,13 @@
   return true;
 }
 
+/// FixUpImmediateBranch - Fix up immediate branches whose destination is too
+/// far away to fit in its displacement field. If it is a conditional branch,
+/// then it is converted to an inverse conditional branch + an unconditional
+/// branch to the destination. If it is an unconditional branch, then it is
+/// converted to a branch to a branch.
 bool
-ARMConstantIslands::ShortenImmediateBranch(MachineFunction &Fn, ImmBranch &Br) {
+ARMConstantIslands::FixUpImmediateBranch(MachineFunction &Fn, ImmBranch &Br) {
   MachineInstr *MI = Br.MI;
   MachineBasicBlock *DestBB = MI->getOperand(0).getMachineBasicBlock();
 





From dpatel at apple.com  Thu Jan 25 17:23:44 2007
From: dpatel at apple.com (Devang Patel)
Date: Thu, 25 Jan 2007 17:23:44 -0600
Subject: [llvm-commits] CVS: llvm/lib/Transforms/Scalar/DCE.cpp
Message-ID: <200701252323.l0PNNiF4009467@zion.cs.uiuc.edu>



Changes in directory llvm/lib/Transforms/Scalar:

DCE.cpp updated: 1.61 -> 1.62
---
Log message:

Inherit BasicBlockPass directly from Pass.


---
Diffs of the changes:  (+1 -1)

 DCE.cpp |    2 +-
 1 files changed, 1 insertion(+), 1 deletion(-)


Index: llvm/lib/Transforms/Scalar/DCE.cpp
diff -u llvm/lib/Transforms/Scalar/DCE.cpp:1.61 llvm/lib/Transforms/Scalar/DCE.cpp:1.62
--- llvm/lib/Transforms/Scalar/DCE.cpp:1.61	Tue Dec 19 15:40:18 2006
+++ llvm/lib/Transforms/Scalar/DCE.cpp	Thu Jan 25 17:23:25 2007
@@ -53,7 +53,7 @@
   RegisterPass X("die", "Dead Instruction Elimination");
 }
 
-FunctionPass *llvm::createDeadInstEliminationPass() {
+Pass *llvm::createDeadInstEliminationPass() {
   return new DeadInstElimination();
 }
 





From dpatel at apple.com  Thu Jan 25 17:23:45 2007
From: dpatel at apple.com (Devang Patel)
Date: Thu, 25 Jan 2007 17:23:45 -0600
Subject: [llvm-commits] CVS: llvm/include/llvm/Transforms/Scalar.h
Message-ID: <200701252323.l0PNNjGJ009473@zion.cs.uiuc.edu>



Changes in directory llvm/include/llvm/Transforms:

Scalar.h updated: 1.69 -> 1.70
---
Log message:

Inherit BasicBlockPass directly from Pass.


---
Diffs of the changes:  (+3 -3)

 Scalar.h |    6 +++---
 1 files changed, 3 insertions(+), 3 deletions(-)


Index: llvm/include/llvm/Transforms/Scalar.h
diff -u llvm/include/llvm/Transforms/Scalar.h:1.69 llvm/include/llvm/Transforms/Scalar.h:1.70
--- llvm/include/llvm/Transforms/Scalar.h:1.69	Fri Oct 13 15:53:50 2006
+++ llvm/include/llvm/Transforms/Scalar.h	Thu Jan 25 17:23:25 2007
@@ -19,8 +19,8 @@
 
 namespace llvm {
 
-class ModulePass;
 class FunctionPass;
+class Pass;
 class GetElementPtrInst;
 class PassInfo;
 class TerminatorInst;
@@ -52,7 +52,7 @@
 // without modifying the CFG of the function.  It is a BasicBlockPass, so it
 // runs efficiently when queued next to other BasicBlockPass's.
 //
-FunctionPass *createDeadInstEliminationPass();
+Pass *createDeadInstEliminationPass();
 
 //===----------------------------------------------------------------------===//
 //
@@ -249,7 +249,7 @@
 //
 //   AU.addRequiredID(LowerAllocationsID);
 //
-FunctionPass *createLowerAllocationsPass(bool LowerMallocArgToInteger = false);
+Pass *createLowerAllocationsPass(bool LowerMallocArgToInteger = false);
 extern const PassInfo *LowerAllocationsID;
 
 //===----------------------------------------------------------------------===//





From dpatel at apple.com  Thu Jan 25 17:23:48 2007
From: dpatel at apple.com (Devang Patel)
Date: Thu, 25 Jan 2007 17:23:48 -0600
Subject: [llvm-commits] CVS: llvm/include/llvm/Pass.h
Message-ID: <200701252323.l0PNNmPx009479@zion.cs.uiuc.edu>



Changes in directory llvm/include/llvm:

Pass.h updated: 1.77 -> 1.78
---
Log message:

Inherit BasicBlockPass directly from Pass.


---
Diffs of the changes:  (+1 -1)

 Pass.h |    2 +-
 1 files changed, 1 insertion(+), 1 deletion(-)


Index: llvm/include/llvm/Pass.h
diff -u llvm/include/llvm/Pass.h:1.77 llvm/include/llvm/Pass.h:1.78
--- llvm/include/llvm/Pass.h:1.77	Thu Jan 25 16:27:00 2007
+++ llvm/include/llvm/Pass.h	Thu Jan 25 17:23:25 2007
@@ -291,7 +291,7 @@
 ///      other basic block in the function.
 ///   3. Optimizations conform to all of the constraints of FunctionPasses.
 ///
-class BasicBlockPass : public FunctionPass {
+class BasicBlockPass : public Pass {
 public:
   /// doInitialization - Virtual method overridden by subclasses to do
   /// any necessary per-module initialization.





From dpatel at apple.com  Thu Jan 25 17:23:48 2007
From: dpatel at apple.com (Devang Patel)
Date: Thu, 25 Jan 2007 17:23:48 -0600
Subject: [llvm-commits] CVS: llvm/lib/Transforms/Utils/LowerAllocations.cpp
Message-ID: <200701252323.l0PNNmdK009484@zion.cs.uiuc.edu>



Changes in directory llvm/lib/Transforms/Utils:

LowerAllocations.cpp updated: 1.70 -> 1.71
---
Log message:

Inherit BasicBlockPass directly from Pass.


---
Diffs of the changes:  (+1 -1)

 LowerAllocations.cpp |    2 +-
 1 files changed, 1 insertion(+), 1 deletion(-)


Index: llvm/lib/Transforms/Utils/LowerAllocations.cpp
diff -u llvm/lib/Transforms/Utils/LowerAllocations.cpp:1.70 llvm/lib/Transforms/Utils/LowerAllocations.cpp:1.71
--- llvm/lib/Transforms/Utils/LowerAllocations.cpp:1.70	Sun Jan  7 02:12:01 2007
+++ llvm/lib/Transforms/Utils/LowerAllocations.cpp	Thu Jan 25 17:23:25 2007
@@ -73,7 +73,7 @@
 // Publically exposed interface to pass...
 const PassInfo *llvm::LowerAllocationsID = X.getPassInfo();
 // createLowerAllocationsPass - Interface to this file...
-FunctionPass *llvm::createLowerAllocationsPass(bool LowerMallocArgToInteger) {
+Pass *llvm::createLowerAllocationsPass(bool LowerMallocArgToInteger) {
   return new LowerAllocations(LowerMallocArgToInteger);
 }
 





From evan.cheng at apple.com  Thu Jan 25 17:31:20 2007
From: evan.cheng at apple.com (Evan Cheng)
Date: Thu, 25 Jan 2007 17:31:20 -0600
Subject: [llvm-commits] CVS: llvm/lib/Target/ARM/ARMConstantIslandPass.cpp
Message-ID: <200701252331.l0PNVK3h009614@zion.cs.uiuc.edu>



Changes in directory llvm/lib/Target/ARM:

ARMConstantIslandPass.cpp updated: 1.5 -> 1.6
---
Log message:

Forgot to update this.

---
Diffs of the changes:  (+1 -1)

 ARMConstantIslandPass.cpp |    2 +-
 1 files changed, 1 insertion(+), 1 deletion(-)


Index: llvm/lib/Target/ARM/ARMConstantIslandPass.cpp
diff -u llvm/lib/Target/ARM/ARMConstantIslandPass.cpp:1.5 llvm/lib/Target/ARM/ARMConstantIslandPass.cpp:1.6
--- llvm/lib/Target/ARM/ARMConstantIslandPass.cpp:1.5	Thu Jan 25 17:18:59 2007
+++ llvm/lib/Target/ARM/ARMConstantIslandPass.cpp	Thu Jan 25 17:31:04 2007
@@ -613,7 +613,7 @@
   Br.MI = &MBB->back();
   BuildMI(MBB, TII->get(Br.UncondBr)).addMBB(DestBB);
   unsigned MaxDisp = (Br.UncondBr == ARM::tB) ? (1<<10)*2 : (1<<23)*4;
-  ImmBranches.push_back(ImmBranch(&MBB->back(), false, Br.UncondBr, MaxDisp));
+  ImmBranches.push_back(ImmBranch(&MBB->back(), MaxDisp, false, Br.UncondBr));
   MI->eraseFromParent();
 
   // Increase the size of MBB to account for the new unconditional branch.





From dpatel at apple.com  Thu Jan 25 18:23:16 2007
From: dpatel at apple.com (Devang Patel)
Date: Thu, 25 Jan 2007 18:23:16 -0600
Subject: [llvm-commits] CVS: llvm/include/llvm/Pass.h
Message-ID: <200701260023.l0Q0NGkc013173@zion.cs.uiuc.edu>



Changes in directory llvm/include/llvm:

Pass.h updated: 1.78 -> 1.79
---
Log message:

Inherit FunctionPass directly from Pass.


---
Diffs of the changes:  (+1 -1)

 Pass.h |    2 +-
 1 files changed, 1 insertion(+), 1 deletion(-)


Index: llvm/include/llvm/Pass.h
diff -u llvm/include/llvm/Pass.h:1.78 llvm/include/llvm/Pass.h:1.79
--- llvm/include/llvm/Pass.h:1.78	Thu Jan 25 17:23:25 2007
+++ llvm/include/llvm/Pass.h	Thu Jan 25 18:23:00 2007
@@ -247,7 +247,7 @@
 ///  2. Optimizing a function does not cause the addition or removal of any
 ///     functions in the module
 ///
-class FunctionPass : public ModulePass {
+class FunctionPass : public Pass {
 public:
   /// doInitialization - Virtual method overridden by subclasses to do
   /// any necessary per-module initialization.





From evan.cheng at apple.com  Thu Jan 25 18:25:15 2007
From: evan.cheng at apple.com (Evan Cheng)
Date: Thu, 25 Jan 2007 16:25:15 -0800
Subject: [llvm-commits] [patch] Intruction Constraint DestReg!=SrcReg
	(for review)
In-Reply-To: <9c10c9f0701251354h301eb289ia694c8c13ab8f8ff@mail.gmail.com>
References: <9c10c9f0701251354h301eb289ia694c8c13ab8f8ff@mail.gmail.com>
Message-ID: <361E3BFE-3731-4265-80BC-AF188AD64221@apple.com>

Hi Lauro,

Thanks for taking a crack at this! Your work is much appreciated.

However, I have some comments. :-)

1. I think rather than adding a constraint that says a source operand  
must not be assigned the same register as another. It would be better  
if you add a constraint that says a source operand "can be killed at  
issue cycle + n". The live range analysis current assumes every  
source operand read is completed at issue cycle + 0 and write back  
happens at issue cycle + 2. By changing the read latency to 2 you can  
force a source operand to conflict with a destination operand.

2. Please write more comments. :-)

Thanks,

Evan

On Jan 25, 2007, at 1:54 PM, Lauro Ramos Venancio wrote:

> This patch implements the instruction constraint DestReg!=SrcReg. It
> is needed by ARM backend.
>
> A sample of use of this constraint is following:
>
> class RegConstraint {
>  string Constraints = C;
> }
>
> // AI_orr - Defines a (op r, r) pattern.
> class AI_orr
>  : AI<(ops GPR:$dst, GPR:$a, GPR:$b),
>       !strconcat(opc, " $dst, $a, $b"),
>       [(set GPR:$dst, (opnode GPR:$a, GPR:$b))]>,
>        RegConstraint<"$dst != $a">;
>
>
> Lauro
> 
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits



From evan.cheng at apple.com  Thu Jan 25 18:42:25 2007
From: evan.cheng at apple.com (Evan Cheng)
Date: Thu, 25 Jan 2007 16:42:25 -0800
Subject: [llvm-commits] InReg patch for review
In-Reply-To: <1169557998.14117.151.camel@asl.dorms.spbu.ru>
References: <1169557998.14117.151.camel@asl.dorms.spbu.ru>
Message-ID: <5AF9B69F-3B35-47DD-888E-005B8B5C7EA7@apple.com>

Comments:

diff -r bdd0e76350e4 lib/Target/PowerPC/PPCISelLowering.cpp
--- a/lib/Target/PowerPC/PPCISelLowering.cpp	Tue Jan 23 13:34:14 2007  
+0300
+++ b/lib/Target/PowerPC/PPCISelLowering.cpp	Tue Jan 23 01:12:46 2007  
+0300
@@ -1360,9 +1360,10 @@ static SDOperand LowerCALL(SDOperand Op,
      // On PPC64, promote integers to 64-bit values.
      if (isPPC64 && Arg.getValueType() == MVT::i32) {
-      unsigned ExtOp = ISD::ZERO_EXTEND;
-      if (cast(Op.getOperand(5+2*i+1))->getValue())
-        ExtOp = ISD::SIGN_EXTEND;
+      unsigned Flags =
+        dyn_cast(Op.getOperand(5+2*i+1))->getValue();
+      unsigned ExtOp = (Flags & 1) ? ISD::SIGN_EXTEND :  
ISD::ZERO_EXTEND;
+
        Arg = DAG.getNode(ExtOp, MVT::i64, Arg);
      }

Please use cast<> not dyn_cast<> here.

    // Add one result value for each formal argument.
    std::vector RetVals;
+  unsigned j = 0;
    for (Function::arg_iterator I = F.arg_begin(), E = F.arg_end();  
I != E; ++I) {
      MVT::ValueType VT = getValueType(I->getType());
+    bool isInReg = FTy->paramHasAttr(++j,  
FunctionType::InRegAttribute);
+    unsigned Flags = (isInReg << 1);

+  // Handle regparm attribute
+  std::vector ArgInRegs(NumArgs, false);
+  if (!isVarArg) {
+    for (unsigned i = 0; i(Op.getOperand(3+i))- 
 >getValue();
+      if ((Flags >> 1) & 1)
+        ArgInRegs[i] = true;
+    }
+  }

Please add getter / setter routines for these attributes.

In LowerFastCCArguments():

-      if (ObjectVT == MVT::i64 && ObjIntRegs) {
-        SDOperand ArgValue2 = DAG.getLoad(Op.Val->getValueType(i),  
Root, FIN,
-                                          NULL, 0);
-        ArgValue = DAG.getNode(ISD::BUILD_PAIR, MVT::i64, ArgValue,  
ArgValue2);
-      } else
-        ArgValue = DAG.getLoad(Op.Val->getValueType(i), Root, FIN,  
NULL, 0);
+      ArgValue = DAG.getLoad(Op.Val->getValueType(i), Root, FIN,  
NULL, 0);
+

I am not following. How are you passing i64 values? It has to take 2  
registers, right?

-    Entry.isSigned = false;
+    Entry.isSigned = false; Entry.isInReg = false;
      Args.push_back(Entry);
      // Extend the unsigned i8 argument to be an int value for the  
call.
      Entry.Node = DAG.getNode(ISD::ZERO_EXTEND, MVT::i32,  
Op.getOperand(2));
      Entry.Ty = IntPtrTy;
-    Entry.isSigned = false;
+    Entry.isSigned = false; Entry.isInReg = false;

Please separate each statement to its own line. :-)

The rest looks good! Thanks.

Evan

On Jan 23, 2007, at 5:13 AM, Anton Korobeynikov wrote:

> Hello, Everyone.
>
> Attached patch will implement "inreg" function argument attribute,  
> which
> is used to tell backend "place this argument in register, if  
> possible".
> The needed changes in x86 backend were made as well.
>
> This also allowed to merge C & StdCall CCs and Fast & FastCall CCs
> inside x86 backend.
>
> This patch is first step for supporting gcc's "regparm" function
> attribute.
>
> -- 
> With best regards, Anton Korobeynikov.
>
> Faculty of Mathematics & Mechanics, Saint Petersburg State University.
>
> 
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits



From dpatel at apple.com  Thu Jan 25 18:47:58 2007
From: dpatel at apple.com (Devang Patel)
Date: Thu, 25 Jan 2007 18:47:58 -0600
Subject: [llvm-commits] CVS: llvm/lib/Transforms/IPO/ArgumentPromotion.cpp
	InlineSimple.cpp PruneEH.cpp
Message-ID: <200701260047.l0Q0lwRU013696@zion.cs.uiuc.edu>



Changes in directory llvm/lib/Transforms/IPO:

ArgumentPromotion.cpp updated: 1.33 -> 1.34
InlineSimple.cpp updated: 1.76 -> 1.77
PruneEH.cpp updated: 1.26 -> 1.27
---
Log message:

Inherit CallGraphSCCPass directly from Pass.


---
Diffs of the changes:  (+3 -3)

 ArgumentPromotion.cpp |    2 +-
 InlineSimple.cpp      |    2 +-
 PruneEH.cpp           |    2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)


Index: llvm/lib/Transforms/IPO/ArgumentPromotion.cpp
diff -u llvm/lib/Transforms/IPO/ArgumentPromotion.cpp:1.33 llvm/lib/Transforms/IPO/ArgumentPromotion.cpp:1.34
--- llvm/lib/Transforms/IPO/ArgumentPromotion.cpp:1.33	Sat Dec 30 23:48:39 2006
+++ llvm/lib/Transforms/IPO/ArgumentPromotion.cpp	Thu Jan 25 18:47:38 2007
@@ -72,7 +72,7 @@
                                "Promote 'by reference' arguments to scalars");
 }
 
-ModulePass *llvm::createArgumentPromotionPass() {
+Pass *llvm::createArgumentPromotionPass() {
   return new ArgPromotion();
 }
 


Index: llvm/lib/Transforms/IPO/InlineSimple.cpp
diff -u llvm/lib/Transforms/IPO/InlineSimple.cpp:1.76 llvm/lib/Transforms/IPO/InlineSimple.cpp:1.77
--- llvm/lib/Transforms/IPO/InlineSimple.cpp:1.76	Sun Nov 26 19:05:10 2006
+++ llvm/lib/Transforms/IPO/InlineSimple.cpp	Thu Jan 25 18:47:38 2007
@@ -58,7 +58,7 @@
   RegisterPass X("inline", "Function Integration/Inlining");
 }
 
-ModulePass *llvm::createFunctionInliningPass() { return new SimpleInliner(); }
+Pass *llvm::createFunctionInliningPass() { return new SimpleInliner(); }
 
 // CountCodeReductionForConstant - Figure out an approximation for how many
 // instructions will be constant folded if the specified value is constant.


Index: llvm/lib/Transforms/IPO/PruneEH.cpp
diff -u llvm/lib/Transforms/IPO/PruneEH.cpp:1.26 llvm/lib/Transforms/IPO/PruneEH.cpp:1.27
--- llvm/lib/Transforms/IPO/PruneEH.cpp:1.26	Tue Dec 19 16:09:18 2006
+++ llvm/lib/Transforms/IPO/PruneEH.cpp	Thu Jan 25 18:47:38 2007
@@ -50,7 +50,7 @@
   RegisterPass X("prune-eh", "Remove unused exception handling info");
 }
 
-ModulePass *llvm::createPruneEHPass() { return new PruneEH(); }
+Pass *llvm::createPruneEHPass() { return new PruneEH(); }
 
 
 bool PruneEH::runOnSCC(const std::vector &SCC) {





From dpatel at apple.com  Thu Jan 25 18:47:59 2007
From: dpatel at apple.com (Devang Patel)
Date: Thu, 25 Jan 2007 18:47:59 -0600
Subject: [llvm-commits] CVS: llvm/include/llvm/Transforms/IPO.h
Message-ID: <200701260047.l0Q0lxPJ013701@zion.cs.uiuc.edu>



Changes in directory llvm/include/llvm/Transforms:

IPO.h updated: 1.46 -> 1.47
---
Log message:

Inherit CallGraphSCCPass directly from Pass.


---
Diffs of the changes:  (+4 -3)

 IPO.h |    7 ++++---
 1 files changed, 4 insertions(+), 3 deletions(-)


Index: llvm/include/llvm/Transforms/IPO.h
diff -u llvm/include/llvm/Transforms/IPO.h:1.46 llvm/include/llvm/Transforms/IPO.h:1.47
--- llvm/include/llvm/Transforms/IPO.h:1.46	Thu Jul 20 12:48:05 2006
+++ llvm/include/llvm/Transforms/IPO.h	Thu Jan 25 18:47:38 2007
@@ -21,6 +21,7 @@
 
 class FunctionPass;
 class ModulePass;
+class Pass;
 class Function;
 class BasicBlock;
 
@@ -101,13 +102,13 @@
 /// createFunctionInliningPass - Return a new pass object that uses a heuristic
 /// to inline direct function calls to small functions.
 ///
-ModulePass *createFunctionInliningPass();
+Pass *createFunctionInliningPass();
 
 //===----------------------------------------------------------------------===//
 /// createPruneEHPass - Return a new pass object which transforms invoke
 /// instructions into calls, if the callee can _not_ unwind the stack.
 ///
-ModulePass *createPruneEHPass();
+Pass *createPruneEHPass();
 
 //===----------------------------------------------------------------------===//
 /// createInternalizePass - This pass loops over all of the functions in the
@@ -134,7 +135,7 @@
 /// createArgumentPromotionPass - This pass promotes "by reference" arguments to
 /// be passed by value.
 ///
-ModulePass *createArgumentPromotionPass();
+Pass *createArgumentPromotionPass();
 
 //===----------------------------------------------------------------------===//
 /// createIPConstantPropagationPass - This pass propagates constants from call





From dpatel at apple.com  Thu Jan 25 18:48:00 2007
From: dpatel at apple.com (Devang Patel)
Date: Thu, 25 Jan 2007 18:48:00 -0600
Subject: [llvm-commits] CVS: llvm/include/llvm/CallGraphSCCPass.h
Message-ID: <200701260048.l0Q0m0iD013706@zion.cs.uiuc.edu>



Changes in directory llvm/include/llvm:

CallGraphSCCPass.h updated: 1.8 -> 1.9
---
Log message:

Inherit CallGraphSCCPass directly from Pass.


---
Diffs of the changes:  (+1 -1)

 CallGraphSCCPass.h |    2 +-
 1 files changed, 1 insertion(+), 1 deletion(-)


Index: llvm/include/llvm/CallGraphSCCPass.h
diff -u llvm/include/llvm/CallGraphSCCPass.h:1.8 llvm/include/llvm/CallGraphSCCPass.h:1.9
--- llvm/include/llvm/CallGraphSCCPass.h:1.8	Tue Jan 23 15:52:35 2007
+++ llvm/include/llvm/CallGraphSCCPass.h	Thu Jan 25 18:47:38 2007
@@ -29,7 +29,7 @@
 class CallGraph;
 class PMStack;
 
-struct CallGraphSCCPass : public ModulePass {
+struct CallGraphSCCPass : public Pass {
 
   /// doInitialization - This method is called before the SCC's of the program
   /// has been processed, allowing the pass to do initialization as necessary.





From evan.cheng at apple.com  Thu Jan 25 19:05:00 2007
From: evan.cheng at apple.com (Evan Cheng)
Date: Thu, 25 Jan 2007 19:05:00 -0600
Subject: [llvm-commits] CVS: llvm/lib/Target/ARM/ARMConstantIslandPass.cpp
Message-ID: <200701260105.l0Q150eo014516@zion.cs.uiuc.edu>



Changes in directory llvm/lib/Target/ARM:

ARMConstantIslandPass.cpp updated: 1.6 -> 1.7
---
Log message:

Need to scan the function for branches even if there aren't any constants.

---
Diffs of the changes:  (+2 -3)

 ARMConstantIslandPass.cpp |    5 ++---
 1 files changed, 2 insertions(+), 3 deletions(-)


Index: llvm/lib/Target/ARM/ARMConstantIslandPass.cpp
diff -u llvm/lib/Target/ARM/ARMConstantIslandPass.cpp:1.6 llvm/lib/Target/ARM/ARMConstantIslandPass.cpp:1.7
--- llvm/lib/Target/ARM/ARMConstantIslandPass.cpp:1.6	Thu Jan 25 17:31:04 2007
+++ llvm/lib/Target/ARM/ARMConstantIslandPass.cpp	Thu Jan 25 19:04:44 2007
@@ -122,9 +122,7 @@
 }
 
 bool ARMConstantIslands::runOnMachineFunction(MachineFunction &Fn) {
-  // If there are no constants, there is nothing to do.
   MachineConstantPool &MCP = *Fn.getConstantPool();
-  if (MCP.isEmpty()) return false;
   
   TII = Fn.getTarget().getInstrInfo();
   TAI = Fn.getTarget().getTargetAsmInfo();
@@ -136,7 +134,8 @@
   // Perform the initial placement of the constant pool entries.  To start with,
   // we put them all at the end of the function.
   std::vector CPEMIs;
-  DoInitialPlacement(Fn, CPEMIs);
+  if (!MCP.isEmpty())
+    DoInitialPlacement(Fn, CPEMIs);
   
   /// The next UID to take is the first unused one.
   NextUID = CPEMIs.size();





From dpatel at apple.com  Thu Jan 25 19:08:37 2007
From: dpatel at apple.com (Devang Patel)
Date: Thu, 25 Jan 2007 19:08:37 -0600
Subject: [llvm-commits] CVS: llvm/include/llvm/CallGraphSCCPass.h
Message-ID: <200701260108.l0Q18bXU014585@zion.cs.uiuc.edu>



Changes in directory llvm/include/llvm:

CallGraphSCCPass.h updated: 1.9 -> 1.10
---
Log message:

Remove dead code. 
CallGraphSCCPass does not need to implement runOnModule().
It supports runOnSCC().


---
Diffs of the changes:  (+0 -5)

 CallGraphSCCPass.h |    5 -----
 1 files changed, 5 deletions(-)


Index: llvm/include/llvm/CallGraphSCCPass.h
diff -u llvm/include/llvm/CallGraphSCCPass.h:1.9 llvm/include/llvm/CallGraphSCCPass.h:1.10
--- llvm/include/llvm/CallGraphSCCPass.h:1.9	Thu Jan 25 18:47:38 2007
+++ llvm/include/llvm/CallGraphSCCPass.h	Thu Jan 25 19:08:18 2007
@@ -50,11 +50,6 @@
     return false;
   }
 
-  /// run - Run this pass, returning true if a modification was made to the
-  /// module argument.  This is implemented in terms of the runOnSCC method.
-  ///
-  virtual bool runOnModule(Module &M);
-
   /// Assign pass manager to manager this pass
   virtual void assignPassManager(PMStack &PMS,
 				 PassManagerType PMT = PMT_CallGraphPassManager);





From dpatel at apple.com  Thu Jan 25 19:08:37 2007
From: dpatel at apple.com (Devang Patel)
Date: Thu, 25 Jan 2007 19:08:37 -0600
Subject: [llvm-commits] CVS: llvm/lib/Analysis/IPA/CallGraphSCCPass.cpp
Message-ID: <200701260108.l0Q18bdf014591@zion.cs.uiuc.edu>



Changes in directory llvm/lib/Analysis/IPA:

CallGraphSCCPass.cpp updated: 1.13 -> 1.14
---
Log message:

Remove dead code. 
CallGraphSCCPass does not need to implement runOnModule().
It supports runOnSCC().


---
Diffs of the changes:  (+0 -9)

 CallGraphSCCPass.cpp |    9 ---------
 1 files changed, 9 deletions(-)


Index: llvm/lib/Analysis/IPA/CallGraphSCCPass.cpp
diff -u llvm/lib/Analysis/IPA/CallGraphSCCPass.cpp:1.13 llvm/lib/Analysis/IPA/CallGraphSCCPass.cpp:1.14
--- llvm/lib/Analysis/IPA/CallGraphSCCPass.cpp:1.13	Tue Jan 23 15:55:17 2007
+++ llvm/lib/Analysis/IPA/CallGraphSCCPass.cpp	Thu Jan 25 19:08:18 2007
@@ -189,12 +189,3 @@
   AU.addRequired();
   AU.addPreserved();
 }
-
-bool CallGraphSCCPass::runOnModule(Module &M) {
-  CallGraph &CG = getAnalysis();
-  bool Changed = doInitialization(CG);
-  for (scc_iterator I = scc_begin(&CG), E = scc_end(&CG);
-       I != E; ++I)
-    Changed = runOnSCC(*I);
-  return Changed | doFinalization(CG);
-}





From evan.cheng at apple.com  Thu Jan 25 20:02:54 2007
From: evan.cheng at apple.com (Evan Cheng)
Date: Thu, 25 Jan 2007 20:02:54 -0600
Subject: [llvm-commits] CVS: llvm/lib/Target/ARM/ARMConstantIslandPass.cpp
Message-ID: <200701260202.l0Q22ssN015869@zion.cs.uiuc.edu>



Changes in directory llvm/lib/Target/ARM:

ARMConstantIslandPass.cpp updated: 1.7 -> 1.8
---
Log message:

SplitBlockBeforeInstr() insert a unconditional branch to the next BB. This
is unnecessary when we are fixing up a conditional branch since we will be
adding a unconditional branch to the destination of the original branch.


---
Diffs of the changes:  (+6 -2)

 ARMConstantIslandPass.cpp |    8 ++++++--
 1 files changed, 6 insertions(+), 2 deletions(-)


Index: llvm/lib/Target/ARM/ARMConstantIslandPass.cpp
diff -u llvm/lib/Target/ARM/ARMConstantIslandPass.cpp:1.7 llvm/lib/Target/ARM/ARMConstantIslandPass.cpp:1.8
--- llvm/lib/Target/ARM/ARMConstantIslandPass.cpp:1.7	Thu Jan 25 19:04:44 2007
+++ llvm/lib/Target/ARM/ARMConstantIslandPass.cpp	Thu Jan 25 20:02:39 2007
@@ -602,13 +602,17 @@
   // direct the updated conditional branch to the fall-through block. Otherwise,
   // split the MBB before the next instruction.
   MachineBasicBlock *MBB = MI->getParent();
-  if (&MBB->back() != MI || !BBHasFallthrough(MBB))
+  if (&MBB->back() != MI || !BBHasFallthrough(MBB)) {
     SplitBlockBeforeInstr(MI);
+    // No need for the branch to the next block. We're adding a unconditional
+    // branch to the destination.
+    MBB->back().eraseFromParent();
+  }
   MachineBasicBlock *NextBB = next(MachineFunction::iterator(MBB));
 
   // Insert a unconditional branch and replace the conditional branch.
   // Also update the ImmBranch as well as adding a new entry for the new branch.
-  BuildMI(MBB, TII->get(MI->getOpcode())).addMBB(NextBB).addImm((unsigned)CC);
+  BuildMI(MBB, TII->get(MI->getOpcode())).addMBB(NextBB).addImm(CC);
   Br.MI = &MBB->back();
   BuildMI(MBB, TII->get(Br.UncondBr)).addMBB(DestBB);
   unsigned MaxDisp = (Br.UncondBr == ARM::tB) ? (1<<10)*2 : (1<<23)*4;





From han at autoesl.com  Thu Jan 25 21:10:33 2007
From: han at autoesl.com (Guoling Han)
Date: Thu, 25 Jan 2007 21:10:33 -0600
Subject: [llvm-commits] CVS: llvm-test/SingleSource/UnitTests/Integer/trunc.c
	trunc.reference_output general-test.c matrix.c matrix.h
	matrix.reference_output
Message-ID: <200701260310.l0Q3AXLT016896@zion.cs.uiuc.edu>



Changes in directory llvm-test/SingleSource/UnitTests/Integer:

trunc.c added (r1.1)
trunc.reference_output added (r1.1)
general-test.c updated: 1.5 -> 1.6
matrix.c updated: 1.7 -> 1.8
matrix.h updated: 1.1 -> 1.2
matrix.reference_output updated: 1.2 -> 1.3
---
Log message:

Add trunc.c for cbe test.
Modify matrix.c to avoid overflow problem.


---
Diffs of the changes:  (+71 -17)

 general-test.c          |    2 -
 matrix.c                |   14 ++++++-------
 matrix.h                |    2 -
 matrix.reference_output |   16 +++++++--------
 trunc.c                 |   50 ++++++++++++++++++++++++++++++++++++++++++++++++
 trunc.reference_output  |    4 +++
 6 files changed, 71 insertions(+), 17 deletions(-)


Index: llvm-test/SingleSource/UnitTests/Integer/trunc.c
diff -c /dev/null llvm-test/SingleSource/UnitTests/Integer/trunc.c:1.1
*** /dev/null	Thu Jan 25 21:10:27 2007
--- llvm-test/SingleSource/UnitTests/Integer/trunc.c	Thu Jan 25 21:10:17 2007
***************
*** 0 ****
--- 1,50 ----
+ //===--- trunc.c --- Test Cases for Bit Accurate Types --------------------===//
+ //
+ // This file was developed by Guoling Han and is distributed under the 
+ // University of Illinois Open Source License. See LICENSE.TXT for details.
+ //
+ //===----------------------------------------------------------------------===//
+ //
+ // This is used to test trunc and sext instructions.
+ //
+ //===----------------------------------------------------------------------===//
+ 
+ #include 
+ 
+ typedef int __attribute__ ((bitwidth(24))) int24;
+ 
+ int
+ test(int24 v)
+ {
+   int y;
+ 
+   y = v * (-1);
+   printf("test() y = %d\n", y);
+ 
+   return 0;
+ }
+ 
+ int
+ main ( int argc, char** argv)
+ {
+   int num;
+   int24 x;
+   
+   if (argc > 1)
+     num = atoi(argv[1]);
+ 
+   test(num);
+   
+   num = num - 0xdf5e75; //0x10001
+ 
+   x = num;
+ 
+   printf("x=%x\n", x);
+ 
+   if(x != 1)
+     printf("error\n");
+ 
+   test(x);
+   
+   return 0;
+ }


Index: llvm-test/SingleSource/UnitTests/Integer/trunc.reference_output
diff -c /dev/null llvm-test/SingleSource/UnitTests/Integer/trunc.reference_output:1.1
*** /dev/null	Thu Jan 25 21:10:33 2007
--- llvm-test/SingleSource/UnitTests/Integer/trunc.reference_output	Thu Jan 25 21:10:17 2007
***************
*** 0 ****
--- 1,4 ----
+ test() y = 2138506
+ x=1
+ test() y = -1
+ exit 0


Index: llvm-test/SingleSource/UnitTests/Integer/general-test.c
diff -u llvm-test/SingleSource/UnitTests/Integer/general-test.c:1.5 llvm-test/SingleSource/UnitTests/Integer/general-test.c:1.6
--- llvm-test/SingleSource/UnitTests/Integer/general-test.c:1.5	Mon Jan 22 15:07:53 2007
+++ llvm-test/SingleSource/UnitTests/Integer/general-test.c	Thu Jan 25 21:10:17 2007
@@ -41,7 +41,7 @@
   *result = sizeof(My17BitInt) + sizeof(j) + sizeof(struct MyStruct);
   Data1.i4Field = num;
   Data1.i12Field = num + 1;
-  Data1.i17Field = num + 2;
+  Data1.i17Field = num + 2; 
   Data1.i37Field = num + 3;
   Data1.next = 0;
   Data2 = Data1;


Index: llvm-test/SingleSource/UnitTests/Integer/matrix.c
diff -u llvm-test/SingleSource/UnitTests/Integer/matrix.c:1.7 llvm-test/SingleSource/UnitTests/Integer/matrix.c:1.8
--- llvm-test/SingleSource/UnitTests/Integer/matrix.c:1.7	Mon Jan 22 18:17:21 2007
+++ llvm-test/SingleSource/UnitTests/Integer/matrix.c	Thu Jan 25 21:10:17 2007
@@ -19,10 +19,10 @@
 
 typedef enum bool{false=0, true=1} bool;
 
-void mysort(const int17  X[8], int17  Y[8])
+void mysort(const int24  X[8], int24  Y[8])
 {
   unsigned int i, j;
-  int17 temp;
+  int24 temp;
   {
     j = 0;
     for ( ; ; ) {
@@ -69,11 +69,11 @@
 
 
 
-int my_test(int17  A[8][8], int17  B[8][8])
+int my_test(int24  A[8][8], int24  B[8][8])
 {
   unsigned int i, j, k, dd;
-  int17 C[8][8];
-  int17 D[8];
+  int24 C[8][8];
+  int24 D[8];
   int t;
   {
     i = 0;
@@ -118,8 +118,8 @@
 {
   int i, j;
             
-  int17 X[8][8];
-  int17 Y[8][8];
+  int24 X[8][8];
+  int24 Y[8][8];
 
   for(i=0; i<8; i++)
     for(j=0; j<8; j++){


Index: llvm-test/SingleSource/UnitTests/Integer/matrix.h
diff -u llvm-test/SingleSource/UnitTests/Integer/matrix.h:1.1 llvm-test/SingleSource/UnitTests/Integer/matrix.h:1.2
--- llvm-test/SingleSource/UnitTests/Integer/matrix.h:1.1	Thu Jan 18 20:22:46 2007
+++ llvm-test/SingleSource/UnitTests/Integer/matrix.h	Thu Jan 25 21:10:17 2007
@@ -2,5 +2,5 @@
 // Date: Fri Jan 12 17:32:33 CST 2007
 #ifndef DATATYPE_DEFINE
 #define DATATYPE_DEFINE
-typedef int __attribute__ ((bitwidth(17))) int17;
+typedef int __attribute__ ((bitwidth(24))) int24;
 #endif


Index: llvm-test/SingleSource/UnitTests/Integer/matrix.reference_output
diff -u llvm-test/SingleSource/UnitTests/Integer/matrix.reference_output:1.2 llvm-test/SingleSource/UnitTests/Integer/matrix.reference_output:1.3
--- llvm-test/SingleSource/UnitTests/Integer/matrix.reference_output:1.2	Mon Jan 22 14:47:27 2007
+++ llvm-test/SingleSource/UnitTests/Integer/matrix.reference_output	Thu Jan 25 21:10:17 2007
@@ -1,9 +1,9 @@
-get_gcd(50088, 48396) = 12
-get_gcd(-30896, -34280) = -8
-get_gcd(19192, 14116) = 4
-get_gcd(62512, 55744) = 16
-get_gcd(60148, -11704) = -44
-get_gcd(38384, 28232) = 8
-get_gcd(64784, 52940) = 4
-get_gcd(57344, 43808) = 32
+get_gcd(443304, 441612) = 1692
+get_gcd(886608, 883224) = 3384
+get_gcd(1329912, 1324836) = 5076
+get_gcd(1773216, 1766448) = 6768
+get_gcd(2216520, 2208060) = 8460
+get_gcd(2659824, 2649672) = 10152
+get_gcd(3103128, 3091284) = 11844
+get_gcd(3546432, 3532896) = 13536
 exit 0





From reid at x10sys.com  Fri Jan 26 00:30:50 2007
From: reid at x10sys.com (Reid Spencer)
Date: Fri, 26 Jan 2007 00:30:50 -0600
Subject: [llvm-commits] CVS: llvm/lib/VMCore/Instructions.cpp
Message-ID: <200701260630.l0Q6Uomk020478@zion.cs.uiuc.edu>



Changes in directory llvm/lib/VMCore:

Instructions.cpp updated: 1.65 -> 1.66
---
Log message:

Fix an assertion message.


---
Diffs of the changes:  (+1 -1)

 Instructions.cpp |    2 +-
 1 files changed, 1 insertion(+), 1 deletion(-)


Index: llvm/lib/VMCore/Instructions.cpp
diff -u llvm/lib/VMCore/Instructions.cpp:1.65 llvm/lib/VMCore/Instructions.cpp:1.66
--- llvm/lib/VMCore/Instructions.cpp:1.65	Sat Jan 20 18:29:26 2007
+++ llvm/lib/VMCore/Instructions.cpp	Fri Jan 26 00:30:34 2007
@@ -518,7 +518,7 @@
     assert(!isa(Amt) &&
            "Passed basic block into allocation size parameter!  Ue other ctor");
     assert(Amt->getType() == Type::Int32Ty &&
-           "Malloc/Allocation array size != UIntTy!");
+           "Malloc/Allocation array size is not a 32-bit integer!");
   }
   return Amt;
 }





From reid at x10sys.com  Fri Jan 26 01:37:50 2007
From: reid at x10sys.com (Reid Spencer)
Date: Fri, 26 Jan 2007 01:37:50 -0600
Subject: [llvm-commits] CVS: llvm/lib/VMCore/Constants.cpp
Message-ID: <200701260737.l0Q7boMw021588@zion.cs.uiuc.edu>



Changes in directory llvm/lib/VMCore:

Constants.cpp updated: 1.204 -> 1.205
---
Log message:

Clean up comments and assert messages that still refer to the old type names.


---
Diffs of the changes:  (+12 -12)

 Constants.cpp |   24 ++++++++++++------------
 1 files changed, 12 insertions(+), 12 deletions(-)


Index: llvm/lib/VMCore/Constants.cpp
diff -u llvm/lib/VMCore/Constants.cpp:1.204 llvm/lib/VMCore/Constants.cpp:1.205
--- llvm/lib/VMCore/Constants.cpp:1.204	Sat Jan 20 20:29:10 2007
+++ llvm/lib/VMCore/Constants.cpp	Fri Jan 26 01:37:34 2007
@@ -1004,10 +1004,10 @@
   return ConstantArray::get(ATy, ElementVals);
 }
 
-/// isString - This method returns true if the array is an array of sbyte or
-/// ubyte, and if the elements of the array are all ConstantInt's.
+/// isString - This method returns true if the array is an array of i8, and 
+/// if the elements of the array are all ConstantInt's.
 bool ConstantArray::isString() const {
-  // Check the element type for sbyte or ubyte...
+  // Check the element type for i8...
   if (getType()->getElementType() != Type::Int8Ty)
     return false;
   // Check the elements to make sure they are all integers, not constant
@@ -1022,7 +1022,7 @@
 /// isString) and it ends in a null byte \0 and does not contains any other
 /// null bytes except its terminator.
 bool ConstantArray::isCString() const {
-  // Check the element type for sbyte or ubyte...
+  // Check the element type for i8...
   if (getType()->getElementType() != Type::Int8Ty)
     return false;
   Constant *Zero = Constant::getNullValue(getOperand(0)->getType());
@@ -1040,7 +1040,7 @@
 }
 
 
-// getAsString - If the sub-element type of this array is either sbyte or ubyte,
+// getAsString - If the sub-element type of this array is i8
 // then this method converts the array to an std::string and returns it.
 // Otherwise, it asserts out.
 //
@@ -1536,7 +1536,7 @@
 
 Constant *ConstantExpr::getUIToFP(Constant *C, const Type *Ty) {
   assert(C->getType()->isInteger() && Ty->isFloatingPoint() &&
-         "This is an illegal uint to floating point cast!");
+         "This is an illegal i32 to floating point cast!");
   return getFoldedCast(Instruction::UIToFP, C, Ty);
 }
 
@@ -1548,13 +1548,13 @@
 
 Constant *ConstantExpr::getFPToUI(Constant *C, const Type *Ty) {
   assert(C->getType()->isFloatingPoint() && Ty->isInteger() &&
-         "This is an illegal floating point to uint cast!");
+         "This is an illegal floating point to i32 cast!");
   return getFoldedCast(Instruction::FPToUI, C, Ty);
 }
 
 Constant *ConstantExpr::getFPToSI(Constant *C, const Type *Ty) {
   assert(C->getType()->isFloatingPoint() && Ty->isInteger() &&
-         "This is an illegal floating point to sint cast!");
+         "This is an illegal floating point to i32 cast!");
   return getFoldedCast(Instruction::FPToSI, C, Ty);
 }
 
@@ -1688,7 +1688,7 @@
   case Instruction::Shl:
   case Instruction::LShr:
   case Instruction::AShr:
-    assert(C2->getType() == Type::Int8Ty && "Shift should be by ubyte!");
+    assert(C2->getType() == Type::Int8Ty && "Shift should be by i8!");
     assert(C1->getType()->isInteger() &&
            "Tried to create a shift operation on a non-integer type!");
     break;
@@ -1708,7 +1708,7 @@
 
 Constant *ConstantExpr::getSelectTy(const Type *ReqTy, Constant *C,
                                     Constant *V1, Constant *V2) {
-  assert(C->getType() == Type::Int1Ty && "Select condition must be bool!");
+  assert(C->getType() == Type::Int1Ty && "Select condition must be i1!");
   assert(V1->getType() == V2->getType() && "Select value types must match!");
   assert(V1->getType()->isFirstClassType() && "Cannot select aggregate type!");
 
@@ -1833,7 +1833,7 @@
   assert(isa(Val->getType()) &&
          "Tried to create extractelement operation on non-packed type!");
   assert(Idx->getType() == Type::Int32Ty &&
-         "Extractelement index must be uint type!");
+         "Extractelement index must be i32 type!");
   return getExtractElementTy(cast(Val->getType())->getElementType(),
                              Val, Idx);
 }
@@ -1857,7 +1857,7 @@
   assert(Elt->getType() == cast(Val->getType())->getElementType()
          && "Insertelement types must match!");
   assert(Idx->getType() == Type::Int32Ty &&
-         "Insertelement index must be uint type!");
+         "Insertelement index must be i32 type!");
   return getInsertElementTy(cast(Val->getType())->getElementType(),
                             Val, Elt, Idx);
 }





From reid at x10sys.com  Fri Jan 26 01:51:52 2007
From: reid at x10sys.com (Reid Spencer)
Date: Fri, 26 Jan 2007 01:51:52 -0600
Subject: [llvm-commits] CVS: llvm/lib/VMCore/Type.cpp
Message-ID: <200701260751.l0Q7pq1h022091@zion.cs.uiuc.edu>



Changes in directory llvm/lib/VMCore:

Type.cpp updated: 1.165 -> 1.166
---
Log message:

IntegerType is a sized DerivedType too.


---
Diffs of the changes:  (+3 -0)

 Type.cpp |    3 +++
 1 files changed, 3 insertions(+)


Index: llvm/lib/VMCore/Type.cpp
diff -u llvm/lib/VMCore/Type.cpp:1.165 llvm/lib/VMCore/Type.cpp:1.166
--- llvm/lib/VMCore/Type.cpp:1.165	Fri Jan 19 15:25:12 2007
+++ llvm/lib/VMCore/Type.cpp	Fri Jan 26 01:51:36 2007
@@ -139,6 +139,9 @@
 /// iff all of the members of the type are sized as well.  Since asking for
 /// their size is relatively uncommon, move this operation out of line.
 bool Type::isSizedDerivedType() const {
+  if (isa(this))
+    return true;
+
   if (const ArrayType *ATy = dyn_cast(this))
     return ATy->getElementType()->isSized();
 





From reid at x10sys.com  Fri Jan 26 02:01:48 2007
From: reid at x10sys.com (Reid Spencer)
Date: Fri, 26 Jan 2007 02:01:48 -0600
Subject: [llvm-commits] CVS: llvm/lib/VMCore/Function.cpp
Message-ID: <200701260801.l0Q81mg6022269@zion.cs.uiuc.edu>



Changes in directory llvm/lib/VMCore:

Function.cpp updated: 1.109 -> 1.110
---
Log message:

For PR645: http://llvm.org/PR645 :
Remove the Function::renameLocalSymbols function as it is no longer
needed.


---
Diffs of the changes:  (+0 -39)

 Function.cpp |   39 ---------------------------------------
 1 files changed, 39 deletions(-)


Index: llvm/lib/VMCore/Function.cpp
diff -u llvm/lib/VMCore/Function.cpp:1.109 llvm/lib/VMCore/Function.cpp:1.110
--- llvm/lib/VMCore/Function.cpp:1.109	Sat Jan  6 01:24:44 2007
+++ llvm/lib/VMCore/Function.cpp	Fri Jan 26 02:01:30 2007
@@ -139,45 +139,6 @@
 }
 
 
-/// renameLocalSymbols - This method goes through the Function's symbol table
-/// and renames any symbols that conflict with symbols at global scope.  This is
-/// required before printing out to a textual form, to ensure that there is no
-/// ambiguity when parsing.
-void Function::renameLocalSymbols() {
-  SymbolTable &LST = getValueSymbolTable();                 // Local Symtab
-  SymbolTable &GST = getParent()->getValueSymbolTable();    // Global Symtab
-
-  for (SymbolTable::plane_iterator LPI = LST.plane_begin(), E = LST.plane_end();
-       LPI != E; ++LPI)
-    // All global symbols are of pointer type, ignore any non-pointer planes.
-    if (isa(LPI->first)) {
-      // Only check if the global plane has any symbols of this type.
-      SymbolTable::plane_iterator GPI = GST.find(LPI->first);
-      if (GPI != GST.plane_end()) {
-        SymbolTable::ValueMap &LVM       = LPI->second;
-        const SymbolTable::ValueMap &GVM = GPI->second;
-
-        // Loop over all local symbols, renaming those that are in the global
-        // symbol table already.
-        for (SymbolTable::value_iterator VI = LVM.begin(), E = LVM.end();
-             VI != E;) {
-          Value *V                = VI->second;
-          const std::string &Name = VI->first;
-          ++VI;
-          if (GVM.count(Name)) {
-            static unsigned UniqueNum = 0;
-            // Find a name that does not conflict!
-            while (GVM.count(Name + "_" + utostr(++UniqueNum)) ||
-                   LVM.count(Name + "_" + utostr(UniqueNum)))
-              /* scan for UniqueNum that works */;
-            V->setName(Name + "_" + utostr(UniqueNum));
-          }
-        }
-      }
-    }
-}
-
-
 // dropAllReferences() - This function causes all the subinstructions to "let
 // go" of all references that they are maintaining.  This allows one to
 // 'delete' a whole class at a time, even though there may be circular





From reid at x10sys.com  Fri Jan 26 02:01:49 2007
From: reid at x10sys.com (Reid Spencer)
Date: Fri, 26 Jan 2007 02:01:49 -0600
Subject: [llvm-commits] CVS: llvm/include/llvm/Function.h
Message-ID: <200701260801.l0Q81nu1022276@zion.cs.uiuc.edu>



Changes in directory llvm/include/llvm:

Function.h updated: 1.69 -> 1.70
---
Log message:

For PR645: http://llvm.org/PR645 :
Remove the Function::renameLocalSymbols function as it is no longer
needed.


---
Diffs of the changes:  (+0 -7)

 Function.h |    7 -------
 1 files changed, 7 deletions(-)


Index: llvm/include/llvm/Function.h
diff -u llvm/include/llvm/Function.h:1.69 llvm/include/llvm/Function.h:1.70
--- llvm/include/llvm/Function.h:1.69	Sat Jan  6 01:24:43 2007
+++ llvm/include/llvm/Function.h	Fri Jan 26 02:01:30 2007
@@ -111,13 +111,6 @@
   unsigned getCallingConv() const { return CallingConvention; }
   void setCallingConv(unsigned CC) { CallingConvention = CC; }
 
-  /// renameLocalSymbols - This method goes through the Function's symbol table
-  /// and renames any symbols that conflict with symbols at global scope.  This
-  /// is required before printing out to a textual form, to ensure that there is
-  /// no ambiguity when parsing.
-  void renameLocalSymbols();
-
-
   /// deleteBody - This method deletes the body of the function, and converts
   /// the linkage to external.
   ///





From reid at x10sys.com  Fri Jan 26 02:01:49 2007
From: reid at x10sys.com (Reid Spencer)
Date: Fri, 26 Jan 2007 02:01:49 -0600
Subject: [llvm-commits] CVS: llvm/lib/Target/CBackend/CBackend.cpp
Message-ID: <200701260801.l0Q81nke022274@zion.cs.uiuc.edu>



Changes in directory llvm/lib/Target/CBackend:

CBackend.cpp updated: 1.319 -> 1.320
---
Log message:

For PR645: http://llvm.org/PR645 :
Remove the Function::renameLocalSymbols function as it is no longer
needed.


---
Diffs of the changes:  (+0 -3)

 CBackend.cpp |    3 ---
 1 files changed, 3 deletions(-)


Index: llvm/lib/Target/CBackend/CBackend.cpp
diff -u llvm/lib/Target/CBackend/CBackend.cpp:1.319 llvm/lib/Target/CBackend/CBackend.cpp:1.320
--- llvm/lib/Target/CBackend/CBackend.cpp:1.319	Tue Jan 16 12:02:45 2007
+++ llvm/lib/Target/CBackend/CBackend.cpp	Fri Jan 26 02:01:30 2007
@@ -99,9 +99,6 @@
       // Output all floating point constants that cannot be printed accurately.
       printFloatingPointConstants(F);
 
-      // Ensure that no local symbols conflict with global symbols.
-      F.renameLocalSymbols();
-
       printFunction(F);
       FPConstantMap.clear();
       return false;





From reid at x10sys.com  Fri Jan 26 02:03:07 2007
From: reid at x10sys.com (Reid Spencer)
Date: Fri, 26 Jan 2007 02:03:07 -0600
Subject: [llvm-commits] CVS: llvm/lib/VMCore/AsmWriter.cpp
Message-ID: <200701260803.l0Q837nf022310@zion.cs.uiuc.edu>



Changes in directory llvm/lib/VMCore:

AsmWriter.cpp updated: 1.254 -> 1.255
---
Log message:

For PR645: http://llvm.org/PR645 :
Implement new syntax for local and global symbols. Types and local 
symbols use the % prefix. Global variables and functions use the @ prefix.


---
Diffs of the changes:  (+53 -93)

 AsmWriter.cpp |  146 +++++++++++++++++++++-------------------------------------
 1 files changed, 53 insertions(+), 93 deletions(-)


Index: llvm/lib/VMCore/AsmWriter.cpp
diff -u llvm/lib/VMCore/AsmWriter.cpp:1.254 llvm/lib/VMCore/AsmWriter.cpp:1.255
--- llvm/lib/VMCore/AsmWriter.cpp:1.254	Mon Jan 15 12:28:18 2007
+++ llvm/lib/VMCore/AsmWriter.cpp	Fri Jan 26 02:02:52 2007
@@ -179,31 +179,47 @@
   return 0;
 }
 
-// getLLVMName - Turn the specified string into an 'LLVM name', which is either
-// prefixed with % (if the string only contains simple characters) or is
-// surrounded with ""'s (if it has special chars in it).
-static std::string getLLVMName(const std::string &Name,
-                               bool prefixName = true) {
-  assert(!Name.empty() && "Cannot get empty name!");
-
-  // First character cannot start with a number...
-  if (Name[0] >= '0' && Name[0] <= '9')
-    return "\"" + Name + "\"";
-
+/// NameNeedsQuotes - Return true if the specified llvm name should be wrapped
+/// with ""'s.
+static bool NameNeedsQuotes(const std::string &Name) {
+  if (Name[0] >= '0' && Name[0] <= '9') return true;
   // Scan to see if we have any characters that are not on the "white list"
   for (unsigned i = 0, e = Name.size(); i != e; ++i) {
     char C = Name[i];
     assert(C != '"' && "Illegal character in LLVM value name!");
     if ((C < 'a' || C > 'z') && (C < 'A' || C > 'Z') && (C < '0' || C > '9') &&
         C != '-' && C != '.' && C != '_')
-      return "\"" + Name + "\"";
+      return true;
+  }
+  return false;
+}
+
+enum PrefixType {
+  GlobalPrefix,
+  LabelPrefix,
+  LocalPrefix
+};
+
+/// getLLVMName - Turn the specified string into an 'LLVM name', which is either
+/// prefixed with % (if the string only contains simple characters) or is
+/// surrounded with ""'s (if it has special chars in it).
+static std::string getLLVMName(const std::string &Name, PrefixType Prefix) {
+  assert(!Name.empty() && "Cannot get empty name!");
+
+  // First character cannot start with a number...
+  if (NameNeedsQuotes(Name)) {
+    if (Prefix == GlobalPrefix)
+      return "@\"" + Name + "\"";
+    return "\"" + Name + "\"";
   }
 
   // If we get here, then the identifier is legal to use as a "VarID".
-  if (prefixName)
-    return "%"+Name;
-  else
-    return Name;
+  switch (Prefix) {
+  default: assert(0 && "Bad prefix!");
+  case GlobalPrefix: return '@' + Name;
+  case LabelPrefix:  return Name;
+  case LocalPrefix:  return '%' + Name;
+  }      
 }
 
 
@@ -224,7 +240,7 @@
         !cast(Ty)->getElementType()->isPrimitiveType() ||
         !cast(Ty)->getElementType()->isInteger() ||
         isa(cast(Ty)->getElementType()))
-      TypeNames.insert(std::make_pair(Ty, getLLVMName(TI->first)));
+      TypeNames.insert(std::make_pair(Ty, getLLVMName(TI->first, LocalPrefix)));
   }
 }
 
@@ -587,7 +603,8 @@
                                    SlotMachine *Machine) {
   Out << ' ';
   if (V->hasName())
-    Out << getLLVMName(V->getName());
+    Out << getLLVMName(V->getName(),
+                       isa(V) ? GlobalPrefix : LocalPrefix);
   else {
     const Constant *CV = dyn_cast(V);
     if (CV && !isa(CV)) {
@@ -602,26 +619,31 @@
       PrintEscapedString(IA->getConstraintString(), Out);
       Out << '"';
     } else {
+      char Prefix = '%';
       int Slot;
       if (Machine) {
-        if (const GlobalValue *GV = dyn_cast(V))
+        if (const GlobalValue *GV = dyn_cast(V)) {
           Slot = Machine->getGlobalSlot(GV);
-        else
+          Prefix = '@';
+        } else {
           Slot = Machine->getLocalSlot(V);
+        }
       } else {
         Machine = createSlotMachine(V);
         if (Machine) {
-          if (const GlobalValue *GV = dyn_cast(V))
+          if (const GlobalValue *GV = dyn_cast(V)) {
             Slot = Machine->getGlobalSlot(GV);
-          else
+            Prefix = '@';
+          } else {
             Slot = Machine->getLocalSlot(V);
+          }
         } else {
           Slot = -1;
         }
         delete Machine;
       }
       if (Slot != -1)
-        Out << '%' << Slot;
+        Out << Prefix << Slot;
       else
         Out << "";
     }
@@ -672,7 +694,6 @@
   inline void write(const Function *F)       { printFunction(F);    }
   inline void write(const BasicBlock *BB)    { printBasicBlock(BB); }
   inline void write(const Instruction *I)    { printInstruction(*I); }
-  inline void write(const Constant *CPV)     { printConstant(CPV);  }
   inline void write(const Type *Ty)          { printType(Ty);       }
 
   void writeOperand(const Value *Op, bool PrintType);
@@ -682,8 +703,6 @@
 private:
   void printModule(const Module *M);
   void printTypeSymbolTable(const TypeSymbolTable &ST);
-  void printValueSymbolTable(const SymbolTable &ST);
-  void printConstant(const Constant *CPV);
   void printGlobal(const GlobalVariable *GV);
   void printFunction(const Function *F);
   void printArgument(const Argument *FA, FunctionType::ParameterAttributes A);
@@ -787,17 +806,6 @@
 
   if (!M->getDataLayout().empty())
     Out << "target datalayout = \"" << M->getDataLayout() << "\"\n";
-
-  switch (M->getEndianness()) {
-  case Module::LittleEndian: Out << "target endian = little\n"; break;
-  case Module::BigEndian:    Out << "target endian = big\n";    break;
-  case Module::AnyEndianness: break;
-  }
-  switch (M->getPointerSize()) {
-  case Module::Pointer32:    Out << "target pointersize = 32\n"; break;
-  case Module::Pointer64:    Out << "target pointersize = 64\n"; break;
-  case Module::AnyPointerSize: break;
-  }
   if (!M->getTargetTriple().empty())
     Out << "target triple = \"" << M->getTargetTriple() << "\"\n";
 
@@ -837,7 +845,6 @@
 
   // Loop over the symbol table, emitting all named constants.
   printTypeSymbolTable(M->getTypeSymbolTable());
-  printValueSymbolTable(M->getValueSymbolTable());
 
   for (Module::const_global_iterator I = M->global_begin(), E = M->global_end();
        I != E; ++I)
@@ -851,7 +858,7 @@
 }
 
 void AssemblyWriter::printGlobal(const GlobalVariable *GV) {
-  if (GV->hasName()) Out << getLLVMName(GV->getName()) << " = ";
+  if (GV->hasName()) Out << getLLVMName(GV->getName(), GlobalPrefix) << " = ";
 
   if (!GV->hasInitializer())
     switch (GV->getLinkage()) {
@@ -901,7 +908,7 @@
   // Print the types.
   for (TypeSymbolTable::const_iterator TI = ST.begin(), TE = ST.end();
        TI != TE; ++TI) {
-    Out << "\t" << getLLVMName(TI->first) << " = type ";
+    Out << "\t" << getLLVMName(TI->first, LocalPrefix) << " = type ";
 
     // Make sure we print out at least one level of the type structure, so
     // that we do not get %FILE = type %FILE
@@ -910,52 +917,12 @@
   }
 }
 
-// printSymbolTable - Run through symbol table looking for constants
-// and types. Emit their declarations.
-void AssemblyWriter::printValueSymbolTable(const SymbolTable &ST) {
-
-  // Print the constants, in type plane order.
-  for (SymbolTable::plane_const_iterator PI = ST.plane_begin();
-       PI != ST.plane_end(); ++PI) {
-    SymbolTable::value_const_iterator VI = ST.value_begin(PI->first);
-    SymbolTable::value_const_iterator VE = ST.value_end(PI->first);
-
-    for (; VI != VE; ++VI) {
-      const Value* V = VI->second;
-      const Constant *CPV = dyn_cast(V) ;
-      if (CPV && !isa(V)) {
-        printConstant(CPV);
-      }
-    }
-  }
-}
-
-
-/// printConstant - Print out a constant pool entry...
-///
-void AssemblyWriter::printConstant(const Constant *CPV) {
-  // Don't print out unnamed constants, they will be inlined
-  if (!CPV->hasName()) return;
-
-  // Print out name...
-  Out << "\t" << getLLVMName(CPV->getName()) << " =";
-
-  // Write the value out now.
-  writeOperand(CPV, true);
-
-  printInfoComment(*CPV);
-  Out << "\n";
-}
-
 /// printFunction - Print all aspects of a function.
 ///
 void AssemblyWriter::printFunction(const Function *F) {
   // Print out the return type and name...
   Out << "\n";
 
-  // Ensure that no local symbols conflict with global symbols.
-  const_cast(F)->renameLocalSymbols();
-
   if (AnnotationWriter) AnnotationWriter->emitFunctionAnnot(F, Out);
 
   if (F->isExternal())
@@ -1000,9 +967,9 @@
   const FunctionType *FT = F->getFunctionType();
   printType(F->getReturnType()) << ' ';
   if (!F->getName().empty())
-    Out << getLLVMName(F->getName());
+    Out << getLLVMName(F->getName(), GlobalPrefix);
   else
-    Out << "\"\"";
+    Out << "@\"\"";
   Out << '(';
   Machine.incorporateFunction(F);
 
@@ -1058,14 +1025,14 @@
 
   // Output name, if available...
   if (Arg->hasName())
-    Out << ' ' << getLLVMName(Arg->getName());
+    Out << ' ' << getLLVMName(Arg->getName(), LocalPrefix);
 }
 
 /// printBasicBlock - This member is called for each basic block in a method.
 ///
 void AssemblyWriter::printBasicBlock(const BasicBlock *BB) {
   if (BB->hasName()) {              // Print out the label if it exists...
-    Out << "\n" << getLLVMName(BB->getName(), false) << ':';
+    Out << "\n" << getLLVMName(BB->getName(), LabelPrefix) << ':';
   } else if (!BB->use_empty()) {      // Don't print block # of no uses...
     Out << "\n; :";
     int Slot = Machine.getLocalSlot(BB);
@@ -1139,7 +1106,7 @@
 
   // Print out name if it exists...
   if (I.hasName())
-    Out << getLLVMName(I.getName()) << " = ";
+    Out << getLLVMName(I.getName(), LocalPrefix) << " = ";
 
   // If this is a volatile load or store, print out the volatile marker.
   if ((isa(I)  && cast(I).isVolatile()) ||
@@ -1533,18 +1500,11 @@
   
   // Lookup the Value in the function and module maps.
   ValueMap::const_iterator FVI = FI->second.map.find(V);
-  TypedPlanes::const_iterator MI = mMap.find(VTy);
   
   // If the value doesn't exist in the function map, it is a 
   if (FVI == FI->second.map.end()) return -1;
   
-  // Return the slot number as the module's contribution to
-  // the type plane plus the index in the function's contribution
-  // to the type plane.
-  if (MI != mMap.end())
-    return MI->second.next_slot + FVI->second;
-  else
-    return FVI->second;
+  return FVI->second;
 }
 
 





From reid at x10sys.com  Fri Jan 26 02:05:07 2007
From: reid at x10sys.com (Reid Spencer)
Date: Fri, 26 Jan 2007 02:05:07 -0600
Subject: [llvm-commits] CVS: llvm/lib/AsmParser/llvmAsmParser.y Lexer.l
	ParserInternals.h
Message-ID: <200701260805.l0Q857NY022367@zion.cs.uiuc.edu>



Changes in directory llvm/lib/AsmParser:

llvmAsmParser.y updated: 1.312 -> 1.313
Lexer.l updated: 1.95 -> 1.96
ParserInternals.h updated: 1.52 -> 1.53
---
Log message:

For PR645: http://llvm.org/PR645 :
Implement separation of local and global symbols. Local symbols and types
now use % prefix. Global variables and functions now use @ prefix.

For PR761: http://llvm.org/PR761 :
Replace:
  target endian = 
  target pointersize =
With:
  target datalayout =



---
Diffs of the changes:  (+173 -157)

 Lexer.l           |   59 +++++++------
 ParserInternals.h |   38 +++++---
 llvmAsmParser.y   |  233 ++++++++++++++++++++++++++----------------------------
 3 files changed, 173 insertions(+), 157 deletions(-)


Index: llvm/lib/AsmParser/llvmAsmParser.y
diff -u llvm/lib/AsmParser/llvmAsmParser.y:1.312 llvm/lib/AsmParser/llvmAsmParser.y:1.313
--- llvm/lib/AsmParser/llvmAsmParser.y:1.312	Sun Jan 21 13:19:31 2007
+++ llvm/lib/AsmParser/llvmAsmParser.y	Fri Jan 26 02:04:51 2007
@@ -270,12 +270,12 @@
 
 static const Type *getTypeVal(const ValID &D, bool DoNotImprovise = false) {
   switch (D.Type) {
-  case ValID::NumberVal:               // Is it a numbered definition?
+  case ValID::LocalID:               // Is it a numbered definition?
     // Module constants occupy the lowest numbered slots...
-    if ((unsigned)D.Num < CurModule.Types.size())
-      return CurModule.Types[(unsigned)D.Num];
+    if (D.Num < CurModule.Types.size())
+      return CurModule.Types[D.Num];
     break;
-  case ValID::NameVal:                 // Is it a named definition?
+  case ValID::LocalName:                 // Is it a named definition?
     if (const Type *N = CurModule.CurrentModule->getTypeByName(D.Name)) {
       D.destroy();  // Free old strdup'd memory...
       return N;
@@ -294,11 +294,11 @@
 
 
   if (inFunctionScope()) {
-    if (D.Type == ValID::NameVal) {
+    if (D.Type == ValID::LocalName) {
       GenerateError("Reference to an undefined type: '" + D.getName() + "'");
       return 0;
     } else {
-      GenerateError("Reference to an undefined type: #" + itostr(D.Num));
+      GenerateError("Reference to an undefined type: #" + utostr(D.Num));
       return 0;
     }
   }
@@ -312,13 +312,6 @@
   return Typ;
  }
 
-static Value *lookupInSymbolTable(const Type *Ty, const std::string &Name) {
-  SymbolTable &SymTab =
-    inFunctionScope() ? CurFun.CurrentFunction->getValueSymbolTable() :
-                        CurModule.CurrentModule->getValueSymbolTable();
-  return SymTab.lookup(Ty, Name);
-}
-
 // getValNonImprovising - Look up the value specified by the provided type and
 // the provided ValID.  If the value exists and has already been defined, return
 // it.  Otherwise return null.
@@ -331,29 +324,39 @@
   }
 
   switch (D.Type) {
-  case ValID::NumberVal: {                 // Is it a numbered definition?
-    unsigned Num = (unsigned)D.Num;
-
-    // Module constants occupy the lowest numbered slots...
-    std::map::iterator VI = CurModule.Values.find(Ty);
-    if (VI != CurModule.Values.end()) {
-      if (Num < VI->second.size())
-        return VI->second[Num];
-      Num -= VI->second.size();
-    }
-
-    // Make sure that our type is within bounds
-    VI = CurFun.Values.find(Ty);
+  case ValID::LocalID: {                 // Is it a numbered definition?
+    // Module constants occupy the lowest numbered slots.
+    std::map::iterator VI = CurFun.Values.find(Ty);
+    // Make sure that our type is within bounds.
     if (VI == CurFun.Values.end()) return 0;
 
-    // Check that the number is within bounds...
-    if (VI->second.size() <= Num) return 0;
+    // Check that the number is within bounds.
+    if (D.Num >= VI->second.size()) return 0;
 
+    return VI->second[D.Num];
+  }
+  case ValID::GlobalID: {                 // Is it a numbered definition?
+    unsigned Num = D.Num;
+    
+    // Module constants occupy the lowest numbered slots...
+    std::map::iterator VI = CurModule.Values.find(Ty);
+    if (VI == CurModule.Values.end()) return 0;
+    if (D.Num >= VI->second.size()) return 0;
     return VI->second[Num];
   }
-
-  case ValID::NameVal: {                // Is it a named definition?
-    Value *N = lookupInSymbolTable(Ty, std::string(D.Name));
+    
+  case ValID::LocalName: {                // Is it a named definition?
+    if (!inFunctionScope()) return 0;
+    SymbolTable &SymTab = CurFun.CurrentFunction->getValueSymbolTable();
+    Value *N = SymTab.lookup(Ty, D.Name);
+    if (N == 0) return 0;
+    
+    D.destroy();  // Free old strdup'd memory...
+    return N;
+  }
+  case ValID::GlobalName: {                // Is it a named definition?
+    SymbolTable &SymTab = CurModule.CurrentModule->getValueSymbolTable();
+    Value *N = SymTab.lookup(Ty, D.Name);
     if (N == 0) return 0;
 
     D.destroy();  // Free old strdup'd memory...
@@ -488,12 +491,12 @@
   default: 
     GenerateError("Illegal label reference " + ID.getName());
     return 0;
-  case ValID::NumberVal:                // Is it a numbered definition?
-    if (unsigned(ID.Num) >= CurFun.NumberedBlocks.size())
+  case ValID::LocalID:                // Is it a numbered definition?
+    if (ID.Num >= CurFun.NumberedBlocks.size())
       CurFun.NumberedBlocks.resize(ID.Num+1);
     BB = CurFun.NumberedBlocks[ID.Num];
     break;
-  case ValID::NameVal:                  // Is it a named definition?
+  case ValID::LocalName:                  // Is it a named definition?
     Name = ID.Name;
     if (Value *N = CurFun.CurrentFunction->
                    getValueSymbolTable().lookup(Type::LabelTy, Name))
@@ -518,7 +521,7 @@
 
   // Otherwise this block has not been seen before.
   BB = new BasicBlock("", CurFun.CurrentFunction);
-  if (ID.Type == ValID::NameVal) {
+  if (ID.Type == ValID::LocalName) {
     BB->setName(ID.Name);
   } else {
     CurFun.NumberedBlocks[ID.Num] = BB;
@@ -585,7 +588,7 @@
         // resolver table
         InsertValue(V, *FutureLateResolvers);
       } else {
-        if (DID.Type == ValID::NameVal) {
+        if (DID.Type == ValID::LocalName || DID.Type == ValID::GlobalName) {
           GenerateError("Reference to an invalid definition: '" +DID.getName()+
                          "' of type '" + V->getType()->getDescription() + "'",
                          PHI->second.second);
@@ -610,8 +613,8 @@
 //
 static void ResolveTypeTo(char *Name, const Type *ToTy) {
   ValID D;
-  if (Name) D = ValID::create(Name);
-  else      D = ValID::create((int)CurModule.Types.size());
+  if (Name) D = ValID::createLocalName(Name);
+  else      D = ValID::createLocalID(CurModule.Types.size());
 
   std::map::iterator I =
     CurModule.LateResolveTypes.find(D);
@@ -626,26 +629,25 @@
 // assumed to be a malloc'd string buffer, and is free'd by this function.
 //
 static void setValueName(Value *V, char *NameStr) {
-  if (NameStr) {
-    std::string Name(NameStr);      // Copy string
-    free(NameStr);                  // Free old string
-
-    if (V->getType() == Type::VoidTy) {
-      GenerateError("Can't assign name '" + Name+"' to value with void type!");
-      return;
-    }
+  if (!NameStr) return;
+  std::string Name(NameStr);      // Copy string
+  free(NameStr);                  // Free old string
 
-    assert(inFunctionScope() && "Must be in function scope!");
-    SymbolTable &ST = CurFun.CurrentFunction->getValueSymbolTable();
-    if (ST.lookup(V->getType(), Name)) {
-      GenerateError("Redefinition of value '" + Name + "' of type '" +
-                     V->getType()->getDescription() + "'!");
-      return;
-    }
+  if (V->getType() == Type::VoidTy) {
+    GenerateError("Can't assign name '" + Name+"' to value with void type!");
+    return;
+  }
 
-    // Set the name.
-    V->setName(Name);
+  assert(inFunctionScope() && "Must be in function scope!");
+  SymbolTable &ST = CurFun.CurrentFunction->getValueSymbolTable();
+  if (ST.lookup(V->getType(), Name)) {
+    GenerateError("Redefinition of value '" + Name + "' of type '" +
+                   V->getType()->getDescription() + "'!");
+    return;
   }
+
+  // Set the name.
+  V->setName(Name);
 }
 
 /// ParseGlobalVariable - Handle parsing of a global.  If Initializer is null,
@@ -673,9 +675,9 @@
   // object.
   ValID ID;
   if (!Name.empty()) {
-    ID = ValID::create((char*)Name.c_str());
+    ID = ValID::createGlobalName((char*)Name.c_str());
   } else {
-    ID = ValID::create((int)CurModule.Values[PTy].size());
+    ID = ValID::createGlobalID(CurModule.Values[PTy].size());
   }
 
   if (GlobalValue *FWGV = CurModule.GetForwardRefForGlobal(PTy, ID)) {
@@ -922,7 +924,6 @@
   llvm::Instruction::MemoryOps      MemOpVal;
   llvm::Instruction::CastOps        CastOpVal;
   llvm::Instruction::OtherOps       OtherOpVal;
-  llvm::Module::Endianness          Endianness;
   llvm::ICmpInst::Predicate         IPredicate;
   llvm::FCmpInst::Predicate         FPredicate;
 }
@@ -949,7 +950,6 @@
 %type        GVInternalLinkage GVExternalLinkage
 %type        FunctionDefineLinkage FunctionDeclareLinkage
 %type     GVVisibilityStyle
-%type     BigOrLittle
 
 // ValueRef - Unresolved reference to a definition or BB
 %type       ValueRef ConstValueRef SymbolicValueRef
@@ -962,9 +962,7 @@
 // EUINT64VAL - A positive number within uns. long long range
 %token  EUINT64VAL
 
-%token     SINTVAL   // Signed 32 bit ints...
-%token     UINTVAL   // Unsigned 32 bit ints...
-%type      INTVAL
+%token     LOCALVAL_ID GLOBALVAL_ID  // %123 @123
 %token       FPVAL     // Float or Double constant
 
 // Built in types...
@@ -974,16 +972,17 @@
 %token  FLOAT DOUBLE LABEL
 %token TYPE
 
-%token  VAR_ID LABELSTR STRINGCONSTANT
-%type   Name OptName OptAssign
-%type   OptAlign OptCAlign
+%token LOCALVAR GLOBALVAR LABELSTR STRINGCONSTANT ATSTRINGCONSTANT
+%type  LocalName OptLocalName OptLocalAssign
+%type  GlobalName OptGlobalAssign
+%type  OptAlign OptCAlign
 %type  OptSection SectionString
 
 %token IMPLEMENTATION ZEROINITIALIZER TRUETOK FALSETOK BEGINTOK ENDTOK
 %token DECLARE DEFINE GLOBAL CONSTANT SECTION VOLATILE
 %token TO DOTDOTDOT NULL_TOK UNDEF INTERNAL LINKONCE WEAK APPENDING
 %token DLLIMPORT DLLEXPORT EXTERN_WEAK
-%token OPAQUE EXTERNAL TARGET TRIPLE ENDIAN POINTERSIZE LITTLE BIG ALIGN
+%token OPAQUE EXTERNAL TARGET TRIPLE ALIGN
 %token DEPLIBS CALL TAIL ASM_TOK MODULE SIDEEFFECT
 %token CC_TOK CCC_TOK CSRETCC_TOK FASTCC_TOK COLDCC_TOK
 %token X86_STDCALLCC_TOK X86_FASTCALLCC_TOK
@@ -1026,15 +1025,6 @@
 %start Module
 %%
 
-// Handle constant integer size restriction and conversion...
-//
-INTVAL : SINTVAL;
-INTVAL : UINTVAL {
-  if ($1 > (uint32_t)INT32_MAX)     // Outside of my range!
-    GEN_ERROR("Value too large for type!");
-  $$ = (int32_t)$1;
-  CHECK_FOR_ERROR
-};
 
 // Operations that are notably excluded from this list include:
 // RET, BR, & SWITCH because they end basic blocks and are treated specially.
@@ -1069,8 +1059,23 @@
 IntType :  INTTYPE;
 FPType   : FLOAT | DOUBLE;
 
-// OptAssign - Value producing statements have an optional assignment component
-OptAssign : Name '=' {
+LocalName : LOCALVAR | STRINGCONSTANT;
+OptLocalName : LocalName | /*empty*/ { $$ = 0; };
+
+/// OptLocalAssign - Value producing statements have an optional assignment
+/// component.
+OptLocalAssign : LocalName '=' {
+    $$ = $1;
+    CHECK_FOR_ERROR
+  }
+  | /*empty*/ {
+    $$ = 0;
+    CHECK_FOR_ERROR
+  };
+
+GlobalName : GLOBALVAR | ATSTRINGCONSTANT;
+
+OptGlobalAssign : GlobalName '=' {
     $$ = $1;
     CHECK_FOR_ERROR
   }
@@ -1630,7 +1635,10 @@
         $2.destroy();
       } else {
         std::string Name;
-        if ($2.Type == ValID::NameVal) Name = $2.Name;
+        if ($2.Type == ValID::GlobalName)
+          Name = $2.Name;
+        else if ($2.Type != ValID::GlobalID)
+          GEN_ERROR("Invalid reference to global");
 
         // Create the forward referenced global.
         GlobalValue *GV;
@@ -1857,7 +1865,7 @@
     // Emit an error if there are any unresolved types left.
     if (!CurModule.LateResolveTypes.empty()) {
       const ValID &DID = CurModule.LateResolveTypes.begin()->first;
-      if (DID.Type == ValID::NameVal) {
+      if (DID.Type == ValID::LocalName) {
         GEN_ERROR("Reference to an undefined type: '"+DID.getName() + "'");
       } else {
         GEN_ERROR("Reference to an undefined type: #" + itostr(DID.Num));
@@ -1865,7 +1873,7 @@
     }
     CHECK_FOR_ERROR
   }
-  | OptAssign TYPE Types {
+  | OptLocalAssign TYPE Types {
     if (!UpRefs.empty())
       GEN_ERROR("Invalid upreference in type: " + (*$3)->getDescription());
     // Eagerly resolve types.  This is not an optimization, this is a
@@ -1889,7 +1897,7 @@
     delete $3;
     CHECK_FOR_ERROR
   }
-  | OptAssign TYPE VOID {
+  | OptLocalAssign TYPE VOID {
     ResolveTypeTo($1, $3);
 
     if (!setTypeName($3, $1) && !$1) {
@@ -1900,7 +1908,8 @@
     }
     CHECK_FOR_ERROR
   }
-  | OptAssign GVVisibilityStyle GlobalType ConstVal { /* "Externally Visible" Linkage */
+  | OptGlobalAssign GVVisibilityStyle GlobalType ConstVal { 
+    /* "Externally Visible" Linkage */
     if ($4 == 0) 
       GEN_ERROR("Global value initializer is not a constant!");
     CurGV = ParseGlobalVariable($1, GlobalValue::ExternalLinkage,
@@ -1909,7 +1918,7 @@
   } GlobalVarAttributes {
     CurGV = 0;
   }
-  | OptAssign GVInternalLinkage GVVisibilityStyle GlobalType ConstVal {
+  | OptGlobalAssign GVInternalLinkage GVVisibilityStyle GlobalType ConstVal {
     if ($5 == 0) 
       GEN_ERROR("Global value initializer is not a constant!");
     CurGV = ParseGlobalVariable($1, $2, $3, $4, $5->getType(), $5);
@@ -1917,7 +1926,7 @@
   } GlobalVarAttributes {
     CurGV = 0;
   }
-  | OptAssign GVExternalLinkage GVVisibilityStyle GlobalType Types {
+  | OptGlobalAssign GVExternalLinkage GVVisibilityStyle GlobalType Types {
     if (!UpRefs.empty())
       GEN_ERROR("Invalid upreference in type: " + (*$5)->getDescription());
     CurGV = ParseGlobalVariable($1, $2, $3, $4, *$5, 0);
@@ -1949,23 +1958,7 @@
   CHECK_FOR_ERROR
 };
 
-BigOrLittle : BIG    { $$ = Module::BigEndian; };
-BigOrLittle : LITTLE { $$ = Module::LittleEndian; };
-
-TargetDefinition : ENDIAN '=' BigOrLittle {
-    CurModule.CurrentModule->setEndianness($3);
-    CHECK_FOR_ERROR
-  }
-  | POINTERSIZE '=' EUINT64VAL {
-    if ($3 == 32)
-      CurModule.CurrentModule->setPointerSize(Module::Pointer32);
-    else if ($3 == 64)
-      CurModule.CurrentModule->setPointerSize(Module::Pointer64);
-    else
-      GEN_ERROR("Invalid pointer size: '" + utostr($3) + "'!");
-    CHECK_FOR_ERROR
-  }
-  | TRIPLE '=' STRINGCONSTANT {
+TargetDefinition : TRIPLE '=' STRINGCONSTANT {
     CurModule.CurrentModule->setTargetTriple($3);
     free($3);
   }
@@ -1995,10 +1988,7 @@
 //                       Rules to match Function Headers
 //===----------------------------------------------------------------------===//
 
-Name : VAR_ID | STRINGCONSTANT;
-OptName : Name | /*empty*/ { $$ = 0; };
-
-ArgListH : ArgListH ',' Types OptParamAttrs OptName {
+ArgListH : ArgListH ',' Types OptParamAttrs OptLocalName {
     if (!UpRefs.empty())
       GEN_ERROR("Invalid upreference in type: " + (*$3)->getDescription());
     if (*$3 == Type::VoidTy)
@@ -2008,7 +1998,7 @@
     $1->push_back(E);
     CHECK_FOR_ERROR
   }
-  | Types OptParamAttrs OptName {
+  | Types OptParamAttrs OptLocalName {
     if (!UpRefs.empty())
       GEN_ERROR("Invalid upreference in type: " + (*$1)->getDescription());
     if (*$1 == Type::VoidTy)
@@ -2046,7 +2036,7 @@
     CHECK_FOR_ERROR
   };
 
-FunctionHeaderH : OptCallingConv ResultTypes Name '(' ArgList ')' 
+FunctionHeaderH : OptCallingConv ResultTypes GlobalName '(' ArgList ')' 
                   OptFuncAttrs OptSection OptAlign {
   UnEscapeLexed($3);
   std::string FunctionName($3);
@@ -2081,9 +2071,9 @@
 
   ValID ID;
   if (!FunctionName.empty()) {
-    ID = ValID::create((char*)FunctionName.c_str());
+    ID = ValID::createGlobalName((char*)FunctionName.c_str());
   } else {
-    ID = ValID::create((int)CurModule.Values[PFT].size());
+    ID = ValID::createGlobalID(CurModule.Values[PFT].size());
   }
 
   Function *Fn = 0;
@@ -2266,12 +2256,20 @@
 // SymbolicValueRef - Reference to one of two ways of symbolically refering to
 // another value.
 //
-SymbolicValueRef : INTVAL {  // Is it an integer reference...?
-    $$ = ValID::create($1);
+SymbolicValueRef : LOCALVAL_ID {  // Is it an integer reference...?
+    $$ = ValID::createLocalID($1);
     CHECK_FOR_ERROR
   }
-  | Name {                   // Is it a named reference...?
-    $$ = ValID::create($1);
+  | GLOBALVAL_ID {
+    $$ = ValID::createGlobalID($1);
+    CHECK_FOR_ERROR
+  }
+  | LocalName {                   // Is it a named reference...?
+    $$ = ValID::createLocalName($1);
+    CHECK_FOR_ERROR
+  }
+  | GlobalName {                   // Is it a named reference...?
+    $$ = ValID::createGlobalName($1);
     CHECK_FOR_ERROR
   };
 
@@ -2304,7 +2302,7 @@
 // Basic blocks are terminated by branching instructions: 
 // br, br/cc, switch, ret
 //
-BasicBlock : InstructionList OptAssign BBTerminatorInst  {
+BasicBlock : InstructionList OptLocalAssign BBTerminatorInst  {
     setValueName($3, $2);
     CHECK_FOR_ERROR
     InsertValue($3);
@@ -2325,7 +2323,7 @@
     CHECK_FOR_ERROR
   }
   | /* empty */ {
-    $$ = getBBVal(ValID::create((int)CurFun.NextBBNum++), true);
+    $$ = getBBVal(ValID::createLocalID(CurFun.NextBBNum++), true);
     CHECK_FOR_ERROR
 
     // Make sure to move the basic block to the correct location in the
@@ -2337,7 +2335,7 @@
     CHECK_FOR_ERROR
   }
   | LABELSTR {
-    $$ = getBBVal(ValID::create($1), true);
+    $$ = getBBVal(ValID::createLocalName($1), true);
     CHECK_FOR_ERROR
 
     // Make sure to move the basic block to the correct location in the
@@ -2502,7 +2500,7 @@
     $$->push_back(std::make_pair(V, tmpBB)); 
   };
 
-Inst : OptAssign InstVal {
+Inst : OptLocalAssign InstVal {
   // Is this definition named?? if so, assign the name...
   setValueName($2, $1);
   CHECK_FOR_ERROR
@@ -2762,6 +2760,7 @@
     CI->setCallingConv($2);
     $$ = CI;
     delete $6;
+    delete $3;
     CHECK_FOR_ERROR
   }
   | MemoryInst {


Index: llvm/lib/AsmParser/Lexer.l
diff -u llvm/lib/AsmParser/Lexer.l:1.95 llvm/lib/AsmParser/Lexer.l:1.96
--- llvm/lib/AsmParser/Lexer.l:1.95	Fri Jan 12 23:00:20 2007
+++ llvm/lib/AsmParser/Lexer.l	Fri Jan 26 02:04:51 2007
@@ -148,8 +148,11 @@
 /* Comments start with a ; and go till end of line */
 Comment    ;.*
 
-/* Variable(Value) identifiers start with a % sign */
-VarID       %[-a-zA-Z$._][-a-zA-Z$._0-9]*
+/* Local Values and Type identifiers start with a % sign */
+LocalVarName       %[-a-zA-Z$._][-a-zA-Z$._0-9]*
+
+/* Global Value identifiers start with an @ sign */
+GlobalVarName       @[-a-zA-Z$._][-a-zA-Z$._0-9]*
 
 /* Label identifiers end with a colon */
 Label       [-a-zA-Z$._0-9]+:
@@ -157,18 +160,16 @@
 
 /* Quoted names can contain any character except " and \ */
 StringConstant \"[^\"]*\"
+AtStringConstant @\"[^\"]*\"
+  
+/* LocalVarID/GlobalVarID: match an unnamed local variable slot ID. */
+LocalVarID     %[0-9]+
+GlobalVarID    @[0-9]+
 
-
-/* [PN]Integer: match positive and negative literal integer values that
- * are preceeded by a '%' character.  These represent unnamed variable slots.
- */
-EPInteger     %[0-9]+
-ENInteger    %-[0-9]+
-
+/* Integer types are specified with i and a bitwidth */
 IntegerType i[0-9]+
 
-
-/* E[PN]Integer: match positive and negative literal integer values */
+/* E[PN]Integer: match positive and negative literal integer values. */
 PInteger   [0-9]+
 NInteger  -[0-9]+
 
@@ -216,11 +217,7 @@
 target          { return TARGET; }
 triple          { return TRIPLE; }
 deplibs         { return DEPLIBS; }
-endian          { return ENDIAN; }
-pointersize     { return POINTERSIZE; }
 datalayout      { return DATALAYOUT; }
-little          { return LITTLE; }
-big             { return BIG; }
 volatile        { return VOLATILE; }
 align           { return ALIGN;  }
 section         { return SECTION; }
@@ -323,10 +320,15 @@
 shufflevector   { RET_TOK(OtherOpVal, ShuffleVector, SHUFFLEVECTOR); }
 
 
-{VarID}         {
+{LocalVarName}  {
                   UnEscapeLexed(yytext+1);
                   llvmAsmlval.StrVal = strdup(yytext+1);             // Skip %
-                  return VAR_ID;
+                  return LOCALVAR;
+                }
+{GlobalVarName} {
+                  UnEscapeLexed(yytext+1);
+                  llvmAsmlval.StrVal = strdup(yytext+1);             // Skip @
+                  return GLOBALVAR;
                 }
 {Label}         {
                   yytext[strlen(yytext)-1] = 0;  // nuke colon
@@ -350,6 +352,12 @@
                    llvmAsmlval.StrVal = strdup(yytext+1);  // Nuke start quote
                    return STRINGCONSTANT;
                  }
+{AtStringConstant} {
+                     yytext[strlen(yytext)-1] = 0;           // nuke end quote
+                     llvmAsmlval.StrVal = strdup(yytext+2);  // Nuke @, quote
+                     return ATSTRINGCONSTANT;
+                   }
+
 
 
 {PInteger}      { llvmAsmlval.UInt64Val = atoull(yytext); return EUINT64VAL; }
@@ -366,20 +374,19 @@
                    return yytext[0] == 's' ? ESINT64VAL : EUINT64VAL;
                  }
 
-{EPInteger}     {
+{LocalVarID}     {
                   uint64_t Val = atoull(yytext+1);
                   if ((unsigned)Val != Val)
                     GenerateError("Invalid value number (too large)!");
                   llvmAsmlval.UIntVal = unsigned(Val);
-                  return UINTVAL;
+                  return LOCALVAL_ID;
                 }
-{ENInteger}     {
-                  uint64_t Val = atoull(yytext+2);
-                  // +1:  we have bigger negative range
-                  if (Val > (uint64_t)INT32_MAX+1)
-                    GenerateError("Constant too large for signed 32 bits!");
-                  llvmAsmlval.SIntVal = (int)-Val;
-                  return SINTVAL;
+{GlobalVarID}   {
+                  uint64_t Val = atoull(yytext+1);
+                  if ((unsigned)Val != Val)
+                    GenerateError("Invalid value number (too large)!");
+                  llvmAsmlval.UIntVal = unsigned(Val);
+                  return GLOBALVAL_ID;
                 }
 
 {FPConstant}    { llvmAsmlval.FPVal = atof(yytext); return FPVAL; }


Index: llvm/lib/AsmParser/ParserInternals.h
diff -u llvm/lib/AsmParser/ParserInternals.h:1.52 llvm/lib/AsmParser/ParserInternals.h:1.53
--- llvm/lib/AsmParser/ParserInternals.h:1.52	Thu Jan 11 06:24:13 2007
+++ llvm/lib/AsmParser/ParserInternals.h	Fri Jan 26 02:04:51 2007
@@ -88,12 +88,13 @@
 //
 struct ValID {
   enum {
-    NumberVal, NameVal, ConstSIntVal, ConstUIntVal, ConstFPVal, ConstNullVal,
+    LocalID, GlobalID, LocalName, GlobalName,
+    ConstSIntVal, ConstUIntVal, ConstFPVal, ConstNullVal,
     ConstUndefVal, ConstZeroVal, ConstantVal, InlineAsmVal
   } Type;
 
   union {
-    int      Num;         // If it's a numeric reference
+    unsigned Num;         // If it's a numeric reference like %1234
     char    *Name;        // If it's a named reference.  Memory must be free'd.
     int64_t  ConstPool64; // Constant pool reference.  This is the value
     uint64_t UConstPool64;// Unsigned constant pool reference.
@@ -102,14 +103,19 @@
     InlineAsmDescriptor *IAD;
   };
 
-  static ValID create(int Num) {
-    ValID D; D.Type = NumberVal; D.Num = Num; return D;
+  static ValID createLocalID(unsigned Num) {
+    ValID D; D.Type = LocalID; D.Num = Num; return D;
   }
-
-  static ValID create(char *Name) {
-    ValID D; D.Type = NameVal; D.Name = Name; return D;
+  static ValID createGlobalID(unsigned Num) {
+    ValID D; D.Type = GlobalID; D.Num = Num; return D;
   }
-
+  static ValID createLocalName(char *Name) {
+    ValID D; D.Type = LocalName; D.Name = Name; return D;
+  }
+  static ValID createGlobalName(char *Name) {
+    ValID D; D.Type = GlobalName; D.Name = Name; return D;
+  }
+  
   static ValID create(int64_t Val) {
     ValID D; D.Type = ConstSIntVal; D.ConstPool64 = Val; return D;
   }
@@ -148,14 +154,14 @@
   }
 
   inline void destroy() const {
-    if (Type == NameVal)
+    if (Type == LocalName || Type == GlobalName)
       free(Name);    // Free this strdup'd memory.
     else if (Type == InlineAsmVal)
       delete IAD;
   }
 
   inline ValID copy() const {
-    if (Type != NameVal) return *this;
+    if (Type != LocalName && Type != GlobalName) return *this;
     ValID Result = *this;
     Result.Name = strdup(Name);
     return Result;
@@ -163,8 +169,10 @@
 
   inline std::string getName() const {
     switch (Type) {
-    case NumberVal     : return std::string("#") + itostr(Num);
-    case NameVal       : return Name;
+    case LocalID       : return '%' + utostr(Num);
+    case GlobalID      : return '@' + utostr(Num);
+    case LocalName     : return Name;
+    case GlobalName    : return Name;
     case ConstFPVal    : return ftostr(ConstPoolFP);
     case ConstNullVal  : return "null";
     case ConstUndefVal : return "undef";
@@ -185,8 +193,10 @@
   bool operator<(const ValID &V) const {
     if (Type != V.Type) return Type < V.Type;
     switch (Type) {
-    case NumberVal:     return Num < V.Num;
-    case NameVal:       return strcmp(Name, V.Name) < 0;
+    case LocalID:
+    case GlobalID:      return Num < V.Num;
+    case LocalName:
+    case GlobalName:    return strcmp(Name, V.Name) < 0;
     case ConstSIntVal:  return ConstPool64  < V.ConstPool64;
     case ConstUIntVal:  return UConstPool64 < V.UConstPool64;
     case ConstFPVal:    return ConstPoolFP  < V.ConstPoolFP;





From reid at x10sys.com  Fri Jan 26 02:05:46 2007
From: reid at x10sys.com (Reid Spencer)
Date: Fri, 26 Jan 2007 02:05:46 -0600
Subject: [llvm-commits] CVS: llvm/lib/AsmParser/Lexer.cpp.cvs Lexer.l.cvs
	llvmAsmParser.cpp.cvs llvmAsmParser.h.cvs llvmAsmParser.y.cvs
Message-ID: <200701260805.l0Q85kJP022395@zion.cs.uiuc.edu>



Changes in directory llvm/lib/AsmParser:

Lexer.cpp.cvs updated: 1.27 -> 1.28
Lexer.l.cvs updated: 1.22 -> 1.23
llvmAsmParser.cpp.cvs updated: 1.57 -> 1.58
llvmAsmParser.h.cvs updated: 1.45 -> 1.46
llvmAsmParser.y.cvs updated: 1.58 -> 1.59
---
Log message:

Regenerate for PR645: http://llvm.org/PR645  and PR761: http://llvm.org/PR761 


---
Diffs of the changes:  (+3801 -3595)

 Lexer.cpp.cvs         | 1430 ++++++-------
 Lexer.l.cvs           |   59 
 llvmAsmParser.cpp.cvs | 5156 ++++++++++++++++++++++++++------------------------
 llvmAsmParser.h.cvs   |  518 ++---
 llvmAsmParser.y.cvs   |  233 +-
 5 files changed, 3801 insertions(+), 3595 deletions(-)


Index: llvm/lib/AsmParser/Lexer.cpp.cvs
diff -u llvm/lib/AsmParser/Lexer.cpp.cvs:1.27 llvm/lib/AsmParser/Lexer.cpp.cvs:1.28
--- llvm/lib/AsmParser/Lexer.cpp.cvs:1.27	Fri Jan 19 15:13:56 2007
+++ llvm/lib/AsmParser/Lexer.cpp.cvs	Fri Jan 26 02:05:27 2007
@@ -17,10 +17,14 @@
 #define yylineno llvmAsmlineno
 
 #line 20 "Lexer.cpp"
-/* A lexical scanner generated by flex*/
+/* A lexical scanner generated by flex */
 
 /* Scanner skeleton version:
- * $Header: /var/cvs/llvm/llvm/lib/AsmParser/Lexer.cpp.cvs,v 1.27 2007/01/19 21:13:56 reid Exp $
+<<<<<<< Lexer.cpp.cvs
+ * $Header: /var/cvs/llvm/llvm/lib/AsmParser/Lexer.cpp.cvs,v 1.28 2007/01/26 08:05:27 reid Exp $
+=======
+ * $Header: /var/cvs/llvm/llvm/lib/AsmParser/Lexer.cpp.cvs,v 1.28 2007/01/26 08:05:27 reid Exp $
+>>>>>>> 1.27
  */
 
 #define FLEX_SCANNER
@@ -28,7 +32,6 @@
 #define YY_FLEX_MINOR_VERSION 5
 
 #include 
-#include 
 
 
 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
@@ -42,6 +45,7 @@
 #ifdef __cplusplus
 
 #include 
+#include 
 
 /* Use prototypes in function declarations. */
 #define YY_USE_PROTOS
@@ -153,15 +157,6 @@
 
 #define unput(c) yyunput( c, yytext_ptr )
 
-/* Some routines like yy_flex_realloc() are emitted as static but are
-   not called by all lexers. This generates warnings in some compilers,
-   notably GCC. Arrange to suppress these. */
-#ifdef __GNUC__
-#define YY_MAY_BE_UNUSED __attribute__((unused))
-#else
-#define YY_MAY_BE_UNUSED
-#endif
-
 /* The following is because we cannot portably get our hands on size_t
  * (without autoconf's help, which isn't available because we want
  * flex-generated scanners to compile on their own).
@@ -268,7 +263,7 @@
 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
 
 static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
-static inline void *yy_flex_realloc YY_PROTO(( void *, yy_size_t )) YY_MAY_BE_UNUSED;
+static inline void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
 static void yy_flex_free YY_PROTO(( void * ));
 
 #define yy_new_buffer yy_create_buffer
@@ -317,37 +312,36 @@
 	*yy_cp = '\0'; \
 	yy_c_buf_p = yy_cp;
 
-#define YY_NUM_RULES 135
-#define YY_END_OF_BUFFER 136
-static yyconst short int yy_acclist[215] =
+#define YY_NUM_RULES 131
+#define YY_END_OF_BUFFER 132
+static yyconst short int yy_acclist[211] =
     {   0,
-      136,  134,  135,  133,  134,  135,  133,  135,  134,  135,
-      134,  135,  134,  135,  134,  135,  134,  135,  134,  135,
-      126,  134,  135,  126,  134,  135,    1,  134,  135,  134,
-      135,  134,  135,  134,  135,  134,  135,  134,  135,  134,
-      135,  134,  135,  134,  135,  134,  135,  134,  135,  134,
-      135,  134,  135,  134,  135,  134,  135,  134,  135,  134,
-      135,  134,  135,  134,  135,  134,  135,  134,  135,  134,
-      135,  134,  135,  125,  123,  122,  122,  129,  127,  131,
-      126,    1,  108,   40,   68,   53,   69,   64,   24,  125,
-      122,  122,  130,  131,   21,  131,  132,   54,   63,   38,
-
-       33,   41,    3,   56,   78,   83,   81,   82,   80,   79,
-       84,   88,  107,   73,   71,  103,   72,   70,   55,   86,
-       77,   75,   76,   74,   87,   85,   65,  124,  131,  131,
-      105,   89,   67,   59,  115,   62,   66,  116,  104,   23,
-      128,   58,   92,   61,   25,    4,   51,   57,   60,   47,
-       12,   91,  131,   35,    2,    5,   48,   94,   50,  117,
-       90,   22,  114,   44,    7,   49,   29,   43,   98,   97,
-        8,   16,  110,   32,  113,   37,   52,  102,   96,  109,
-       26,   27,   95,  111,  106,  101,   42,    6,   28,   93,
-       36,    9,   18,   10,   99,   11,  100,   34,   13,   15,
+      132,  130,  131,  129,  130,  131,  129,  131,  130,  131,
+      130,  131,  130,  131,  130,  131,  130,  131,  130,  131,
+      122,  130,  131,  122,  130,  131,    1,  130,  131,  130,
+      131,  130,  131,  130,  131,  130,  131,  130,  131,  130,
+      131,  130,  131,  130,  131,  130,  131,  130,  131,  130,
+      131,  130,  131,  130,  131,  130,  131,  130,  131,  130,
+      131,  130,  131,  130,  131,  130,  131,  130,  131,  130,
+      131,  130,  131,  121,  119,  118,  118,  125,  123,  127,
+      122,    1,  104,   36,   64,   49,   65,   60,   24,  121,
+      118,  118,  126,  127,   21,  127,  128,   50,   59,   34,
+
+       37,    3,   52,   74,   79,   77,   78,   76,   75,   80,
+       84,  103,   69,   67,   99,   68,   66,   51,   82,   73,
+       71,   72,   70,   83,   81,   61,  120,  127,  127,  101,
+       85,   63,   55,  111,   58,   62,  112,  100,   23,  124,
+       54,   88,   57,   25,    4,   47,   53,   56,   43,   12,
+       87,  127,   31,    2,    5,   44,   90,   46,  113,   86,
+       22,  110,   40,    7,   45,   39,   94,   93,    8,   16,
+      106,  109,   33,   48,   98,   92,  105,   26,   27,   91,
+      107,  102,   97,   38,    6,   28,   89,   32,    9,   18,
+       10,   95,   11,   96,   30,   13,   15,   14,   29,   35,
 
-       14,   31,   39,   17,   30,  112,  118,  120,  121,   45,
-      119,   19,   46,   20
+       17,  108,  114,  116,  117,   41,  115,   19,   42,   20
     } ;
 
-static yyconst short int yy_accept[555] =
+static yyconst short int yy_accept[537] =
     {   0,
         1,    1,    1,    2,    4,    7,    9,   11,   13,   15,
        17,   19,   21,   24,   27,   30,   32,   34,   36,   38,
@@ -361,55 +355,53 @@
        87,   88,   88,   88,   88,   88,   88,   88,   89,   89,
 
        89,   89,   89,   89,   89,   89,   89,   89,   89,   89,
-       89,   89,   89,   89,   89,   90,   90,   90,   90,   90,
+       89,   89,   89,   89,   90,   90,   90,   90,   90,   90,
        90,   90,   90,   90,   90,   90,   90,   90,   90,   90,
-       90,   91,   92,   94,   95,   96,   97,   97,   98,   99,
-       99,   99,  100,  100,  100,  101,  101,  102,  102,  102,
+       91,   92,   94,   95,   96,   97,   97,   98,   99,   99,
+       99,  100,  100,  100,  101,  101,  101,  101,  102,  102,
+      102,  102,  102,  102,  102,  102,  102,  102,  103,  103,
+      103,  103,  103,  103,  103,  103,  103,  103,  103,  103,
       103,  103,  103,  103,  103,  103,  103,  103,  103,  103,
-      104,  104,  104,  104,  104,  104,  104,  104,  104,  104,
-      104,  104,  104,  104,  104,  104,  104,  104,  104,  104,
-      104,  104,  104,  104,  104,  105,  105,  106,  107,  108,
-      109,  110,  111,  111,  112,  113,  113,  113,  114,  114,
-
-      114,  114,  114,  114,  115,  116,  117,  117,  117,  117,
-      118,  119,  119,  119,  120,  120,  120,  120,  120,  120,
-      120,  120,  121,  122,  123,  123,  124,  125,  125,  126,
-      127,  127,  127,  127,  127,  127,  127,  127,  127,  128,
-      128,  128,  129,  130,  130,  130,  130,  131,  131,  131,
-      131,  132,  132,  132,  133,  133,  133,  133,  133,  133,
-      133,  133,  133,  133,  133,  133,  133,  133,  133,  133,
-      134,  135,  135,  135,  135,  135,  136,  137,  137,  137,
-      137,  138,  138,  138,  138,  138,  138,  138,  138,  138,
-      139,  140,  140,  140,  141,  141,  141,  141,  142,  143,
-
-      143,  143,  144,  144,  144,  144,  145,  145,  145,  146,
-      146,  146,  147,  147,  148,  149,  149,  149,  149,  149,
-      150,  150,  151,  151,  152,  152,  152,  153,  154,  155,
-      155,  155,  156,  156,  156,  156,  156,  156,  156,  156,
-      156,  156,  156,  156,  156,  156,  156,  157,  157,  158,
-      159,  159,  159,  159,  159,  159,  159,  159,  159,  159,
-      159,  159,  160,  160,  160,  160,  160,  160,  160,  160,
-      160,  160,  160,  160,  160,  161,  161,  161,  161,  162,
-      162,  163,  163,  163,  163,  163,  163,  163,  163,  164,
-      164,  164,  165,  165,  165,  165,  165,  166,  166,  166,
-
-      166,  167,  168,  168,  168,  169,  170,  171,  171,  171,
-      172,  173,  173,  173,  173,  173,  174,  174,  175,  176,
-      177,  178,  178,  178,  178,  179,  179,  179,  180,  181,
-      182,  183,  184,  184,  185,  186,  186,  186,  186,  186,
-      186,  187,  187,  188,  188,  189,  190,  190,  190,  190,
-      190,  190,  191,  191,  191,  191,  191,  191,  191,  191,
-      191,  192,  192,  192,  192,  192,  192,  192,  192,  192,
-      193,  193,  193,  193,  193,  194,  194,  194,  194,  194,
-      195,  196,  197,  197,  198,  198,  198,  198,  199,  199,
-      199,  199,  200,  200,  201,  202,  202,  202,  202,  202,
-
-      202,  202,  202,  202,  202,  202,  202,  202,  203,  203,
-      203,  203,  203,  203,  203,  203,  204,  204,  204,  204,
-      204,  205,  205,  205,  205,  205,  206,  206,  207,  207,
-      207,  207,  207,  207,  207,  207,  207,  207,  207,  207,
-      207,  208,  208,  209,  210,  210,  211,  211,  212,  213,
-      214,  214,  215,  215
+      103,  103,  104,  104,  105,  106,  107,  108,  109,  110,
+      110,  111,  112,  112,  113,  113,  113,  113,  113,  113,
+
+      114,  115,  116,  116,  116,  116,  117,  118,  118,  118,
+      119,  119,  119,  119,  119,  119,  119,  119,  120,  121,
+      122,  122,  123,  124,  124,  125,  126,  126,  126,  126,
+      126,  126,  126,  126,  126,  127,  127,  127,  128,  129,
+      129,  129,  129,  130,  130,  130,  130,  131,  131,  131,
+      132,  132,  132,  132,  132,  132,  132,  132,  132,  132,
+      132,  132,  132,  132,  132,  133,  134,  134,  134,  134,
+      134,  135,  136,  136,  136,  136,  137,  137,  137,  137,
+      137,  137,  137,  137,  138,  139,  139,  139,  140,  140,
+      140,  141,  142,  142,  142,  143,  143,  143,  143,  144,
+
+      144,  144,  145,  145,  145,  146,  146,  147,  148,  148,
+      148,  148,  148,  149,  149,  150,  150,  151,  151,  151,
+      152,  153,  154,  154,  154,  155,  155,  155,  155,  155,
+      155,  155,  155,  155,  155,  155,  155,  155,  155,  156,
+      156,  157,  158,  158,  158,  158,  158,  158,  158,  158,
+      158,  158,  158,  158,  159,  159,  159,  159,  159,  159,
+      159,  159,  159,  159,  159,  160,  160,  160,  160,  161,
+      161,  162,  162,  162,  162,  162,  162,  162,  162,  163,
+      163,  163,  164,  164,  164,  164,  164,  165,  165,  165,
+      165,  166,  166,  166,  167,  168,  169,  169,  169,  170,
+
+      171,  171,  171,  171,  171,  172,  172,  173,  174,  175,
+      175,  175,  176,  176,  176,  177,  178,  179,  180,  181,
+      181,  182,  183,  183,  183,  183,  183,  183,  184,  184,
+      185,  185,  186,  187,  187,  187,  187,  187,  187,  188,
+      188,  188,  188,  188,  188,  188,  188,  189,  189,  189,
+      189,  189,  189,  189,  189,  189,  190,  190,  190,  190,
+      190,  191,  191,  191,  191,  191,  192,  193,  194,  195,
+      195,  195,  195,  196,  196,  196,  196,  197,  197,  198,
+      199,  199,  199,  199,  199,  199,  199,  199,  199,  199,
+      199,  199,  200,  200,  200,  200,  200,  200,  200,  201,
+
+      201,  201,  201,  201,  202,  202,  202,  202,  202,  202,
+      203,  203,  203,  203,  203,  203,  203,  203,  203,  203,
+      203,  203,  203,  204,  204,  205,  206,  206,  207,  207,
+      208,  209,  210,  210,  211,  211
     } ;
 
 static yyconst int yy_ec[256] =
@@ -453,416 +445,404 @@
         3,    3,    3
     } ;
 
-static yyconst short int yy_base[559] =
+static yyconst short int yy_base[541] =
     {   0,
-        0,    0, 1200, 1201, 1201, 1201, 1195, 1184,   36,   40,
+        0,    0, 1164, 1165, 1165, 1165, 1159, 1148,   36,   40,
        44,   50,   56,   62,    0,   63,   66,   81,   89,   47,
-      108,   91,   77,  134,   92,  119,   93,  152,  126,  109,
-      178,  154,  209,  135,  111,  146,  112, 1193, 1201, 1182,
-     1201,    0,  159,  198,  215,  236,   70,  241,  256,  261,
-        0,   68,  147,  128,  165,  176,   73,  262, 1181,   31,
-      170,  166,   48,   49,  265,  185,  101,  198, 1180,  180,
-      227,  207,  208,  225,  274,  139,  276,  228,  278,  272,
-      229,  277,  280,  281,  290,  293,  282,  291,  292,  295,
-     1179,  301,  122,  308,  309,  311,  314,  304,  315,  321,
-
-      322,  323,  324,  325,  326,  327,  330,  329,  335,  339,
-      342,  349,  356,  357, 1178,  359,  347,  361,  362,  364,
-      340,  367,  371,  368,  215,  381,  386,  395,  384,  385,
-     1177,    0,  402,  411, 1176,  425,  442,    0, 1175,  168,
-      411, 1174,  404,  416, 1173,  375, 1172,  419,  402, 1171,
-      443,  427,  444,  445,  403,  433,  415,  447,  448,  452,
-      455,  457,  458,  459,  461,  462,  463,  466,  473,  468,
-      469,  472,  474,  470,  483,  488,  491,  494,  496,  495,
-      498,  499,  500,  501, 1170,  502, 1169, 1168, 1167, 1166,
-     1165, 1164,  504, 1163, 1162,  505,  507, 1161,  535,  514,
-
-      512,  519,  513, 1160, 1159, 1158,  516,  546,  529, 1157,
-     1156,  548,  549, 1155,  527,  508,  551,  552,  556,  554,
-      553, 1154, 1153, 1152,  557, 1151, 1150,  558, 1149, 1148,
-      559,  561,  560,  572,  579,  580,  569,  582, 1147,  566,
-      581, 1201,  592,  600,  609,  613,  618,  602,  620,  621,
-     1146,  622,  623, 1145,  624,  603,  625,  629,  630,  632,
-      633,  634,  636,  640,  637,  641,  645,  647,  651, 1144,
-     1143,  643,  653,  657,  654, 1142, 1141,  659,  660,  663,
-     1140,  664,  667,  668,  669,  670,  671,  675,  677, 1139,
-     1138,  680,  682, 1137,  683,  685,  691,    0, 1136,  690,
-
-      694, 1135,  695,  702,  696, 1134,  704,  710, 1133,  712,
-      699, 1132,  715, 1131, 1130,  716,  718,  719,  720, 1129,
-      723, 1128,  725, 1127,  729,  727, 1126,  734, 1125,  736,
-      592, 1124,  734,  735,  738,  745,  749,  746,  750,  747,
-      755,  757,  760,  758,  761,  763, 1123,  764, 1122, 1121,
-      766,  768,  765,  777,  772,  773,  780,  762,  783,  784,
-      788, 1120,  789,  792,  791,  793,  795,  799,  794,  805,
-      809,  810,  811,  812, 1119,  814,  813,  815, 1118,  816,
-     1117,  820,  822,  817,  829,  833,  818,  834, 1116,  837,
-      839, 1115,  840,  845,  819,  844, 1114,  843,  846,  848,
-
-     1113, 1112,  854,  849, 1111, 1110, 1109,  856,  855, 1108,
-     1107,  860,  861,  868,  867, 1106,  874, 1105, 1104, 1103,
-     1102,  875,  876,  877, 1101,  878,  879, 1100, 1099, 1098,
-     1097, 1096,  880, 1095, 1094,  882,  883,  891,  885,  884,
-     1093,  886, 1092,  888, 1091, 1090,  895,  900,  902,  903,
-      904, 1089,  908,  907,  910,  911,  912,  914,  915,  919,
-     1086,  920,  922,  927,  929,  930,  934,  935,  936, 1077,
-      939,  943,  944,  940, 1076,  946,  948,  950,  951, 1075,
-     1073, 1071,  955, 1070,  962,  952,  964, 1069,  969,  972,
-      974, 1068,  956, 1067, 1064,  975,  981,  978,  983,  982,
-
-      957,  984,  985,  989,  992,  994,  995, 1063,  993,  996,
-      999, 1002, 1005, 1006, 1003, 1062, 1010, 1013, 1016, 1017,
-     1058, 1011, 1021, 1022, 1023,  954, 1024,  700, 1030, 1027,
-     1033, 1036, 1029, 1037, 1038, 1039, 1041, 1047, 1043, 1051,
-      521, 1049,  471,  432, 1052,  431, 1056,  365,  248,  247,
-     1057,  216, 1201, 1092, 1094,  107, 1098,  106
+      108,   91,   77,  134,   92,  119,   93,  152,   72,  109,
+      178,  121,  209,  120,  135,  146,  147, 1157, 1165, 1146,
+     1165,    0,  161,  183,  199,  215,   70,  235,  250,  255,
+        0,   68,  140,  128,  165,  154,  101,   46, 1145,   96,
+      168,  206,  162,  177,  259,  188,   49,  208, 1144,  219,
+      267,  176,  172,  207,  268,  227,  256,  270,  229,  264,
+      274,  273,  272,  287,   31,  296,  228,  283,  276,  285,
+     1143,  299,  286,  302,  303,  304,  305,  307,  308,  309,
+
+      316,  317,  318,  320,  319,  322,  332,  329,  324,  323,
+      343,  345,  348, 1142,  350,  334,  351,  336,  357,  354,
+      359,  367,  362,  239,  379,  360,  372,  378,  381, 1141,
+        0,  399,  407, 1140,  421,  438,    0, 1139,  373,  383,
+     1138,  391,  386, 1137,  409,  426,  412, 1136,  415,  389,
+      439,  440,  413,  429,  441,  444,  443, 1135,  446,  425,
+      450,  451,  452,  454,  387,  458,  462,  460,  466,  474,
+      461,  468,  475,  481,  485,  486,  487,  488,  489,  491,
+      492, 1134,  493, 1133, 1132, 1131, 1130, 1129, 1128,  494,
+     1127, 1126,  497, 1125,  525,  500,  513,  498,  515, 1124,
+
+     1123, 1122,  499,  502,  519, 1121, 1120,  526,  518, 1119,
+      517,  529,  541,  543,  546,  545,  547, 1118, 1117, 1116,
+      548, 1115, 1114,  549, 1113, 1112,  550,  551,  553,  556,
+      557,  568,  560,  567, 1111,  570,  575, 1165,  580,  588,
+      594,  603,  608,  580,  505,  594, 1110,  595,  609, 1109,
+      610,  596,  613,  615,  616,  618,  620,  622,  623,  625,
+      624,  626,  628,  627, 1108, 1107,  629,  632,  638,  641,
+     1106, 1105,  642,  643,  644, 1104,  647,  646,  650,  651,
+      654,  658,  659, 1103, 1102,  661,  663, 1101,  664,  666,
+        0, 1100,  670,  674, 1099,  672,  676,  680, 1098,  686,
+
+      687, 1097,  689,  691, 1096,  692, 1095, 1094,  693,  697,
+      696,  700, 1093,  702, 1092,  704, 1091,  708,  709, 1090,
+      714, 1089,  714,  716, 1088,  715,  721,  720,  726,  729,
+      731,  732,  736,  735,  738,  739,  743,  740, 1087,  744,
+     1086, 1085,  745,  746,  749,  753,  750,  755,  761,  756,
+      763,  764,  767, 1084,  768,  771,  773,  775,  774,  770,
+      769,  781,  789,  786, 1083,  790,  791,  794, 1082,  793,
+     1081,  797,  798,  800,  795,  810,  801,  809, 1080,  807,
+      813, 1079,  816,  818,  817,  819, 1078,  821,  822,  823,
+     1077,  827,  829, 1076, 1075, 1074,  830,  834, 1073, 1072,
+
+      835,  838,  846,  839, 1071,  842, 1070, 1069, 1068,  848,
+      853, 1067,  854,  856, 1066, 1065, 1064, 1063, 1062,  855,
+     1061, 1060,  857,  858,  860,  861,  859, 1059,  864, 1058,
+      871, 1057, 1056,  869,  873,  122,  877,  875, 1055,  879,
+      878,  881,  882,  883,  891,  885, 1054,  886,  893,  898,
+      901,  899,  905,  906,  907, 1051,  909,  913,  914,  915,
+     1042,  916,  917,  919,  921, 1041, 1040, 1039, 1038,  923,
+      920,  935, 1036,  938,  939,  940, 1035,  925, 1033, 1032,
+      946,  943,  926,  950,  947,  954,  956,  957,  959,  958,
+      960, 1031,  962,  966,  967,  968,  969,  970, 1027,  971,
+
+      974,  975,  977, 1025,  985,  981,  983,  984,  987, 1024,
+      988,  995,  997,  998,  999, 1000, 1006, 1007, 1009, 1012,
+     1008, 1011, 1023, 1013,  928,  705, 1014,  675, 1017,  465,
+      464,  463, 1022,  390, 1165, 1057, 1059,  286, 1063,  252
     } ;
 
-static yyconst short int yy_def[559] =
+static yyconst short int yy_def[541] =
     {   0,
-      553,    1,  553,  553,  553,  553,  554,  555,  556,  553,
-      555,  555,  555,  555,  557,  555,  555,  555,  555,  555,
-      555,  555,  555,  555,  555,  555,  555,  555,  555,  555,
-      555,  555,  555,  555,  555,  555,  555,  554,  553,  555,
-      553,  558,  558,  553,  553,  555,  555,  555,  555,  555,
-      557,  555,  555,  555,  555,  555,  555,  555,  555,  555,
-      555,  555,  555,  555,  555,  555,  555,  555,  555,  555,
-      555,  555,  555,  555,  555,  555,  555,  555,  555,   24,
-      555,  555,  555,  555,  555,  555,  555,  555,  555,  555,
-      555,  555,  555,  555,  555,  555,  555,  555,  555,  555,
-
-      555,  555,  555,  555,  555,  555,  555,  555,  555,  555,
-      555,  555,  555,  555,  555,  555,  555,  555,  555,  555,
-      555,  555,  555,  555,  555,  555,  555,  555,  555,  555,
-      553,  558,  558,  553,  555,  555,  555,   50,  555,  555,
-      555,  555,  555,  555,  555,  555,  555,  555,  555,  555,
-      555,  555,  555,  555,  555,  555,  555,  555,  555,  555,
-      555,  555,  555,  555,  555,  555,  555,  555,  555,  555,
-      555,  555,  555,  555,  555,  555,  555,  555,  555,  555,
-      555,  555,  555,  555,  555,  555,  555,  555,  555,  555,
-      555,  555,  555,  555,  555,  555,  555,  555,   50,  555,
-
-      555,  555,  555,  555,  555,  555,  555,  555,  555,  555,
-      555,  555,  555,  555,  555,  555,  555,  555,  555,  555,
-      555,  555,  555,  555,  555,  555,  555,  555,  555,  555,
-      555,  555,  555,  555,  555,  555,  555,  555,  555,  555,
-      555,  553,  553,  553,  553,  555,  555,  555,  555,  555,
-      555,  555,  555,  555,  555,  555,  555,  555,  555,  555,
-      555,  555,  555,  555,  555,  555,  555,  555,  555,  555,
-      555,  555,  555,  555,  555,  555,  555,  555,  555,  555,
-      555,  555,  555,  555,  555,  555,  555,  555,  555,  555,
-      555,  555,  555,  555,  555,  555,  555,  199,  555,  555,
-
-      555,  555,  555,  555,  555,  555,  555,  555,  555,  555,
-      555,  555,  555,  555,  555,  555,  555,  555,  555,  555,
-      555,  555,  555,  555,  555,  555,  555,  553,  555,  555,
-      555,  555,  555,  555,  555,  555,  555,  555,  555,  555,
-      555,  555,  555,  555,  555,  555,  555,  555,  555,  555,
-      555,  555,  555,  555,  555,  555,  555,  555,  555,  555,
-      555,  555,  555,  555,  555,  555,  555,  555,  555,  555,
-      555,  555,  555,  555,  555,  555,  555,  555,  555,  555,
-      555,  555,  555,  555,  555,  555,  555,  555,  555,  555,
-      555,  555,  555,  555,  555,  555,  555,  555,  555,  555,
-
-      555,  555,  555,  555,  555,  555,  555,  555,  555,  555,
-      555,  555,  555,  555,  555,  555,  555,  555,  555,  555,
-      555,  555,  555,  555,  555,  555,  555,  555,  555,  555,
-      555,  555,  555,  555,  555,  555,  555,  555,  555,  555,
-      555,  555,  555,  555,  555,  555,  555,  555,  555,  555,
-      555,  555,  555,  555,  555,  555,  555,  555,  555,  555,
-      555,  555,  555,  555,  555,  555,  555,  555,  555,  555,
-      555,  555,  555,  555,  555,  555,  555,  555,  555,  555,
-      555,  555,  555,  555,  555,  555,  555,  555,  555,  555,
-      555,  555,  555,  555,  555,  555,  555,  555,  555,  555,
-
-      555,  555,  555,  555,  555,  555,  555,  555,  555,  555,
-      555,  555,  555,  555,  555,  555,  555,  555,  555,  555,
-      555,  555,  555,  555,  555,  555,  555,  555,  555,  555,
-      555,  555,  555,  555,  555,  555,  555,  555,  555,  555,
-      555,  555,  555,  555,  555,  555,  555,  555,  555,  555,
-      555,  555,    0,  553,  553,  553,  553,  553
+      535,    1,  535,  535,  535,  535,  536,  537,  538,  535,
+      537,  537,  537,  537,  539,  537,  537,  537,  537,  537,
+      537,  537,  537,  537,  537,  537,  537,  537,  537,  537,
+      537,  537,  537,  537,  537,  537,  537,  536,  535,  537,
+      535,  540,  540,  535,  535,  537,  537,  537,  537,  537,
+      539,  537,  537,  537,  537,  537,  537,  537,  537,  537,
+      537,  537,  537,  537,  537,  537,  537,  537,  537,  537,
+      537,  537,  537,  537,  537,  537,  537,  537,  537,   24,
+      537,  537,  537,  537,  537,  537,  537,  537,  537,  537,
+      537,  537,  537,  537,  537,  537,  537,  537,  537,  537,
+
+      537,  537,  537,  537,  537,  537,  537,  537,  537,  537,
+      537,  537,  537,  537,  537,  537,  537,  537,  537,  537,
+      537,  537,  537,  537,  537,  537,  537,  537,  537,  535,
+      540,  540,  535,  537,  537,  537,   50,  537,  537,  537,
+      537,  537,  537,  537,  537,  537,  537,  537,  537,  537,
+      537,  537,  537,  537,  537,  537,  537,  537,  537,  537,
+      537,  537,  537,  537,  537,  537,  537,  537,  537,  537,
+      537,  537,  537,  537,  537,  537,  537,  537,  537,  537,
+      537,  537,  537,  537,  537,  537,  537,  537,  537,  537,
+      537,  537,  537,  537,   50,  537,  537,  537,  537,  537,
+
+      537,  537,  537,  537,  537,  537,  537,  537,  537,  537,
+      537,  537,  537,  537,  537,  537,  537,  537,  537,  537,
+      537,  537,  537,  537,  537,  537,  537,  537,  537,  537,
+      537,  537,  537,  537,  537,  537,  537,  535,  535,  535,
+      535,  537,  537,  537,  537,  537,  537,  537,  537,  537,
+      537,  537,  537,  537,  537,  537,  537,  537,  537,  537,
+      537,  537,  537,  537,  537,  537,  537,  537,  537,  537,
+      537,  537,  537,  537,  537,  537,  537,  537,  537,  537,
+      537,  537,  537,  537,  537,  537,  537,  537,  537,  537,
+      195,  537,  537,  537,  537,  537,  537,  537,  537,  537,
+
+      537,  537,  537,  537,  537,  537,  537,  537,  537,  537,
+      537,  537,  537,  537,  537,  537,  537,  537,  537,  537,
+      535,  537,  537,  537,  537,  537,  537,  537,  537,  537,
+      537,  537,  537,  537,  537,  537,  537,  537,  537,  537,
+      537,  537,  537,  537,  537,  537,  537,  537,  537,  537,
+      537,  537,  537,  537,  537,  537,  537,  537,  537,  537,
+      537,  537,  537,  537,  537,  537,  537,  537,  537,  537,
+      537,  537,  537,  537,  537,  537,  537,  537,  537,  537,
+      537,  537,  537,  537,  537,  537,  537,  537,  537,  537,
+      537,  537,  537,  537,  537,  537,  537,  537,  537,  537,
+
+      537,  537,  537,  537,  537,  537,  537,  537,  537,  537,
+      537,  537,  537,  537,  537,  537,  537,  537,  537,  537,
+      537,  537,  537,  537,  537,  537,  537,  537,  537,  537,
+      537,  537,  537,  537,  537,  537,  537,  537,  537,  537,
+      537,  537,  537,  537,  537,  537,  537,  537,  537,  537,
+      537,  537,  537,  537,  537,  537,  537,  537,  537,  537,
+      537,  537,  537,  537,  537,  537,  537,  537,  537,  537,
+      537,  537,  537,  537,  537,  537,  537,  537,  537,  537,
+      537,  537,  537,  537,  537,  537,  537,  537,  537,  537,
+      537,  537,  537,  537,  537,  537,  537,  537,  537,  537,
+
+      537,  537,  537,  537,  537,  537,  537,  537,  537,  537,
+      537,  537,  537,  537,  537,  537,  537,  537,  537,  537,
+      537,  537,  537,  537,  537,  537,  537,  537,  537,  537,
+      537,  537,  537,  537,    0,  535,  535,  535,  535,  535
     } ;
 
-static yyconst short int yy_nxt[1245] =
+static yyconst short int yy_nxt[1209] =
     {   0,
         4,    5,    6,    7,    8,    9,   10,   11,   12,   13,
        14,   14,   14,    4,   15,    8,    8,    8,   16,   17,
        18,   19,   20,   21,   22,   23,   24,    8,   25,   26,
        27,   28,   29,    8,   30,   31,   32,   33,   34,   35,
        36,    8,   37,   43,   41,   44,   44,   44,   44,   45,
-       45,   45,   45,   46,   46,   46,   46,   41,   47,  149,
-       41,   41,   41,   41,   48,   49,   49,   49,   49,   41,
-       48,   49,   49,   49,   49,   41,   41,   68,  135,   41,
-       69,   41,  153,   41,   52,  154,   41,   70,   57,  139,
-       41,   53,   58,   54,   41,   55,   50,  146,   56,   60,
+       45,   45,   45,   46,   46,   46,   46,   41,   47,   41,
+       41,  177,   41,   41,   48,   49,   49,   49,   49,   41,
+       48,   49,   49,   49,   49,   41,   41,   68,  134,   41,
+       69,   41,  146,   41,   52,   41,  157,   70,   57,  138,
+       41,   53,   58,   54,   41,   55,   50,   99,   56,   60,
 
-       59,   61,   41,   79,   41,   41,   41,   64,  132,   42,
+       59,   61,   41,   79,   41,   41,   41,   64,  100,   41,
        84,   65,   62,   77,   41,   91,   63,   66,   85,   78,
-       67,   41,   41,   86,   41,   41,   71,   87,   72,   73,
-       92,  102,   41,  127,  130,   41,   74,   88,  159,   41,
-       75,   41,   76,   80,   80,   80,   80,   41,   41,  142,
-       89,   99,   41,  125,   81,  187,   90,  100,  128,   41,
-       41,  169,  101,   82,   83,   41,  126,   41,  133,  133,
-      133,  133,  114,  140,   93,  141,   94,  129,   41,   41,
-       95,   41,   96,   41,   97,  115,   98,  103,  116,   41,
-      150,   41,  248,   41,  151,  117,  152,  143,   41,  104,
-
-      105,  144,  106,  107,  108,  145,  109,   44,   44,   44,
-       44,   41,  110,  158,  111,  112,  161,  113,  103,  160,
-       41,   41,   41,  134,   45,   45,   45,   45,   41,   41,
-      118,  119,  234,  120,  165,  121,  164,  122,   41,  123,
-       41,   41,   41,  124,   48,   46,   46,   46,   46,   41,
-      136,  136,  136,  136,   41,  162,  166,  137,  173,  171,
-       41,   41,  163,  137,   48,   49,   49,   49,   49,   41,
-      138,  138,  138,  138,   41,   41,  138,  138,   41,  138,
-      138,  138,  138,  138,  138,  155,  147,   41,  156,   41,
-       41,   41,   40,   41,   41,   41,  167,  157,  148,  172,
-
-      178,   40,   40,   41,   41,   41,   41,  182,   41,  174,
-      168,  181,  170,  184,   41,  175,  176,   41,  177,  183,
-      179,   41,   41,  185,   41,  194,  180,   41,   41,  186,
-      188,  190,  193,  192,   41,   41,   41,   41,   41,   41,
-       41,  195,   41,   41,  189,  191,  201,  196,   41,  204,
-      208,  200,   41,   41,  202,   41,  197,  210,  206,  198,
-       41,  212,   41,  205,  199,  209,  203,  207,  214,   41,
-       41,  211,   41,  213,   41,   41,  225,   41,   41,  220,
-       41,   41,  215,  216,   41,  218,  223,  221,   41,  226,
-      233,  217,  228,  229,   41,  222,  219,   41,   41,   41,
-
-      224,  252,  230,  227,  237,  231,  238,  235,   41,  236,
-      232,  133,  133,  133,  133,   41,   41,   41,  239,  240,
-      243,  243,  243,  243,   41,  241,  250,  244,   41,   41,
-      254,  259,   41,  244,  136,  136,  136,  136,   41,  253,
-       41,  137,  249,  261,   41,   41,   41,  137,  245,  246,
-      251,  247,  247,  247,  247,   41,   41,   41,   41,  260,
-       41,   41,  256,  258,  255,   41,  257,  264,   41,  262,
-       41,   41,   41,  263,   41,   41,   41,  266,  265,   41,
-      272,   41,   41,   41,   41,   41,   41,   41,  279,  267,
-      278,  270,  268,  280,  269,  276,   41,  274,  282,  271,
-
-      275,   41,  277,  273,   41,  283,  281,   41,   41,   41,
-      284,   41,   41,   41,   41,   41,  287,   41,   41,  290,
-       41,   41,  286,  288,  285,   41,   41,   41,  292,   41,
-      294,  289,   41,  291,   41,  296,  309,  295,  293,  303,
-       41,  301,   41,  297,  298,  298,  298,  298,  300,  302,
-      298,  298,  299,  298,  298,  298,  298,  298,  298,   41,
-      305,   41,   41,  308,   41,   41,   41,   41,  304,   41,
-       41,   41,   41,   41,   41,  310,  314,  306,  312,   41,
-      317,  318,   41,  307,  311,   41,  313,  319,  316,  320,
-      321,  315,   41,   41,   41,   41,  324,  326,  323,  325,
-
-      322,  243,  243,  243,  243,   41,  245,  245,  244,  328,
-      328,  328,  328,  390,  244,   41,   41,  327,  328,  328,
-      328,  328,  247,  247,  247,  247,   41,  247,  247,  247,
-      247,   41,  329,   41,   41,   41,   41,   41,   41,  335,
-      330,  333,   41,   41,  334,   41,   41,   41,  338,   41,
-       41,  331,  332,   41,   41,  344,   41,  337,   41,  340,
-       41,  336,  339,  346,   41,  342,   41,   41,  343,  347,
-       41,  348,   41,   41,  341,  345,   41,   41,  355,  349,
-       41,   41,   41,   41,   41,  356,  357,  354,   41,  350,
-       41,  353,  351,   41,  352,   41,   41,  361,   41,  362,
-
-      360,  358,  359,   41,   41,  364,  363,   41,   41,   41,
-      366,  365,   41,   41,  371,   41,  370,   41,  372,  374,
-      367,  368,  369,   41,  373,   41,  375,  378,   41,   41,
-      376,   41,   41,   41,  377,  379,   41,  382,   41,  380,
-       41,  381,   41,  328,  328,  328,  328,   41,   41,   41,
-      383,   41,  386,  388,  389,  392,  393,  384,   41,   41,
-       41,  385,   41,   41,  387,  394,  398,  395,   41,  391,
-       41,   41,  397,   41,   41,   41,   41,   41,   41,   41,
-      396,   41,  401,  404,  405,   41,   41,  399,  402,  400,
-       41,  403,  406,   41,  407,  408,   41,   41,  413,  409,
-
-      410,   41,   41,  411,   41,   41,   41,   41,   41,  412,
-      416,  419,   41,  414,  418,  420,  415,  421,   41,  417,
-      423,  422,   41,   41,   41,   41,   41,   41,   41,   41,
-       41,   41,   41,   41,  427,   41,  424,  431,  426,  429,
-      433,  435,   41,  434,  428,  425,   41,   41,  432,  430,
-       41,  437,   41,   41,  438,  436,   41,   41,   41,   41,
-      444,   41,   41,  440,  439,  443,  445,   41,   41,   41,
-      442,  449,  450,   41,   41,  441,  452,  447,  446,  448,
-       41,   41,  454,  455,  453,  451,  456,   41,   41,   41,
-       41,   41,   41,   41,  458,   41,   41,   41,   41,   41,
-
-      462,   41,  463,  457,   41,  464,  460,  461,   41,  459,
-      465,  468,  467,   41,  469,   41,   41,   41,  466,  471,
-       41,   41,  470,   41,   41,   41,  476,   41,   41,  472,
-      477,  475,   41,   41,  473,   41,  482,  478,  479,  480,
-       41,  474,   41,   41,  486,  487,  481,   41,   41,   41,
-      483,  488,   41,   41,  490,  484,   41,   41,  485,   41,
-      492,   41,  496,   41,   41,   41,  489,   41,   41,   41,
-       41,  491,  503,  500,  497,   41,  493,   41,  498,  494,
-      495,  501,   41,  504,  502,   41,  499,   41,   41,  505,
-      506,   41,  508,  509,   41,   41,   41,   41,   41,  514,
-
-      507,  512,   41,  510,  515,   41,   41,   41,   41,   41,
-      518,  513,   41,  520,  511,   41,   41,  517,   41,   41,
-      521,  516,  519,   41,   41,  522,   41,  525,  526,   41,
-       41,  523,  528,  532,   41,   41,   41,   41,  524,  527,
-       41,  529,   41,   41,  530,  531,   41,  538,  534,   41,
-       41,   41,   41,  535,   41,  536,   41,  533,  537,  539,
-       41,  545,   41,  541,   41,   41,  540,  546,  542,   41,
-       41,   41,  550,  544,  543,   41,   41,   41,  551,  549,
-       41,   41,   41,   41,   41,  547,   41,  548,   41,   41,
-       41,  552,   38,   38,   38,   38,   40,   40,   51,   41,
-
-       51,   51,   41,   41,   41,   41,   41,   41,   41,   41,
+       67,   41,   41,   86,  147,  145,   71,   87,   72,   73,
+       92,  101,   41,   41,   41,   41,   74,   88,  124,  113,
+       75,   41,   76,   80,   80,   80,   80,   41,   41,  141,
+       89,  125,  114,   41,   81,  115,   90,  126,  127,   41,
+       41,  460,  116,   82,   83,   41,  139,   41,  140,  129,
+      132,  132,  132,  132,   93,   41,   94,  128,   41,  143,
+       95,   41,   96,  144,   97,   41,   98,  102,  148,   41,
+       41,   41,   44,   44,   44,   44,  151,  142,  163,  103,
+
+      104,   41,  105,  106,  107,  162,  108,  133,   45,   45,
+       45,   45,  109,  152,  110,  111,  156,  112,  102,   41,
+       41,   41,   41,   48,   46,   46,   46,   46,   41,  158,
+      117,  118,   41,  119,  149,  120,  150,  121,  164,  122,
+       41,   41,   41,  123,  135,  135,  135,  135,   41,  167,
+      170,  136,   41,  179,  131,  159,  230,  136,   48,   49,
+       49,   49,   49,   41,  137,  137,  137,  137,   41,   41,
+      137,  137,   41,  137,  137,  137,  137,  137,  137,  153,
+       41,   41,  154,   41,   40,   41,   41,   41,   42,   41,
+      165,  155,  168,   40,   40,  160,   41,  181,   41,   41,
+
+       41,  169,  161,  171,  166,  172,  176,  173,  174,   41,
+      175,  180,   41,  182,  178,   41,   41,   41,   41,  184,
+       41,   41,   41,  190,  185,  187,  189,  183,  191,   41,
+       41,   41,   41,   41,  192,   41,   41,   41,  186,  188,
+      197,  200,   41,  193,  196,   41,  208,   41,  198,   41,
+      202,  206,  194,  204,  209,  201,   41,  195,   41,  203,
+      199,   41,  210,   41,   41,  207,  216,   41,  205,  218,
+       41,  211,   41,   41,  212,   41,  214,  217,  233,  219,
+       41,  222,  213,  234,  229,   41,   41,  215,  224,  225,
+      221,   41,   41,  220,   41,  223,   41,  244,  226,   41,
+
+       41,  227,   41,   41,   41,  231,  228,  232,  132,  132,
+      132,  132,  235,  246,  245,  236,  239,  239,  239,  239,
+      247,  237,   41,  240,  252,   41,   41,  268,   41,  240,
+      135,  135,  135,  135,   41,  248,  251,  136,   41,   41,
+      250,  255,   41,  136,  241,  242,  249,  243,  243,  243,
+      243,   41,   41,   41,   41,  256,   41,   41,  254,   41,
+      263,  253,  260,   41,   41,   41,  258,   41,  261,  257,
+      259,   41,  267,   41,   41,   41,   41,   41,   41,   41,
+      262,   41,  273,  265,  271,  274,  264,   41,   41,  269,
+      266,  272,  270,  276,   41,  275,  277,  278,   41,   41,
+
+       41,   41,   41,  279,   41,   41,   41,   41,  282,  284,
+       41,   41,   41,   41,  283,   41,  281,  280,   41,  286,
+      294,  288,  296,  285,  297,  323,   41,  289,   41,  287,
+       41,   41,   41,  290,  291,  291,  291,  291,  292,   41,
+      291,  291,   41,  291,  291,  291,  291,  291,  291,  293,
+      298,  295,  300,  301,   41,  299,   41,  302,   41,   41,
+       41,   41,   41,   41,   41,  303,   41,  307,  305,   41,
+       41,  310,  311,   41,  314,  304,  306,  312,  315,  309,
+       41,   41,  313,   41,  318,  308,  316,  317,   41,  239,
+      239,  239,  239,   41,  241,  241,  240,  321,  321,  321,
+
+      321,  319,  240,  321,  321,  321,  321,   41,   41,   41,
+      322,  320,  243,  243,  243,  243,   41,  243,  243,  243,
+      243,   41,   41,   41,  324,  325,   41,  326,   41,   41,
+      327,   41,  328,   41,  331,   41,   41,   41,   41,   41,
+       41,   41,   41,  330,  338,   41,  333,  340,  332,  329,
+      339,   41,  335,  336,   41,   41,   41,   41,  337,   41,
+       41,  347,  334,   41,   41,  341,  348,   41,  342,  349,
+      346,   41,   41,  343,   41,  344,   41,   41,  345,   41,
+      350,  353,  352,   41,  351,   41,  354,   41,   41,   41,
+      355,  357,  356,   41,  361,  362,  360,  359,  363,   41,
+
+       41,  358,   41,  364,   41,   41,   41,  366,  365,   41,
+       41,  367,  369,   41,  372,   41,  370,   41,   41,  368,
+      371,   41,   41,  321,  321,  321,  321,   41,   41,   41,
+      373,  376,  379,   41,   41,  378,  374,  380,  383,   41,
+      375,  382,   41,  377,   41,   41,  384,  385,   41,   41,
+      381,   41,   41,   41,  387,  388,   41,   41,   41,   41,
+      393,  391,   41,   41,  394,  386,   41,  389,   41,   41,
+      390,  395,  396,  392,   41,  398,   41,   41,  399,  397,
+       41,   41,   41,   41,   41,  400,   41,   41,   41,  405,
+      401,  407,  402,  403,   41,  408,  404,  409,  406,   41,
+
+      410,  411,   41,   41,   41,  412,   41,   41,   41,  413,
+       41,   41,  414,   41,   41,  416,  418,  420,  415,  421,
+       41,  423,   41,   41,  422,  419,   41,  417,  424,   41,
+       41,   41,   41,  427,   41,   41,   41,  425,  430,  426,
+       41,  432,   41,   41,  436,  437,  429,   41,   41,  428,
+      439,   41,   41,  434,  435,   41,  433,  441,  431,   41,
+      442,   41,  445,  440,  443,  438,   41,   41,   41,   41,
+       41,   41,   41,   41,   41,  444,  448,   41,  446,  449,
+      450,  453,   41,  447,   41,  451,   41,  454,   41,  455,
+       41,   41,   41,  452,   41,   41,   41,  462,   41,   41,
+
+      456,  463,  457,  458,   41,  461,   41,  459,  464,  465,
+      466,   41,   41,  468,   41,  471,  472,  467,   41,   41,
+       41,  469,   41,  473,  470,  475,   41,   41,   41,   41,
+       41,  477,   41,   41,   41,  474,   41,  481,   41,   41,
+      487,   41,  476,  485,  482,  486,  478,  483,   41,  479,
+      480,   41,   41,   41,  488,  484,   41,  490,  489,   41,
+       41,  492,  495,   41,  493,  494,  491,   41,  496,   41,
+       41,   41,   41,   41,  498,   41,  497,  501,  503,   41,
+       41,   41,   41,   41,   41,  500,  502,   41,   41,  504,
+       41,  508,  499,  510,   41,  505,   41,   41,   41,  506,
+
+       41,   41,  511,  512,  507,  513,  509,  514,   41,  516,
+       41,   41,   41,   41,  517,  520,  519,  515,  518,   41,
+       41,   41,   41,  521,   41,   41,   41,   41,  522,  527,
+       41,  524,  528,  523,  532,   41,   41,   41,   41,  533,
+       41,  526,  525,  531,   41,   41,   41,  530,   41,   41,
+      529,   41,   41,   41,   41,   41,  534,   38,   38,   38,
+       38,   40,   40,   51,   41,   51,   51,   41,   41,   41,
        41,   41,   41,   41,   41,   41,   41,   41,   41,   41,
        41,   41,   41,   41,   41,   41,   41,   41,   41,   41,
        41,   41,   41,   41,   41,   41,   41,   41,   41,   41,
+
        41,   41,   41,   41,   41,   41,   41,   41,   41,   41,
        41,   41,   41,   41,   41,   41,   41,   41,   41,   41,
        41,   41,   41,   41,   41,   41,   41,   41,   41,   41,
        41,   41,   41,   41,   41,   41,   41,   41,   41,   41,
        41,   41,   41,   41,   41,   41,   41,   41,   41,   41,
-      242,   41,   41,   41,   41,   41,  131,   41,   39,  553,
+       41,   41,   41,   41,  238,   41,   41,   41,   41,   41,
+      130,   41,   39,  535,    3,  535,  535,  535,  535,  535,
+      535,  535,  535,  535,  535,  535,  535,  535,  535,  535,
+      535,  535,  535,  535,  535,  535,  535,  535,  535,  535,
+      535,  535,  535,  535,  535,  535,  535,  535,  535,  535,
 
-        3,  553,  553,  553,  553,  553,  553,  553,  553,  553,
-      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
-      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
-      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
-      553,  553,  553,  553
+      535,  535,  535,  535,  535,  535,  535,  535
     } ;
 
-static yyconst short int yy_chk[1245] =
+static yyconst short int yy_chk[1209] =
     {   0,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    9,   60,    9,    9,    9,    9,   10,
-       10,   10,   10,   11,   11,   11,   11,   11,   12,   60,
-       20,   63,   64,   12,   13,   13,   13,   13,   13,   13,
+        1,    1,    1,    9,   85,    9,    9,    9,    9,   10,
+       10,   10,   10,   11,   11,   11,   11,   11,   12,   58,
+       20,   85,   67,   12,   13,   13,   13,   13,   13,   13,
        14,   14,   14,   14,   14,   14,   16,   20,   47,   17,
-       20,   52,   63,   47,   16,   64,   57,   20,   17,   52,
-       23,   16,   17,   16,   18,   16,   13,   57,   16,   18,
+       20,   52,   58,   47,   16,   29,   67,   20,   17,   52,
+       23,   16,   17,   16,   18,   16,   13,   29,   16,   18,
+
+       17,   18,   19,   23,   22,   25,   27,   19,   29,   60,
+       25,   19,   18,   22,   57,   27,   18,   19,   25,   22,
+       19,   21,   30,   25,   60,   57,   21,   25,   21,   21,
+       27,   30,   26,   34,   32,  436,   21,   26,   34,   32,
+       21,   54,   21,   24,   24,   24,   24,   24,   35,   54,
+       26,   34,   32,   53,   24,   32,   26,   35,   36,   36,
+       37,  436,   32,   24,   24,   28,   53,   56,   53,   37,
+       43,   43,   43,   43,   28,   63,   28,   36,   55,   56,
+       28,   61,   28,   56,   28,   73,   28,   31,   61,   72,
+       64,   31,   44,   44,   44,   44,   63,   55,   73,   31,
+
+       31,   66,   31,   31,   31,   72,   31,   45,   45,   45,
+       45,   45,   31,   64,   31,   31,   66,   31,   33,   62,
+       74,   68,   33,   46,   46,   46,   46,   46,   46,   68,
+       33,   33,   70,   33,   62,   33,   62,   33,   74,   33,
+       76,   87,   79,   33,   48,   48,   48,   48,   48,   76,
+       79,   48,  124,   87,  540,   70,  124,   48,   49,   49,
+       49,   49,   49,   49,   50,   50,   50,   50,   50,   77,
+       50,   50,   65,   50,   50,   50,   50,   50,   50,   65,
+       71,   75,   65,   78,   80,   83,   82,   81,  538,   89,
+       75,   65,   77,   80,   80,   71,   88,   89,   90,   93,
+
+       84,   78,   71,   81,   75,   82,   84,   83,   83,   86,
+       83,   88,   92,   90,   86,   94,   95,   96,   97,   93,
+       98,   99,  100,   97,   94,   95,   96,   92,   98,  101,
+      102,  103,  105,  104,   99,  106,  110,  109,   94,   95,
+      104,  105,  108,  100,  103,  107,  109,  116,  104,  118,
+      106,  108,  101,  107,  110,  105,  111,  102,  112,  106,
+      104,  113,  111,  115,  117,  108,  116,  120,  107,  118,
+      119,  112,  121,  126,  113,  123,  115,  117,  126,  119,
+      122,  121,  113,  127,  123,  127,  139,  115,  122,  122,
+      120,  128,  125,  119,  129,  121,  140,  139,  122,  143,
+
+      165,  122,  150,  534,  142,  125,  122,  125,  132,  132,
+      132,  132,  128,  142,  140,  129,  133,  133,  133,  133,
+      143,  129,  145,  133,  150,  147,  153,  165,  149,  133,
+      135,  135,  135,  135,  135,  145,  149,  135,  160,  146,
+      147,  153,  154,  135,  136,  136,  146,  136,  136,  136,
+      136,  136,  151,  152,  155,  154,  157,  156,  152,  159,
+      160,  151,  157,  161,  162,  163,  156,  164,  159,  155,
+      156,  166,  164,  168,  171,  167,  532,  531,  530,  169,
+      159,  172,  168,  162,  167,  169,  161,  170,  173,  166,
+      163,  167,  166,  171,  174,  170,  172,  173,  175,  176,
+
+      177,  178,  179,  174,  180,  181,  183,  190,  176,  178,
+      193,  198,  203,  196,  177,  204,  175,  174,  245,  180,
+      198,  183,  203,  179,  204,  245,  197,  190,  199,  181,
+      211,  209,  205,  193,  195,  195,  195,  195,  196,  208,
+      195,  195,  212,  195,  195,  195,  195,  195,  195,  197,
+      205,  199,  209,  211,  213,  208,  214,  212,  216,  215,
+      217,  221,  224,  227,  228,  213,  229,  216,  215,  230,
+      231,  224,  227,  233,  230,  214,  215,  228,  231,  221,
+      234,  232,  229,  236,  234,  217,  232,  233,  237,  239,
+      239,  239,  239,  244,  240,  240,  239,  240,  240,  240,
+
+      240,  236,  239,  241,  241,  241,  241,  246,  248,  252,
+      244,  237,  242,  242,  242,  242,  242,  243,  243,  243,
+      243,  243,  249,  251,  246,  248,  253,  249,  254,  255,
+      251,  256,  252,  257,  255,  258,  259,  261,  260,  262,
+      264,  263,  267,  254,  262,  268,  257,  264,  256,  253,
+      263,  269,  259,  260,  270,  273,  274,  275,  261,  278,
+      277,  274,  258,  279,  280,  267,  275,  281,  268,  277,
+      273,  282,  283,  269,  286,  269,  287,  289,  270,  290,
+      278,  281,  280,  293,  279,  296,  282,  294,  528,  297,
+      283,  287,  286,  298,  294,  296,  293,  290,  297,  300,
+
+      301,  289,  303,  298,  304,  306,  309,  301,  300,  311,
+      310,  303,  306,  312,  311,  314,  309,  316,  526,  304,
+      310,  318,  319,  321,  321,  321,  321,  323,  326,  324,
+      312,  318,  323,  328,  327,  319,  314,  324,  328,  329,
+      316,  327,  330,  318,  331,  332,  329,  330,  334,  333,
+      326,  335,  336,  338,  332,  333,  337,  340,  343,  344,
+      338,  336,  345,  347,  340,  331,  346,  334,  348,  350,
+      335,  343,  344,  337,  349,  346,  351,  352,  347,  345,
+      353,  355,  361,  360,  356,  348,  357,  359,  358,  353,
+      349,  356,  350,  351,  362,  357,  352,  358,  355,  364,
+
+      359,  360,  363,  366,  367,  361,  370,  368,  375,  362,
+      372,  373,  363,  374,  377,  366,  368,  372,  364,  373,
+      380,  375,  378,  376,  374,  370,  381,  367,  376,  383,
+      385,  384,  386,  380,  388,  389,  390,  377,  384,  378,
+      392,  386,  393,  397,  392,  392,  383,  398,  401,  381,
+      397,  402,  404,  389,  390,  406,  388,  401,  385,  403,
+      402,  410,  406,  398,  403,  393,  411,  413,  420,  414,
+      423,  424,  427,  425,  426,  404,  413,  429,  410,  414,
+      420,  425,  434,  411,  431,  423,  435,  426,  438,  427,
+      437,  441,  440,  424,  442,  443,  444,  438,  446,  448,
+
+      429,  440,  431,  434,  445,  437,  449,  435,  441,  442,
+      443,  450,  452,  445,  451,  449,  450,  444,  453,  454,
+      455,  446,  457,  451,  448,  453,  458,  459,  460,  462,
+      463,  455,  464,  471,  465,  452,  470,  460,  478,  483,
+      471,  525,  454,  465,  462,  470,  457,  463,  472,  458,
+      459,  474,  475,  476,  472,  464,  482,  475,  474,  481,
+      485,  478,  483,  484,  481,  482,  476,  486,  484,  487,
+      488,  490,  489,  491,  486,  493,  485,  489,  491,  494,
+      495,  496,  497,  498,  500,  488,  490,  501,  502,  493,
+      503,  497,  487,  500,  506,  494,  507,  508,  505,  495,
+
+      509,  511,  501,  502,  496,  503,  498,  505,  512,  507,
+      513,  514,  515,  516,  508,  512,  511,  506,  509,  517,
+      518,  521,  519,  513,  522,  520,  524,  527,  514,  519,
+      529,  516,  520,  515,  527,  533,  523,  510,  504,  529,
+      499,  518,  517,  524,  492,  480,  479,  522,  477,  473,
+      521,  469,  468,  467,  466,  461,  533,  536,  536,  536,
+      536,  537,  537,  539,  456,  539,  539,  447,  439,  433,
+      432,  430,  428,  422,  421,  419,  418,  417,  416,  415,
+      412,  409,  408,  407,  405,  400,  399,  396,  395,  394,
+      391,  387,  382,  379,  371,  369,  365,  354,  342,  341,
+
+      339,  325,  322,  320,  317,  315,  313,  308,  307,  305,
+      302,  299,  295,  292,  288,  285,  284,  276,  272,  271,
+      266,  265,  250,  247,  235,  226,  225,  223,  222,  220,
+      219,  218,  210,  207,  206,  202,  201,  200,  194,  192,
+      191,  189,  188,  187,  186,  185,  184,  182,  158,  148,
+      144,  141,  138,  134,  130,  114,   91,   69,   59,   40,
+       38,    8,    7,    3,  535,  535,  535,  535,  535,  535,
+      535,  535,  535,  535,  535,  535,  535,  535,  535,  535,
+      535,  535,  535,  535,  535,  535,  535,  535,  535,  535,
+      535,  535,  535,  535,  535,  535,  535,  535,  535,  535,
 
-       17,   18,   19,   23,   22,   25,   27,   19,  558,  556,
-       25,   19,   18,   22,   67,   27,   18,   19,   25,   22,
-       19,   21,   30,   25,   35,   37,   21,   25,   21,   21,
-       27,   30,   26,   35,   37,   93,   21,   26,   67,   29,
-       21,   54,   21,   24,   24,   24,   24,   24,   34,   54,
-       26,   29,   76,   34,   24,   93,   26,   29,   36,   36,
-       53,   76,   29,   24,   24,   28,   34,   32,   43,   43,
-       43,   43,   32,   53,   28,   53,   28,   36,   55,   62,
-       28,  140,   28,   61,   28,   32,   28,   31,   32,   56,
-       61,   31,  140,   70,   62,   32,   62,   55,   66,   31,
-
-       31,   56,   31,   31,   31,   56,   31,   44,   44,   44,
-       44,   68,   31,   66,   31,   31,   70,   31,   33,   68,
-       72,   73,   33,   45,   45,   45,   45,   45,  125,  552,
-       33,   33,  125,   33,   73,   33,   72,   33,   74,   33,
-       71,   78,   81,   33,   46,   46,   46,   46,   46,   46,
-       48,   48,   48,   48,   48,   71,   74,   48,   81,   78,
-      550,  549,   71,   48,   49,   49,   49,   49,   49,   49,
-       50,   50,   50,   50,   50,   58,   50,   50,   65,   50,
-       50,   50,   50,   50,   50,   65,   58,   75,   65,   77,
-       82,   79,   80,   83,   84,   87,   75,   65,   58,   79,
-
-       84,   80,   80,   85,   88,   89,   86,   87,   90,   82,
-       75,   86,   77,   89,   92,   83,   83,   98,   83,   88,
-       85,   94,   95,   90,   96,   98,   85,   97,   99,   92,
-       94,   95,   97,   96,  100,  101,  102,  103,  104,  105,
-      106,   99,  108,  107,   94,   95,  105,  100,  109,  106,
-      108,  104,  110,  121,  105,  111,  101,  109,  107,  102,
-      117,  110,  112,  106,  103,  108,  105,  107,  112,  113,
-      114,  109,  116,  111,  118,  119,  121,  120,  548,  117,
-      122,  124,  113,  114,  123,  116,  120,  118,  146,  122,
-      124,  114,  123,  123,  126,  119,  116,  129,  130,  127,
-
-      120,  146,  123,  122,  127,  123,  128,  126,  128,  126,
-      123,  133,  133,  133,  133,  149,  155,  143,  129,  130,
-      134,  134,  134,  134,  141,  130,  143,  134,  157,  144,
-      149,  155,  148,  134,  136,  136,  136,  136,  136,  148,
-      152,  136,  141,  157,  546,  544,  156,  136,  137,  137,
-      144,  137,  137,  137,  137,  137,  151,  153,  154,  156,
-      158,  159,  152,  154,  151,  160,  153,  159,  161,  158,
-      162,  163,  164,  158,  165,  166,  167,  161,  160,  168,
-      166,  170,  171,  174,  543,  172,  169,  173,  171,  161,
-      170,  164,  162,  172,  163,  169,  175,  168,  174,  165,
-
-      168,  176,  169,  167,  177,  175,  173,  178,  180,  179,
-      176,  181,  182,  183,  184,  186,  178,  193,  196,  181,
-      197,  216,  177,  179,  176,  201,  203,  200,  183,  207,
-      186,  180,  202,  182,  541,  196,  216,  193,  184,  207,
-      215,  202,  209,  197,  199,  199,  199,  199,  201,  203,
-      199,  199,  200,  199,  199,  199,  199,  199,  199,  208,
-      209,  212,  213,  215,  217,  218,  221,  220,  208,  219,
-      225,  228,  231,  233,  232,  217,  220,  212,  219,  240,
-      228,  231,  237,  213,  218,  234,  219,  232,  225,  233,
-      234,  221,  235,  236,  241,  238,  237,  240,  236,  238,
-
-      235,  243,  243,  243,  243,  331,  244,  244,  243,  244,
-      244,  244,  244,  331,  243,  248,  256,  241,  245,  245,
-      245,  245,  246,  246,  246,  246,  246,  247,  247,  247,
-      247,  247,  248,  249,  250,  252,  253,  255,  257,  256,
-      249,  253,  258,  259,  255,  260,  261,  262,  259,  263,
-      265,  250,  252,  264,  266,  265,  272,  258,  267,  261,
-      268,  257,  260,  267,  269,  263,  273,  275,  264,  268,
-      274,  269,  278,  279,  262,  266,  280,  282,  279,  272,
-      283,  284,  285,  286,  287,  280,  282,  278,  288,  273,
-      289,  275,  274,  292,  274,  293,  295,  286,  296,  287,
-
-      285,  283,  284,  300,  297,  289,  288,  301,  303,  305,
-      293,  292,  311,  528,  301,  304,  300,  307,  303,  305,
-      295,  296,  297,  308,  304,  310,  307,  311,  313,  316,
-      308,  317,  318,  319,  310,  313,  321,  318,  323,  316,
-      326,  317,  325,  328,  328,  328,  328,  333,  334,  330,
-      319,  335,  325,  326,  330,  334,  335,  321,  336,  338,
-      340,  323,  337,  339,  325,  336,  340,  337,  341,  333,
-      342,  344,  339,  343,  345,  358,  346,  348,  353,  351,
-      338,  352,  343,  346,  348,  355,  356,  341,  344,  342,
-      354,  345,  351,  357,  352,  353,  359,  360,  358,  354,
-
-      355,  361,  363,  356,  365,  364,  366,  369,  367,  357,
-      361,  365,  368,  359,  364,  366,  360,  367,  370,  363,
-      369,  368,  371,  372,  373,  374,  377,  376,  378,  380,
-      384,  387,  395,  382,  373,  383,  370,  378,  372,  376,
-      382,  384,  385,  383,  374,  371,  386,  388,  380,  377,
-      390,  386,  391,  393,  387,  385,  398,  396,  394,  399,
-      395,  400,  404,  390,  388,  394,  396,  403,  409,  408,
-      393,  403,  403,  412,  413,  391,  408,  399,  398,  400,
-      415,  414,  412,  413,  409,  404,  414,  417,  422,  423,
-      424,  426,  427,  433,  417,  436,  437,  440,  439,  442,
-
-      426,  444,  427,  415,  438,  433,  423,  424,  447,  422,
-      436,  439,  438,  448,  440,  449,  450,  451,  437,  444,
-      454,  453,  442,  455,  456,  457,  451,  458,  459,  447,
-      453,  450,  460,  462,  448,  463,  458,  454,  455,  456,
-      464,  449,  465,  466,  463,  464,  457,  467,  468,  469,
-      459,  465,  471,  474,  467,  460,  472,  473,  462,  476,
-      469,  477,  474,  478,  479,  486,  466,  526,  483,  493,
-      501,  468,  486,  479,  476,  485,  471,  487,  477,  472,
-      473,  483,  489,  487,  485,  490,  478,  491,  496,  489,
-      490,  498,  493,  496,  497,  500,  499,  502,  503,  501,
-
-      491,  499,  504,  497,  502,  505,  509,  506,  507,  510,
-      505,  500,  511,  507,  498,  512,  515,  504,  513,  514,
-      509,  503,  506,  517,  522,  510,  518,  513,  514,  519,
-      520,  511,  517,  522,  523,  524,  525,  527,  512,  515,
-      530,  518,  533,  529,  519,  520,  531,  530,  524,  532,
-      534,  535,  536,  525,  537,  527,  539,  523,  529,  531,
-      538,  537,  542,  533,  540,  545,  532,  538,  534,  547,
-      551,  521,  545,  536,  535,  516,  508,  495,  547,  542,
-      494,  492,  488,  484,  482,  539,  481,  540,  480,  475,
-      470,  551,  554,  554,  554,  554,  555,  555,  557,  461,
-
-      557,  557,  452,  446,  445,  443,  441,  435,  434,  432,
-      431,  430,  429,  428,  425,  421,  420,  419,  418,  416,
-      411,  410,  407,  406,  405,  402,  401,  397,  392,  389,
-      381,  379,  375,  362,  350,  349,  347,  332,  329,  327,
-      324,  322,  320,  315,  314,  312,  309,  306,  302,  299,
-      294,  291,  290,  281,  277,  276,  271,  270,  254,  251,
-      239,  230,  229,  227,  226,  224,  223,  222,  214,  211,
-      210,  206,  205,  204,  198,  195,  194,  192,  191,  190,
-      189,  188,  187,  185,  150,  147,  145,  142,  139,  135,
-      131,  115,   91,   69,   59,   40,   38,    8,    7,    3,
-
-      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
-      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
-      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
-      553,  553,  553,  553,  553,  553,  553,  553,  553,  553,
-      553,  553,  553,  553
+      535,  535,  535,  535,  535,  535,  535,  535
     } ;
 
 static yy_state_type yy_state_buf[YY_BUF_SIZE + 2], *yy_state_ptr;
@@ -879,7 +859,7 @@
 #define YY_MORE_ADJ 0
 #define YY_RESTORE_YY_MORE_OFFSET
 char *yytext;
-#line 1 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 1 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 #define INITIAL 0
 /*===-- Lexer.l - Scanner for llvm assembly files --------------*- C++ -*--===//
 //
@@ -894,7 +874,7 @@
 //
 //===----------------------------------------------------------------------===*/
 #define YY_NEVER_INTERACTIVE 1
-#line 28 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 28 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 #include "ParserInternals.h"
 #include "llvm/Module.h"
 #include 
@@ -1027,7 +1007,7 @@
 /* HexIntConstant - Hexadecimal constant generated by the CFE to avoid forcing
  * it to deal with 64 bit numbers.
  */
-#line 1031 "Lexer.cpp"
+#line 1007 "Lexer.cpp"
 
 /* Macros after this point can all be overridden by user definitions in
  * section 1.
@@ -1175,13 +1155,13 @@
 YY_DECL
 	{
 	register yy_state_type yy_current_state;
-	register char *yy_cp = NULL, *yy_bp = NULL;
+	register char *yy_cp, *yy_bp;
 	register int yy_act;
 
-#line 188 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 188 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 
 
-#line 1185 "Lexer.cpp"
+#line 1161 "Lexer.cpp"
 
 	if ( yy_init )
 		{
@@ -1229,14 +1209,14 @@
 			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 				{
 				yy_current_state = (int) yy_def[yy_current_state];
-				if ( yy_current_state >= 554 )
+				if ( yy_current_state >= 536 )
 					yy_c = yy_meta[(unsigned int) yy_c];
 				}
 			yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
 			*yy_state_ptr++ = yy_current_state;
 			++yy_cp;
 			}
-		while ( yy_current_state != 553 );
+		while ( yy_current_state != 535 );
 
 yy_find_action:
 		yy_current_state = *--yy_state_ptr;
@@ -1274,267 +1254,247 @@
 	{ /* beginning of action switch */
 case 1:
 YY_RULE_SETUP
-#line 190 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 190 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { /* Ignore comments for now */ }
 	YY_BREAK
 case 2:
 YY_RULE_SETUP
-#line 192 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 192 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return BEGINTOK; }
 	YY_BREAK
 case 3:
 YY_RULE_SETUP
-#line 193 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 193 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return ENDTOK; }
 	YY_BREAK
 case 4:
 YY_RULE_SETUP
-#line 194 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 194 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return TRUETOK;  }
 	YY_BREAK
 case 5:
 YY_RULE_SETUP
-#line 195 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 195 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return FALSETOK; }
 	YY_BREAK
 case 6:
 YY_RULE_SETUP
-#line 196 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 196 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return DECLARE; }
 	YY_BREAK
 case 7:
 YY_RULE_SETUP
-#line 197 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 197 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return DEFINE; }
 	YY_BREAK
 case 8:
 YY_RULE_SETUP
-#line 198 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 198 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return GLOBAL; }
 	YY_BREAK
 case 9:
 YY_RULE_SETUP
-#line 199 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 199 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return CONSTANT; }
 	YY_BREAK
 case 10:
 YY_RULE_SETUP
-#line 200 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 200 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return INTERNAL; }
 	YY_BREAK
 case 11:
 YY_RULE_SETUP
-#line 201 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 201 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return LINKONCE; }
 	YY_BREAK
 case 12:
 YY_RULE_SETUP
-#line 202 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 202 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return WEAK; }
 	YY_BREAK
 case 13:
 YY_RULE_SETUP
-#line 203 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 203 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return APPENDING; }
 	YY_BREAK
 case 14:
 YY_RULE_SETUP
-#line 204 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 204 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return DLLIMPORT; }
 	YY_BREAK
 case 15:
 YY_RULE_SETUP
-#line 205 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 205 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return DLLEXPORT; }
 	YY_BREAK
 case 16:
 YY_RULE_SETUP
-#line 206 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 206 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return HIDDEN; }
 	YY_BREAK
 case 17:
 YY_RULE_SETUP
-#line 207 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 207 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return EXTERN_WEAK; }
 	YY_BREAK
 case 18:
 YY_RULE_SETUP
-#line 208 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 208 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return EXTERNAL; }
 	YY_BREAK
 case 19:
 YY_RULE_SETUP
-#line 209 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 209 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return IMPLEMENTATION; }
 	YY_BREAK
 case 20:
 YY_RULE_SETUP
-#line 210 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 210 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return ZEROINITIALIZER; }
 	YY_BREAK
 case 21:
 YY_RULE_SETUP
-#line 211 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 211 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return DOTDOTDOT; }
 	YY_BREAK
 case 22:
 YY_RULE_SETUP
-#line 212 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 212 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return UNDEF; }
 	YY_BREAK
 case 23:
 YY_RULE_SETUP
-#line 213 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 213 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return NULL_TOK; }
 	YY_BREAK
 case 24:
 YY_RULE_SETUP
-#line 214 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 214 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return TO; }
 	YY_BREAK
 case 25:
 YY_RULE_SETUP
-#line 215 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 215 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return TAIL; }
 	YY_BREAK
 case 26:
 YY_RULE_SETUP
-#line 216 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 216 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return TARGET; }
 	YY_BREAK
 case 27:
 YY_RULE_SETUP
-#line 217 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 217 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return TRIPLE; }
 	YY_BREAK
 case 28:
 YY_RULE_SETUP
-#line 218 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 218 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return DEPLIBS; }
 	YY_BREAK
 case 29:
 YY_RULE_SETUP
-#line 219 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
-{ return ENDIAN; }
-	YY_BREAK
-case 30:
-YY_RULE_SETUP
-#line 220 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
-{ return POINTERSIZE; }
-	YY_BREAK
-case 31:
-YY_RULE_SETUP
-#line 221 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 219 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return DATALAYOUT; }
 	YY_BREAK
-case 32:
-YY_RULE_SETUP
-#line 222 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
-{ return LITTLE; }
-	YY_BREAK
-case 33:
-YY_RULE_SETUP
-#line 223 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
-{ return BIG; }
-	YY_BREAK
-case 34:
+case 30:
 YY_RULE_SETUP
-#line 224 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 220 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return VOLATILE; }
 	YY_BREAK
-case 35:
+case 31:
 YY_RULE_SETUP
-#line 225 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 221 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return ALIGN;  }
 	YY_BREAK
-case 36:
+case 32:
 YY_RULE_SETUP
-#line 226 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 222 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return SECTION; }
 	YY_BREAK
-case 37:
+case 33:
 YY_RULE_SETUP
-#line 227 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 223 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return MODULE; }
 	YY_BREAK
-case 38:
+case 34:
 YY_RULE_SETUP
-#line 228 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 224 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return ASM_TOK; }
 	YY_BREAK
-case 39:
+case 35:
 YY_RULE_SETUP
-#line 229 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 225 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return SIDEEFFECT; }
 	YY_BREAK
-case 40:
+case 36:
 YY_RULE_SETUP
-#line 231 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 227 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return CC_TOK; }
 	YY_BREAK
-case 41:
+case 37:
 YY_RULE_SETUP
-#line 232 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 228 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return CCC_TOK; }
 	YY_BREAK
-case 42:
+case 38:
 YY_RULE_SETUP
-#line 233 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 229 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return CSRETCC_TOK; }
 	YY_BREAK
-case 43:
+case 39:
 YY_RULE_SETUP
-#line 234 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 230 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return FASTCC_TOK; }
 	YY_BREAK
-case 44:
+case 40:
 YY_RULE_SETUP
-#line 235 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 231 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return COLDCC_TOK; }
 	YY_BREAK
-case 45:
+case 41:
 YY_RULE_SETUP
-#line 236 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 232 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return X86_STDCALLCC_TOK; }
 	YY_BREAK
-case 46:
+case 42:
 YY_RULE_SETUP
-#line 237 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 233 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return X86_FASTCALLCC_TOK; }
 	YY_BREAK
-case 47:
+case 43:
 YY_RULE_SETUP
-#line 239 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 235 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TY(Type::VoidTy,  VOID);  }
 	YY_BREAK
-case 48:
+case 44:
 YY_RULE_SETUP
-#line 240 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 236 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TY(Type::FloatTy, FLOAT); }
 	YY_BREAK
-case 49:
+case 45:
 YY_RULE_SETUP
-#line 241 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 237 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TY(Type::DoubleTy,DOUBLE);}
 	YY_BREAK
-case 50:
+case 46:
 YY_RULE_SETUP
-#line 242 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 238 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TY(Type::LabelTy, LABEL); }
 	YY_BREAK
-case 51:
+case 47:
 YY_RULE_SETUP
-#line 243 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 239 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return TYPE;   }
 	YY_BREAK
-case 52:
+case 48:
 YY_RULE_SETUP
-#line 244 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 240 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return OPAQUE; }
 	YY_BREAK
-case 53:
+case 49:
 YY_RULE_SETUP
-#line 245 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 241 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { uint64_t NumBits = atoull(yytext+1);
                   if (NumBits < IntegerType::MIN_INT_BITS || 
                       NumBits > IntegerType::MAX_INT_BITS)
@@ -1543,358 +1503,358 @@
                   RET_TY(Ty, INTTYPE);
                 }
 	YY_BREAK
-case 54:
+case 50:
 YY_RULE_SETUP
-#line 253 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 249 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(BinaryOpVal, Add, ADD); }
 	YY_BREAK
-case 55:
+case 51:
 YY_RULE_SETUP
-#line 254 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 250 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(BinaryOpVal, Sub, SUB); }
 	YY_BREAK
-case 56:
+case 52:
 YY_RULE_SETUP
-#line 255 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 251 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(BinaryOpVal, Mul, MUL); }
 	YY_BREAK
-case 57:
+case 53:
 YY_RULE_SETUP
-#line 256 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 252 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(BinaryOpVal, UDiv, UDIV); }
 	YY_BREAK
-case 58:
+case 54:
 YY_RULE_SETUP
-#line 257 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 253 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(BinaryOpVal, SDiv, SDIV); }
 	YY_BREAK
-case 59:
+case 55:
 YY_RULE_SETUP
-#line 258 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 254 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(BinaryOpVal, FDiv, FDIV); }
 	YY_BREAK
-case 60:
+case 56:
 YY_RULE_SETUP
-#line 259 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 255 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(BinaryOpVal, URem, UREM); }
 	YY_BREAK
-case 61:
+case 57:
 YY_RULE_SETUP
-#line 260 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 256 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(BinaryOpVal, SRem, SREM); }
 	YY_BREAK
-case 62:
+case 58:
 YY_RULE_SETUP
-#line 261 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 257 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(BinaryOpVal, FRem, FREM); }
 	YY_BREAK
-case 63:
+case 59:
 YY_RULE_SETUP
-#line 262 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 258 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(BinaryOpVal, And, AND); }
 	YY_BREAK
-case 64:
+case 60:
 YY_RULE_SETUP
-#line 263 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 259 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(BinaryOpVal, Or , OR ); }
 	YY_BREAK
-case 65:
+case 61:
 YY_RULE_SETUP
-#line 264 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 260 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(BinaryOpVal, Xor, XOR); }
 	YY_BREAK
-case 66:
+case 62:
 YY_RULE_SETUP
-#line 265 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 261 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(OtherOpVal,  ICmp,  ICMP); }
 	YY_BREAK
-case 67:
+case 63:
 YY_RULE_SETUP
-#line 266 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 262 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(OtherOpVal,  FCmp,  FCMP); }
 	YY_BREAK
-case 68:
+case 64:
 YY_RULE_SETUP
-#line 267 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 263 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return EQ;  }
 	YY_BREAK
-case 69:
+case 65:
 YY_RULE_SETUP
-#line 268 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 264 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return NE;  }
 	YY_BREAK
-case 70:
+case 66:
 YY_RULE_SETUP
-#line 269 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 265 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return SLT; }
 	YY_BREAK
-case 71:
+case 67:
 YY_RULE_SETUP
-#line 270 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 266 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return SGT; }
 	YY_BREAK
-case 72:
+case 68:
 YY_RULE_SETUP
-#line 271 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 267 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return SLE; }
 	YY_BREAK
-case 73:
+case 69:
 YY_RULE_SETUP
-#line 272 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 268 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return SGE; }
 	YY_BREAK
-case 74:
+case 70:
 YY_RULE_SETUP
-#line 273 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 269 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return ULT; }
 	YY_BREAK
-case 75:
+case 71:
 YY_RULE_SETUP
-#line 274 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 270 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return UGT; }
 	YY_BREAK
-case 76:
+case 72:
 YY_RULE_SETUP
-#line 275 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 271 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return ULE; }
 	YY_BREAK
-case 77:
+case 73:
 YY_RULE_SETUP
-#line 276 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 272 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return UGE; }
 	YY_BREAK
-case 78:
+case 74:
 YY_RULE_SETUP
-#line 277 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 273 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return OEQ; }
 	YY_BREAK
-case 79:
+case 75:
 YY_RULE_SETUP
-#line 278 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 274 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return ONE; }
 	YY_BREAK
-case 80:
+case 76:
 YY_RULE_SETUP
-#line 279 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 275 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return OLT; }
 	YY_BREAK
-case 81:
+case 77:
 YY_RULE_SETUP
-#line 280 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 276 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return OGT; }
 	YY_BREAK
-case 82:
+case 78:
 YY_RULE_SETUP
-#line 281 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 277 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return OLE; }
 	YY_BREAK
-case 83:
+case 79:
 YY_RULE_SETUP
-#line 282 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 278 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return OGE; }
 	YY_BREAK
-case 84:
+case 80:
 YY_RULE_SETUP
-#line 283 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 279 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return ORD; }
 	YY_BREAK
-case 85:
+case 81:
 YY_RULE_SETUP
-#line 284 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 280 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return UNO; }
 	YY_BREAK
-case 86:
+case 82:
 YY_RULE_SETUP
-#line 285 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 281 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return UEQ; }
 	YY_BREAK
-case 87:
+case 83:
 YY_RULE_SETUP
-#line 286 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 282 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return UNE; }
 	YY_BREAK
-case 88:
+case 84:
 YY_RULE_SETUP
-#line 288 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 284 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(OtherOpVal, PHI, PHI_TOK); }
 	YY_BREAK
-case 89:
+case 85:
 YY_RULE_SETUP
-#line 289 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 285 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(OtherOpVal, Call, CALL); }
 	YY_BREAK
-case 90:
+case 86:
 YY_RULE_SETUP
-#line 290 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 286 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(CastOpVal, Trunc, TRUNC); }
 	YY_BREAK
-case 91:
+case 87:
 YY_RULE_SETUP
-#line 291 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 287 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(CastOpVal, ZExt, ZEXT); }
 	YY_BREAK
-case 92:
+case 88:
 YY_RULE_SETUP
-#line 292 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 288 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(CastOpVal, SExt, SEXT); }
 	YY_BREAK
-case 93:
+case 89:
 YY_RULE_SETUP
-#line 293 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 289 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(CastOpVal, FPTrunc, FPTRUNC); }
 	YY_BREAK
-case 94:
+case 90:
 YY_RULE_SETUP
-#line 294 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 290 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(CastOpVal, FPExt, FPEXT); }
 	YY_BREAK
-case 95:
+case 91:
 YY_RULE_SETUP
-#line 295 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 291 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(CastOpVal, UIToFP, UITOFP); }
 	YY_BREAK
-case 96:
+case 92:
 YY_RULE_SETUP
-#line 296 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 292 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(CastOpVal, SIToFP, SITOFP); }
 	YY_BREAK
-case 97:
+case 93:
 YY_RULE_SETUP
-#line 297 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 293 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(CastOpVal, FPToUI, FPTOUI); }
 	YY_BREAK
-case 98:
+case 94:
 YY_RULE_SETUP
-#line 298 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 294 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(CastOpVal, FPToSI, FPTOSI); }
 	YY_BREAK
-case 99:
+case 95:
 YY_RULE_SETUP
-#line 299 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 295 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(CastOpVal, IntToPtr, INTTOPTR); }
 	YY_BREAK
-case 100:
+case 96:
 YY_RULE_SETUP
-#line 300 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 296 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(CastOpVal, PtrToInt, PTRTOINT); }
 	YY_BREAK
-case 101:
+case 97:
 YY_RULE_SETUP
-#line 301 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 297 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(CastOpVal, BitCast, BITCAST); }
 	YY_BREAK
-case 102:
+case 98:
 YY_RULE_SETUP
-#line 302 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 298 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(OtherOpVal, Select, SELECT); }
 	YY_BREAK
-case 103:
+case 99:
 YY_RULE_SETUP
-#line 303 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 299 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(OtherOpVal, Shl, SHL); }
 	YY_BREAK
-case 104:
+case 100:
 YY_RULE_SETUP
-#line 304 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 300 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(OtherOpVal, LShr, LSHR); }
 	YY_BREAK
-case 105:
+case 101:
 YY_RULE_SETUP
-#line 305 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 301 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(OtherOpVal, AShr, ASHR); }
 	YY_BREAK
-case 106:
+case 102:
 YY_RULE_SETUP
-#line 306 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 302 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(OtherOpVal, VAArg , VAARG); }
 	YY_BREAK
-case 107:
+case 103:
 YY_RULE_SETUP
-#line 307 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 303 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(TermOpVal, Ret, RET); }
 	YY_BREAK
-case 108:
+case 104:
 YY_RULE_SETUP
-#line 308 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 304 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(TermOpVal, Br, BR); }
 	YY_BREAK
-case 109:
+case 105:
 YY_RULE_SETUP
-#line 309 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 305 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(TermOpVal, Switch, SWITCH); }
 	YY_BREAK
-case 110:
+case 106:
 YY_RULE_SETUP
-#line 310 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 306 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(TermOpVal, Invoke, INVOKE); }
 	YY_BREAK
-case 111:
+case 107:
 YY_RULE_SETUP
-#line 311 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 307 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(TermOpVal, Unwind, UNWIND); }
 	YY_BREAK
-case 112:
+case 108:
 YY_RULE_SETUP
-#line 312 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 308 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(TermOpVal, Unreachable, UNREACHABLE); }
 	YY_BREAK
-case 113:
+case 109:
 YY_RULE_SETUP
-#line 314 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 310 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(MemOpVal, Malloc, MALLOC); }
 	YY_BREAK
-case 114:
+case 110:
 YY_RULE_SETUP
-#line 315 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 311 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(MemOpVal, Alloca, ALLOCA); }
 	YY_BREAK
-case 115:
+case 111:
 YY_RULE_SETUP
-#line 316 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 312 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(MemOpVal, Free, FREE); }
 	YY_BREAK
-case 116:
+case 112:
 YY_RULE_SETUP
-#line 317 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 313 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(MemOpVal, Load, LOAD); }
 	YY_BREAK
-case 117:
+case 113:
 YY_RULE_SETUP
-#line 318 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 314 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(MemOpVal, Store, STORE); }
 	YY_BREAK
-case 118:
+case 114:
 YY_RULE_SETUP
-#line 319 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 315 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(MemOpVal, GetElementPtr, GETELEMENTPTR); }
 	YY_BREAK
-case 119:
+case 115:
 YY_RULE_SETUP
-#line 321 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 317 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(OtherOpVal, ExtractElement, EXTRACTELEMENT); }
 	YY_BREAK
-case 120:
+case 116:
 YY_RULE_SETUP
-#line 322 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 318 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(OtherOpVal, InsertElement, INSERTELEMENT); }
 	YY_BREAK
-case 121:
+case 117:
 YY_RULE_SETUP
-#line 323 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 319 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(OtherOpVal, ShuffleVector, SHUFFLEVECTOR); }
 	YY_BREAK
-case 122:
+case 118:
 YY_RULE_SETUP
-#line 326 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 322 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 {
                   UnEscapeLexed(yytext+1);
                   llvmAsmlval.StrVal = strdup(yytext+1);             // Skip %
                   return VAR_ID;
                 }
 	YY_BREAK
-case 123:
+case 119:
 YY_RULE_SETUP
-#line 331 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 327 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 {
                   yytext[strlen(yytext)-1] = 0;  // nuke colon
                   UnEscapeLexed(yytext);
@@ -1902,9 +1862,9 @@
                   return LABELSTR;
                 }
 	YY_BREAK
-case 124:
+case 120:
 YY_RULE_SETUP
-#line 337 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 333 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 {
                   yytext[strlen(yytext)-2] = 0;  // nuke colon, end quote
                   UnEscapeLexed(yytext+1);
@@ -1912,9 +1872,9 @@
                   return LABELSTR;
                 }
 	YY_BREAK
-case 125:
+case 121:
 YY_RULE_SETUP
-#line 344 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 340 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { // Note that we cannot unescape a string constant here!  The
                    // string constant might contain a \00 which would not be
                    // understood by the string stuff.  It is valid to make a
@@ -1925,14 +1885,14 @@
                    return STRINGCONSTANT;
                  }
 	YY_BREAK
-case 126:
+case 122:
 YY_RULE_SETUP
-#line 355 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 351 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { llvmAsmlval.UInt64Val = atoull(yytext); return EUINT64VAL; }
 	YY_BREAK
-case 127:
+case 123:
 YY_RULE_SETUP
-#line 356 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 352 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 {
                   uint64_t Val = atoull(yytext+1);
                   // +1:  we have bigger negative range
@@ -1942,17 +1902,17 @@
                   return ESINT64VAL;
                 }
 	YY_BREAK
-case 128:
+case 124:
 YY_RULE_SETUP
-#line 364 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 360 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 {
                    llvmAsmlval.UInt64Val = HexIntToVal(yytext+3);
                    return yytext[0] == 's' ? ESINT64VAL : EUINT64VAL;
                  }
 	YY_BREAK
-case 129:
+case 125:
 YY_RULE_SETUP
-#line 369 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 365 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 {
                   uint64_t Val = atoull(yytext+1);
                   if ((unsigned)Val != Val)
@@ -1961,9 +1921,9 @@
                   return UINTVAL;
                 }
 	YY_BREAK
-case 130:
+case 126:
 YY_RULE_SETUP
-#line 376 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 372 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 {
                   uint64_t Val = atoull(yytext+2);
                   // +1:  we have bigger negative range
@@ -1973,18 +1933,18 @@
                   return SINTVAL;
                 }
 	YY_BREAK
-case 131:
+case 127:
 YY_RULE_SETUP
-#line 385 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 381 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { llvmAsmlval.FPVal = atof(yytext); return FPVAL; }
 	YY_BREAK
-case 132:
+case 128:
 YY_RULE_SETUP
-#line 386 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 382 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { llvmAsmlval.FPVal = HexToFP(yytext); return FPVAL; }
 	YY_BREAK
 case YY_STATE_EOF(INITIAL):
-#line 388 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 384 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 {
                   /* Make sure to free the internal buffers for flex when we are
                    * done reading our input!
@@ -1993,22 +1953,22 @@
                   return EOF;
                 }
 	YY_BREAK
-case 133:
+case 129:
 YY_RULE_SETUP
-#line 396 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 392 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { /* Ignore whitespace */ }
 	YY_BREAK
-case 134:
+case 130:
 YY_RULE_SETUP
-#line 397 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 393 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 { return yytext[0]; }
 	YY_BREAK
-case 135:
+case 131:
 YY_RULE_SETUP
-#line 399 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 395 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 YY_FATAL_ERROR( "flex scanner jammed" );
 	YY_BREAK
-#line 2012 "Lexer.cpp"
+#line 1968 "Lexer.cpp"
 
 	case YY_END_OF_BUFFER:
 		{
@@ -2295,7 +2255,7 @@
 		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 			{
 			yy_current_state = (int) yy_def[yy_current_state];
-			if ( yy_current_state >= 554 )
+			if ( yy_current_state >= 536 )
 				yy_c = yy_meta[(unsigned int) yy_c];
 			}
 		yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
@@ -2325,11 +2285,11 @@
 	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 		{
 		yy_current_state = (int) yy_def[yy_current_state];
-		if ( yy_current_state >= 554 )
+		if ( yy_current_state >= 536 )
 			yy_c = yy_meta[(unsigned int) yy_c];
 		}
 	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
-	yy_is_jam = (yy_current_state == 553);
+	yy_is_jam = (yy_current_state == 535);
 	if ( ! yy_is_jam )
 		*yy_state_ptr++ = yy_current_state;
 
@@ -2384,7 +2344,6 @@
 #endif	/* ifndef YY_NO_UNPUT */
 
 
-#ifndef YY_NO_INPUT
 #ifdef __cplusplus
 static int yyinput()
 #else
@@ -2458,7 +2417,7 @@
 
 	return c;
 	}
-#endif /* YY_NO_INPUT */
+
 
 #ifdef YY_USE_PROTOS
 void yyrestart( FILE *input_file )
@@ -2569,6 +2528,11 @@
 	}
 
 
+#ifndef YY_ALWAYS_INTERACTIVE
+#ifndef YY_NEVER_INTERACTIVE
+extern int isatty YY_PROTO(( int ));
+#endif
+#endif
 
 #ifdef YY_USE_PROTOS
 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
@@ -2886,5 +2850,5 @@
 	return 0;
 	}
 #endif
-#line 399 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
+#line 395 "/Users/resistor/llvm/src/llvm/lib/AsmParser/Lexer.l"
 


Index: llvm/lib/AsmParser/Lexer.l.cvs
diff -u llvm/lib/AsmParser/Lexer.l.cvs:1.22 llvm/lib/AsmParser/Lexer.l.cvs:1.23
--- llvm/lib/AsmParser/Lexer.l.cvs:1.22	Fri Jan 12 23:00:46 2007
+++ llvm/lib/AsmParser/Lexer.l.cvs	Fri Jan 26 02:05:27 2007
@@ -148,8 +148,11 @@
 /* Comments start with a ; and go till end of line */
 Comment    ;.*
 
-/* Variable(Value) identifiers start with a % sign */
-VarID       %[-a-zA-Z$._][-a-zA-Z$._0-9]*
+/* Local Values and Type identifiers start with a % sign */
+LocalVarName       %[-a-zA-Z$._][-a-zA-Z$._0-9]*
+
+/* Global Value identifiers start with an @ sign */
+GlobalVarName       @[-a-zA-Z$._][-a-zA-Z$._0-9]*
 
 /* Label identifiers end with a colon */
 Label       [-a-zA-Z$._0-9]+:
@@ -157,18 +160,16 @@
 
 /* Quoted names can contain any character except " and \ */
 StringConstant \"[^\"]*\"
+AtStringConstant @\"[^\"]*\"
+  
+/* LocalVarID/GlobalVarID: match an unnamed local variable slot ID. */
+LocalVarID     %[0-9]+
+GlobalVarID    @[0-9]+
 
-
-/* [PN]Integer: match positive and negative literal integer values that
- * are preceeded by a '%' character.  These represent unnamed variable slots.
- */
-EPInteger     %[0-9]+
-ENInteger    %-[0-9]+
-
+/* Integer types are specified with i and a bitwidth */
 IntegerType i[0-9]+
 
-
-/* E[PN]Integer: match positive and negative literal integer values */
+/* E[PN]Integer: match positive and negative literal integer values. */
 PInteger   [0-9]+
 NInteger  -[0-9]+
 
@@ -216,11 +217,7 @@
 target          { return TARGET; }
 triple          { return TRIPLE; }
 deplibs         { return DEPLIBS; }
-endian          { return ENDIAN; }
-pointersize     { return POINTERSIZE; }
 datalayout      { return DATALAYOUT; }
-little          { return LITTLE; }
-big             { return BIG; }
 volatile        { return VOLATILE; }
 align           { return ALIGN;  }
 section         { return SECTION; }
@@ -323,10 +320,15 @@
 shufflevector   { RET_TOK(OtherOpVal, ShuffleVector, SHUFFLEVECTOR); }
 
 
-{VarID}         {
+{LocalVarName}  {
                   UnEscapeLexed(yytext+1);
                   llvmAsmlval.StrVal = strdup(yytext+1);             // Skip %
-                  return VAR_ID;
+                  return LOCALVAR;
+                }
+{GlobalVarName} {
+                  UnEscapeLexed(yytext+1);
+                  llvmAsmlval.StrVal = strdup(yytext+1);             // Skip @
+                  return GLOBALVAR;
                 }
 {Label}         {
                   yytext[strlen(yytext)-1] = 0;  // nuke colon
@@ -350,6 +352,12 @@
                    llvmAsmlval.StrVal = strdup(yytext+1);  // Nuke start quote
                    return STRINGCONSTANT;
                  }
+{AtStringConstant} {
+                     yytext[strlen(yytext)-1] = 0;           // nuke end quote
+                     llvmAsmlval.StrVal = strdup(yytext+2);  // Nuke @, quote
+                     return ATSTRINGCONSTANT;
+                   }
+
 
 
 {PInteger}      { llvmAsmlval.UInt64Val = atoull(yytext); return EUINT64VAL; }
@@ -366,20 +374,19 @@
                    return yytext[0] == 's' ? ESINT64VAL : EUINT64VAL;
                  }
 
-{EPInteger}     {
+{LocalVarID}     {
                   uint64_t Val = atoull(yytext+1);
                   if ((unsigned)Val != Val)
                     GenerateError("Invalid value number (too large)!");
                   llvmAsmlval.UIntVal = unsigned(Val);
-                  return UINTVAL;
+                  return LOCALVAL_ID;
                 }
-{ENInteger}     {
-                  uint64_t Val = atoull(yytext+2);
-                  // +1:  we have bigger negative range
-                  if (Val > (uint64_t)INT32_MAX+1)
-                    GenerateError("Constant too large for signed 32 bits!");
-                  llvmAsmlval.SIntVal = (int)-Val;
-                  return SINTVAL;
+{GlobalVarID}   {
+                  uint64_t Val = atoull(yytext+1);
+                  if ((unsigned)Val != Val)
+                    GenerateError("Invalid value number (too large)!");
+                  llvmAsmlval.UIntVal = unsigned(Val);
+                  return GLOBALVAL_ID;
                 }
 
 {FPConstant}    { llvmAsmlval.FPVal = atof(yytext); return FPVAL; }


Index: llvm/lib/AsmParser/llvmAsmParser.cpp.cvs
diff -u llvm/lib/AsmParser/llvmAsmParser.cpp.cvs:1.57 llvm/lib/AsmParser/llvmAsmParser.cpp.cvs:1.58
--- llvm/lib/AsmParser/llvmAsmParser.cpp.cvs:1.57	Sun Jan 21 13:19:31 2007
+++ llvm/lib/AsmParser/llvmAsmParser.cpp.cvs	Fri Jan 26 02:05:27 2007
@@ -1,7 +1,7 @@
-/* A Bison parser, made from /usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y, by GNU bison 1.75.  */
+/* A Bison parser, made by GNU Bison 2.1.  */
 
 /* Skeleton parser for Yacc-like parsing with Bison,
-   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software Foundation, Inc.
+   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -15,8 +15,8 @@
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
+   Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.  */
 
 /* As a special exception, when this file is copied by Bison into a
    Bison output file, you may use that output file without restriction.
@@ -34,16 +34,21 @@
    USER NAME SPACE" below.  */
 
 /* Identify Bison output.  */
-#define YYBISON	1
+#define YYBISON 1
+
+/* Bison version.  */
+#define YYBISON_VERSION "2.1"
+
+/* Skeleton name.  */
+#define YYSKELETON_NAME "yacc.c"
 
 /* Pure parsers.  */
-#define YYPURE	0
+#define YYPURE 0
 
 /* Using locations.  */
 #define YYLSP_NEEDED 0
 
-/* If NAME_PREFIX is specified substitute the variables and functions
-   names.  */
+/* Substitute the variable and function names.  */
 #define yyparse llvmAsmparse
 #define yylex   llvmAsmlex
 #define yyerror llvmAsmerror
@@ -61,8 +66,8 @@
    enum yytokentype {
      ESINT64VAL = 258,
      EUINT64VAL = 259,
-     SINTVAL = 260,
-     UINTVAL = 261,
+     LOCALVAL_ID = 260,
+     GLOBALVAL_ID = 261,
      FPVAL = 262,
      VOID = 263,
      INTTYPE = 264,
@@ -70,131 +75,130 @@
      DOUBLE = 266,
      LABEL = 267,
      TYPE = 268,
-     VAR_ID = 269,
-     LABELSTR = 270,
-     STRINGCONSTANT = 271,
-     IMPLEMENTATION = 272,
-     ZEROINITIALIZER = 273,
-     TRUETOK = 274,
-     FALSETOK = 275,
-     BEGINTOK = 276,
-     ENDTOK = 277,
-     DECLARE = 278,
-     DEFINE = 279,
-     GLOBAL = 280,
-     CONSTANT = 281,
-     SECTION = 282,
-     VOLATILE = 283,
-     TO = 284,
-     DOTDOTDOT = 285,
-     NULL_TOK = 286,
-     UNDEF = 287,
-     INTERNAL = 288,
-     LINKONCE = 289,
-     WEAK = 290,
-     APPENDING = 291,
-     DLLIMPORT = 292,
-     DLLEXPORT = 293,
-     EXTERN_WEAK = 294,
-     OPAQUE = 295,
-     EXTERNAL = 296,
-     TARGET = 297,
-     TRIPLE = 298,
-     ENDIAN = 299,
-     POINTERSIZE = 300,
-     LITTLE = 301,
-     BIG = 302,
-     ALIGN = 303,
-     DEPLIBS = 304,
-     CALL = 305,
-     TAIL = 306,
-     ASM_TOK = 307,
-     MODULE = 308,
-     SIDEEFFECT = 309,
-     CC_TOK = 310,
-     CCC_TOK = 311,
-     CSRETCC_TOK = 312,
-     FASTCC_TOK = 313,
-     COLDCC_TOK = 314,
-     X86_STDCALLCC_TOK = 315,
-     X86_FASTCALLCC_TOK = 316,
-     DATALAYOUT = 317,
-     RET = 318,
-     BR = 319,
-     SWITCH = 320,
-     INVOKE = 321,
-     UNWIND = 322,
-     UNREACHABLE = 323,
-     ADD = 324,
-     SUB = 325,
-     MUL = 326,
-     UDIV = 327,
-     SDIV = 328,
-     FDIV = 329,
-     UREM = 330,
-     SREM = 331,
-     FREM = 332,
-     AND = 333,
-     OR = 334,
-     XOR = 335,
-     ICMP = 336,
-     FCMP = 337,
-     EQ = 338,
-     NE = 339,
-     SLT = 340,
-     SGT = 341,
-     SLE = 342,
-     SGE = 343,
-     ULT = 344,
-     UGT = 345,
-     ULE = 346,
-     UGE = 347,
-     OEQ = 348,
-     ONE = 349,
-     OLT = 350,
-     OGT = 351,
-     OLE = 352,
-     OGE = 353,
-     ORD = 354,
-     UNO = 355,
-     UEQ = 356,
-     UNE = 357,
-     MALLOC = 358,
-     ALLOCA = 359,
-     FREE = 360,
-     LOAD = 361,
-     STORE = 362,
-     GETELEMENTPTR = 363,
-     TRUNC = 364,
-     ZEXT = 365,
-     SEXT = 366,
-     FPTRUNC = 367,
-     FPEXT = 368,
-     BITCAST = 369,
-     UITOFP = 370,
-     SITOFP = 371,
-     FPTOUI = 372,
-     FPTOSI = 373,
-     INTTOPTR = 374,
-     PTRTOINT = 375,
-     PHI_TOK = 376,
-     SELECT = 377,
-     SHL = 378,
-     LSHR = 379,
-     ASHR = 380,
-     VAARG = 381,
-     EXTRACTELEMENT = 382,
-     INSERTELEMENT = 383,
-     SHUFFLEVECTOR = 384,
-     NORETURN = 385,
-     DEFAULT = 386,
-     HIDDEN = 387
+     LOCALVAR = 269,
+     GLOBALVAR = 270,
+     LABELSTR = 271,
+     STRINGCONSTANT = 272,
+     ATSTRINGCONSTANT = 273,
+     IMPLEMENTATION = 274,
+     ZEROINITIALIZER = 275,
+     TRUETOK = 276,
+     FALSETOK = 277,
+     BEGINTOK = 278,
+     ENDTOK = 279,
+     DECLARE = 280,
+     DEFINE = 281,
+     GLOBAL = 282,
+     CONSTANT = 283,
+     SECTION = 284,
+     VOLATILE = 285,
+     TO = 286,
+     DOTDOTDOT = 287,
+     NULL_TOK = 288,
+     UNDEF = 289,
+     INTERNAL = 290,
+     LINKONCE = 291,
+     WEAK = 292,
+     APPENDING = 293,
+     DLLIMPORT = 294,
+     DLLEXPORT = 295,
+     EXTERN_WEAK = 296,
+     OPAQUE = 297,
+     EXTERNAL = 298,
+     TARGET = 299,
+     TRIPLE = 300,
+     ALIGN = 301,
+     DEPLIBS = 302,
+     CALL = 303,
+     TAIL = 304,
+     ASM_TOK = 305,
+     MODULE = 306,
+     SIDEEFFECT = 307,
+     CC_TOK = 308,
+     CCC_TOK = 309,
+     CSRETCC_TOK = 310,
+     FASTCC_TOK = 311,
+     COLDCC_TOK = 312,
+     X86_STDCALLCC_TOK = 313,
+     X86_FASTCALLCC_TOK = 314,
+     DATALAYOUT = 315,
+     RET = 316,
+     BR = 317,
+     SWITCH = 318,
+     INVOKE = 319,
+     UNWIND = 320,
+     UNREACHABLE = 321,
+     ADD = 322,
+     SUB = 323,
+     MUL = 324,
+     UDIV = 325,
+     SDIV = 326,
+     FDIV = 327,
+     UREM = 328,
+     SREM = 329,
+     FREM = 330,
+     AND = 331,
+     OR = 332,
+     XOR = 333,
+     ICMP = 334,
+     FCMP = 335,
+     EQ = 336,
+     NE = 337,
+     SLT = 338,
+     SGT = 339,
+     SLE = 340,
+     SGE = 341,
+     ULT = 342,
+     UGT = 343,
+     ULE = 344,
+     UGE = 345,
+     OEQ = 346,
+     ONE = 347,
+     OLT = 348,
+     OGT = 349,
+     OLE = 350,
+     OGE = 351,
+     ORD = 352,
+     UNO = 353,
+     UEQ = 354,
+     UNE = 355,
+     MALLOC = 356,
+     ALLOCA = 357,
+     FREE = 358,
+     LOAD = 359,
+     STORE = 360,
+     GETELEMENTPTR = 361,
+     TRUNC = 362,
+     ZEXT = 363,
+     SEXT = 364,
+     FPTRUNC = 365,
+     FPEXT = 366,
+     BITCAST = 367,
+     UITOFP = 368,
+     SITOFP = 369,
+     FPTOUI = 370,
+     FPTOSI = 371,
+     INTTOPTR = 372,
+     PTRTOINT = 373,
+     PHI_TOK = 374,
+     SELECT = 375,
+     SHL = 376,
+     LSHR = 377,
+     ASHR = 378,
+     VAARG = 379,
+     EXTRACTELEMENT = 380,
+     INSERTELEMENT = 381,
+     SHUFFLEVECTOR = 382,
+     NORETURN = 383,
+     DEFAULT = 384,
+     HIDDEN = 385
    };
 #endif
+/* Tokens.  */
 #define ESINT64VAL 258
 #define EUINT64VAL 259
-#define SINTVAL 260
-#define UINTVAL 261
+#define LOCALVAL_ID 260
+#define GLOBALVAL_ID 261
 #define FPVAL 262
 #define VOID 263
 #define INTTYPE 264
@@ -202,131 +206,129 @@
 #define DOUBLE 266
 #define LABEL 267
 #define TYPE 268
-#define VAR_ID 269
-#define LABELSTR 270
-#define STRINGCONSTANT 271
-#define IMPLEMENTATION 272
-#define ZEROINITIALIZER 273
-#define TRUETOK 274
-#define FALSETOK 275
-#define BEGINTOK 276
-#define ENDTOK 277
-#define DECLARE 278
-#define DEFINE 279
-#define GLOBAL 280
-#define CONSTANT 281
-#define SECTION 282
-#define VOLATILE 283
-#define TO 284
-#define DOTDOTDOT 285
-#define NULL_TOK 286
-#define UNDEF 287
-#define INTERNAL 288
-#define LINKONCE 289
-#define WEAK 290
-#define APPENDING 291
-#define DLLIMPORT 292
-#define DLLEXPORT 293
-#define EXTERN_WEAK 294
-#define OPAQUE 295
-#define EXTERNAL 296
-#define TARGET 297
-#define TRIPLE 298
-#define ENDIAN 299
-#define POINTERSIZE 300
-#define LITTLE 301
-#define BIG 302
-#define ALIGN 303
-#define DEPLIBS 304
-#define CALL 305
-#define TAIL 306
-#define ASM_TOK 307
-#define MODULE 308
-#define SIDEEFFECT 309
-#define CC_TOK 310
-#define CCC_TOK 311
-#define CSRETCC_TOK 312
-#define FASTCC_TOK 313
-#define COLDCC_TOK 314
-#define X86_STDCALLCC_TOK 315
-#define X86_FASTCALLCC_TOK 316
-#define DATALAYOUT 317
-#define RET 318
-#define BR 319
-#define SWITCH 320
-#define INVOKE 321
-#define UNWIND 322
-#define UNREACHABLE 323
-#define ADD 324
-#define SUB 325
-#define MUL 326
-#define UDIV 327
-#define SDIV 328
-#define FDIV 329
-#define UREM 330
-#define SREM 331
-#define FREM 332
-#define AND 333
-#define OR 334
-#define XOR 335
-#define ICMP 336
-#define FCMP 337
-#define EQ 338
-#define NE 339
-#define SLT 340
-#define SGT 341
-#define SLE 342
-#define SGE 343
-#define ULT 344
-#define UGT 345
-#define ULE 346
-#define UGE 347
-#define OEQ 348
-#define ONE 349
-#define OLT 350
-#define OGT 351
-#define OLE 352
-#define OGE 353
-#define ORD 354
-#define UNO 355
-#define UEQ 356
-#define UNE 357
-#define MALLOC 358
-#define ALLOCA 359
-#define FREE 360
-#define LOAD 361
-#define STORE 362
-#define GETELEMENTPTR 363
-#define TRUNC 364
-#define ZEXT 365
-#define SEXT 366
-#define FPTRUNC 367
-#define FPEXT 368
-#define BITCAST 369
-#define UITOFP 370
-#define SITOFP 371
-#define FPTOUI 372
-#define FPTOSI 373
-#define INTTOPTR 374
-#define PTRTOINT 375
-#define PHI_TOK 376
-#define SELECT 377
-#define SHL 378
-#define LSHR 379
-#define ASHR 380
-#define VAARG 381
-#define EXTRACTELEMENT 382
-#define INSERTELEMENT 383
-#define SHUFFLEVECTOR 384
-#define NORETURN 385
-#define DEFAULT 386
-#define HIDDEN 387
+#define LOCALVAR 269
+#define GLOBALVAR 270
+#define LABELSTR 271
+#define STRINGCONSTANT 272
+#define ATSTRINGCONSTANT 273
+#define IMPLEMENTATION 274
+#define ZEROINITIALIZER 275
+#define TRUETOK 276
+#define FALSETOK 277
+#define BEGINTOK 278
+#define ENDTOK 279
+#define DECLARE 280
+#define DEFINE 281
+#define GLOBAL 282
+#define CONSTANT 283
+#define SECTION 284
+#define VOLATILE 285
+#define TO 286
+#define DOTDOTDOT 287
+#define NULL_TOK 288
+#define UNDEF 289
+#define INTERNAL 290
+#define LINKONCE 291
+#define WEAK 292
+#define APPENDING 293
+#define DLLIMPORT 294
+#define DLLEXPORT 295
+#define EXTERN_WEAK 296
+#define OPAQUE 297
+#define EXTERNAL 298
+#define TARGET 299
+#define TRIPLE 300
+#define ALIGN 301
+#define DEPLIBS 302
+#define CALL 303
+#define TAIL 304
+#define ASM_TOK 305
+#define MODULE 306
+#define SIDEEFFECT 307
+#define CC_TOK 308
+#define CCC_TOK 309
+#define CSRETCC_TOK 310
+#define FASTCC_TOK 311
+#define COLDCC_TOK 312
+#define X86_STDCALLCC_TOK 313
+#define X86_FASTCALLCC_TOK 314
+#define DATALAYOUT 315
+#define RET 316
+#define BR 317
+#define SWITCH 318
+#define INVOKE 319
+#define UNWIND 320
+#define UNREACHABLE 321
+#define ADD 322
+#define SUB 323
+#define MUL 324
+#define UDIV 325
+#define SDIV 326
+#define FDIV 327
+#define UREM 328
+#define SREM 329
+#define FREM 330
+#define AND 331
+#define OR 332
+#define XOR 333
+#define ICMP 334
+#define FCMP 335
+#define EQ 336
+#define NE 337
+#define SLT 338
+#define SGT 339
+#define SLE 340
+#define SGE 341
+#define ULT 342
+#define UGT 343
+#define ULE 344
+#define UGE 345
+#define OEQ 346
+#define ONE 347
+#define OLT 348
+#define OGT 349
+#define OLE 350
+#define OGE 351
+#define ORD 352
+#define UNO 353
+#define UEQ 354
+#define UNE 355
+#define MALLOC 356
+#define ALLOCA 357
+#define FREE 358
+#define LOAD 359
+#define STORE 360
+#define GETELEMENTPTR 361
+#define TRUNC 362
+#define ZEXT 363
+#define SEXT 364
+#define FPTRUNC 365
+#define FPEXT 366
+#define BITCAST 367
+#define UITOFP 368
+#define SITOFP 369
+#define FPTOUI 370
+#define FPTOSI 371
+#define INTTOPTR 372
+#define PTRTOINT 373
+#define PHI_TOK 374
+#define SELECT 375
+#define SHL 376
+#define LSHR 377
+#define ASHR 378
+#define VAARG 379
+#define EXTRACTELEMENT 380
+#define INSERTELEMENT 381
+#define SHUFFLEVECTOR 382
+#define NORETURN 383
+#define DEFAULT 384
+#define HIDDEN 385
 
 
 
 
 /* Copy the first part of user declarations.  */
-#line 14 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 14 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
 
 #include "ParserInternals.h"
 #include "llvm/CallingConv.h"
@@ -586,12 +588,12 @@
 
 static const Type *getTypeVal(const ValID &D, bool DoNotImprovise = false) {
   switch (D.Type) {
-  case ValID::NumberVal:               // Is it a numbered definition?
+  case ValID::LocalID:               // Is it a numbered definition?
     // Module constants occupy the lowest numbered slots...
-    if ((unsigned)D.Num < CurModule.Types.size())
-      return CurModule.Types[(unsigned)D.Num];
+    if (D.Num < CurModule.Types.size())
+      return CurModule.Types[D.Num];
     break;
-  case ValID::NameVal:                 // Is it a named definition?
+  case ValID::LocalName:                 // Is it a named definition?
     if (const Type *N = CurModule.CurrentModule->getTypeByName(D.Name)) {
       D.destroy();  // Free old strdup'd memory...
       return N;
@@ -610,11 +612,11 @@
 
 
   if (inFunctionScope()) {
-    if (D.Type == ValID::NameVal) {
+    if (D.Type == ValID::LocalName) {
       GenerateError("Reference to an undefined type: '" + D.getName() + "'");
       return 0;
     } else {
-      GenerateError("Reference to an undefined type: #" + itostr(D.Num));
+      GenerateError("Reference to an undefined type: #" + utostr(D.Num));
       return 0;
     }
   }
@@ -628,13 +630,6 @@
   return Typ;
  }
 
-static Value *lookupInSymbolTable(const Type *Ty, const std::string &Name) {
-  SymbolTable &SymTab =
-    inFunctionScope() ? CurFun.CurrentFunction->getValueSymbolTable() :
-                        CurModule.CurrentModule->getValueSymbolTable();
-  return SymTab.lookup(Ty, Name);
-}
-
 // getValNonImprovising - Look up the value specified by the provided type and
 // the provided ValID.  If the value exists and has already been defined, return
 // it.  Otherwise return null.
@@ -647,29 +642,39 @@
   }
 
   switch (D.Type) {
-  case ValID::NumberVal: {                 // Is it a numbered definition?
-    unsigned Num = (unsigned)D.Num;
-
-    // Module constants occupy the lowest numbered slots...
-    std::map::iterator VI = CurModule.Values.find(Ty);
-    if (VI != CurModule.Values.end()) {
-      if (Num < VI->second.size())
-        return VI->second[Num];
-      Num -= VI->second.size();
-    }
-
-    // Make sure that our type is within bounds
-    VI = CurFun.Values.find(Ty);
+  case ValID::LocalID: {                 // Is it a numbered definition?
+    // Module constants occupy the lowest numbered slots.
+    std::map::iterator VI = CurFun.Values.find(Ty);
+    // Make sure that our type is within bounds.
     if (VI == CurFun.Values.end()) return 0;
 
-    // Check that the number is within bounds...
-    if (VI->second.size() <= Num) return 0;
+    // Check that the number is within bounds.
+    if (D.Num >= VI->second.size()) return 0;
 
+    return VI->second[D.Num];
+  }
+  case ValID::GlobalID: {                 // Is it a numbered definition?
+    unsigned Num = D.Num;
+    
+    // Module constants occupy the lowest numbered slots...
+    std::map::iterator VI = CurModule.Values.find(Ty);
+    if (VI == CurModule.Values.end()) return 0;
+    if (D.Num >= VI->second.size()) return 0;
     return VI->second[Num];
   }
-
-  case ValID::NameVal: {                // Is it a named definition?
-    Value *N = lookupInSymbolTable(Ty, std::string(D.Name));
+    
+  case ValID::LocalName: {                // Is it a named definition?
+    if (!inFunctionScope()) return 0;
+    SymbolTable &SymTab = CurFun.CurrentFunction->getValueSymbolTable();
+    Value *N = SymTab.lookup(Ty, D.Name);
+    if (N == 0) return 0;
+    
+    D.destroy();  // Free old strdup'd memory...
+    return N;
+  }
+  case ValID::GlobalName: {                // Is it a named definition?
+    SymbolTable &SymTab = CurModule.CurrentModule->getValueSymbolTable();
+    Value *N = SymTab.lookup(Ty, D.Name);
     if (N == 0) return 0;
 
     D.destroy();  // Free old strdup'd memory...
@@ -804,12 +809,12 @@
   default: 
     GenerateError("Illegal label reference " + ID.getName());
     return 0;
-  case ValID::NumberVal:                // Is it a numbered definition?
-    if (unsigned(ID.Num) >= CurFun.NumberedBlocks.size())
+  case ValID::LocalID:                // Is it a numbered definition?
+    if (ID.Num >= CurFun.NumberedBlocks.size())
       CurFun.NumberedBlocks.resize(ID.Num+1);
     BB = CurFun.NumberedBlocks[ID.Num];
     break;
-  case ValID::NameVal:                  // Is it a named definition?
+  case ValID::LocalName:                  // Is it a named definition?
     Name = ID.Name;
     if (Value *N = CurFun.CurrentFunction->
                    getValueSymbolTable().lookup(Type::LabelTy, Name))
@@ -834,7 +839,7 @@
 
   // Otherwise this block has not been seen before.
   BB = new BasicBlock("", CurFun.CurrentFunction);
-  if (ID.Type == ValID::NameVal) {
+  if (ID.Type == ValID::LocalName) {
     BB->setName(ID.Name);
   } else {
     CurFun.NumberedBlocks[ID.Num] = BB;
@@ -901,7 +906,7 @@
         // resolver table
         InsertValue(V, *FutureLateResolvers);
       } else {
-        if (DID.Type == ValID::NameVal) {
+        if (DID.Type == ValID::LocalName || DID.Type == ValID::GlobalName) {
           GenerateError("Reference to an invalid definition: '" +DID.getName()+
                          "' of type '" + V->getType()->getDescription() + "'",
                          PHI->second.second);
@@ -926,8 +931,8 @@
 //
 static void ResolveTypeTo(char *Name, const Type *ToTy) {
   ValID D;
-  if (Name) D = ValID::create(Name);
-  else      D = ValID::create((int)CurModule.Types.size());
+  if (Name) D = ValID::createLocalName(Name);
+  else      D = ValID::createLocalID(CurModule.Types.size());
 
   std::map::iterator I =
     CurModule.LateResolveTypes.find(D);
@@ -942,26 +947,25 @@
 // assumed to be a malloc'd string buffer, and is free'd by this function.
 //
 static void setValueName(Value *V, char *NameStr) {
-  if (NameStr) {
-    std::string Name(NameStr);      // Copy string
-    free(NameStr);                  // Free old string
-
-    if (V->getType() == Type::VoidTy) {
-      GenerateError("Can't assign name '" + Name+"' to value with void type!");
-      return;
-    }
+  if (!NameStr) return;
+  std::string Name(NameStr);      // Copy string
+  free(NameStr);                  // Free old string
 
-    assert(inFunctionScope() && "Must be in function scope!");
-    SymbolTable &ST = CurFun.CurrentFunction->getValueSymbolTable();
-    if (ST.lookup(V->getType(), Name)) {
-      GenerateError("Redefinition of value '" + Name + "' of type '" +
-                     V->getType()->getDescription() + "'!");
-      return;
-    }
+  if (V->getType() == Type::VoidTy) {
+    GenerateError("Can't assign name '" + Name+"' to value with void type!");
+    return;
+  }
 
-    // Set the name.
-    V->setName(Name);
+  assert(inFunctionScope() && "Must be in function scope!");
+  SymbolTable &ST = CurFun.CurrentFunction->getValueSymbolTable();
+  if (ST.lookup(V->getType(), Name)) {
+    GenerateError("Redefinition of value '" + Name + "' of type '" +
+                   V->getType()->getDescription() + "'!");
+    return;
   }
+
+  // Set the name.
+  V->setName(Name);
 }
 
 /// ParseGlobalVariable - Handle parsing of a global.  If Initializer is null,
@@ -989,9 +993,9 @@
   // object.
   ValID ID;
   if (!Name.empty()) {
-    ID = ValID::create((char*)Name.c_str());
+    ID = ValID::createGlobalName((char*)Name.c_str());
   } else {
-    ID = ValID::create((int)CurModule.Values[PTy].size());
+    ID = ValID::createGlobalID(CurModule.Values[PTy].size());
   }
 
   if (GlobalValue *FWGV = CurModule.GetForwardRefForGlobal(PTy, ID)) {
@@ -1209,9 +1213,14 @@
 # define YYERROR_VERBOSE 0
 #endif
 
-#ifndef YYSTYPE
-#line 883 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-typedef union {
+/* Enabling the token table.  */
+#ifndef YYTOKEN_TABLE
+# define YYTOKEN_TABLE 0
+#endif
+
+#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
+#line 885 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+typedef union YYSTYPE {
   llvm::Module                           *ModuleVal;
   llvm::Function                         *FunctionVal;
   llvm::BasicBlock                       *BasicBlockVal;
@@ -1253,47 +1262,63 @@
   llvm::Instruction::MemoryOps      MemOpVal;
   llvm::Instruction::CastOps        CastOpVal;
   llvm::Instruction::OtherOps       OtherOpVal;
-  llvm::Module::Endianness          Endianness;
   llvm::ICmpInst::Predicate         IPredicate;
   llvm::FCmpInst::Predicate         FPredicate;
-} yystype;
-/* Line 188 of /usr/local/share/bison/yacc.c.  */
-#line 1262 "llvmAsmParser.tab.c"
-# define YYSTYPE yystype
+} YYSTYPE;
+/* Line 196 of yacc.c.  */
+#line 1270 "llvmAsmParser.tab.c"
+# define yystype YYSTYPE /* obsolescent; will be withdrawn */
+# define YYSTYPE_IS_DECLARED 1
 # define YYSTYPE_IS_TRIVIAL 1
 #endif
 
-#ifndef YYLTYPE
-typedef struct yyltype
-{
-  int first_line;
-  int first_column;
-  int last_line;
-  int last_column;
-} yyltype;
-# define YYLTYPE yyltype
-# define YYLTYPE_IS_TRIVIAL 1
-#endif
+
 
 /* Copy the second part of user declarations.  */
 
 
-/* Line 213 of /usr/local/share/bison/yacc.c.  */
-#line 1283 "llvmAsmParser.tab.c"
+/* Line 219 of yacc.c.  */
+#line 1282 "llvmAsmParser.tab.c"
+
+#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
+# define YYSIZE_T __SIZE_TYPE__
+#endif
+#if ! defined (YYSIZE_T) && defined (size_t)
+# define YYSIZE_T size_t
+#endif
+#if ! defined (YYSIZE_T) && (defined (__STDC__) || defined (__cplusplus))
+# include  /* INFRINGES ON USER NAME SPACE */
+# define YYSIZE_T size_t
+#endif
+#if ! defined (YYSIZE_T)
+# define YYSIZE_T unsigned int
+#endif
+
+#ifndef YY_
+# if YYENABLE_NLS
+#  if ENABLE_NLS
+#   include  /* INFRINGES ON USER NAME SPACE */
+#   define YY_(msgid) dgettext ("bison-runtime", msgid)
+#  endif
+# endif
+# ifndef YY_
+#  define YY_(msgid) msgid
+# endif
+#endif
 
 #if ! defined (yyoverflow) || YYERROR_VERBOSE
 
 /* The parser invokes alloca or malloc; define the necessary symbols.  */
 
-# if YYSTACK_USE_ALLOCA
-#  define YYSTACK_ALLOC alloca
-# else
-#  ifndef YYSTACK_USE_ALLOCA
-#   if defined (alloca) || defined (_ALLOCA_H)
-#    define YYSTACK_ALLOC alloca
+# ifdef YYSTACK_USE_ALLOCA
+#  if YYSTACK_USE_ALLOCA
+#   ifdef __GNUC__
+#    define YYSTACK_ALLOC __builtin_alloca
 #   else
-#    ifdef __GNUC__
-#     define YYSTACK_ALLOC __builtin_alloca
+#    define YYSTACK_ALLOC alloca
+#    if defined (__STDC__) || defined (__cplusplus)
+#     include  /* INFRINGES ON USER NAME SPACE */
+#     define YYINCLUDED_STDLIB_H
 #    endif
 #   endif
 #  endif
@@ -1302,50 +1327,76 @@
 # ifdef YYSTACK_ALLOC
    /* Pacify GCC's `empty if-body' warning. */
 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
+#  ifndef YYSTACK_ALLOC_MAXIMUM
+    /* The OS might guarantee only one guard page at the bottom of the stack,
+       and a page size can be as small as 4096 bytes.  So we cannot safely
+       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
+       to allow for a few compiler-allocated temporary stack slots.  */
+#   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2005 */
+#  endif
 # else
-#  if defined (__STDC__) || defined (__cplusplus)
-#   include  /* INFRINGES ON USER NAME SPACE */
-#   define YYSIZE_T size_t
+#  define YYSTACK_ALLOC YYMALLOC
+#  define YYSTACK_FREE YYFREE
+#  ifndef YYSTACK_ALLOC_MAXIMUM
+#   define YYSTACK_ALLOC_MAXIMUM ((YYSIZE_T) -1)
+#  endif
+#  ifdef __cplusplus
+extern "C" {
+#  endif
+#  ifndef YYMALLOC
+#   define YYMALLOC malloc
+#   if (! defined (malloc) && ! defined (YYINCLUDED_STDLIB_H) \
+	&& (defined (__STDC__) || defined (__cplusplus)))
+void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
+#   endif
+#  endif
+#  ifndef YYFREE
+#   define YYFREE free
+#   if (! defined (free) && ! defined (YYINCLUDED_STDLIB_H) \
+	&& (defined (__STDC__) || defined (__cplusplus)))
+void free (void *); /* INFRINGES ON USER NAME SPACE */
+#   endif
+#  endif
+#  ifdef __cplusplus
+}
 #  endif
-#  define YYSTACK_ALLOC malloc
-#  define YYSTACK_FREE free
 # endif
 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
 
 
 #if (! defined (yyoverflow) \
      && (! defined (__cplusplus) \
-	 || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
+	 || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
 
 /* A type that is properly aligned for any stack member.  */
 union yyalloc
 {
-  short yyss;
+  short int yyss;
   YYSTYPE yyvs;
   };
 
 /* The size of the maximum gap between one aligned stack and the next.  */
-# define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1)
+# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
 
 /* The size of an array large to enough to hold all stacks, each with
    N elements.  */
 # define YYSTACK_BYTES(N) \
-     ((N) * (sizeof (short) + sizeof (YYSTYPE))				\
-      + YYSTACK_GAP_MAX)
+     ((N) * (sizeof (short int) + sizeof (YYSTYPE))			\
+      + YYSTACK_GAP_MAXIMUM)
 
 /* Copy COUNT objects from FROM to TO.  The source and destination do
    not overlap.  */
 # ifndef YYCOPY
-#  if 1 < __GNUC__
+#  if defined (__GNUC__) && 1 < __GNUC__
 #   define YYCOPY(To, From, Count) \
       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
 #  else
 #   define YYCOPY(To, From, Count)		\
       do					\
 	{					\
-	  register YYSIZE_T yyi;		\
+	  YYSIZE_T yyi;				\
 	  for (yyi = 0; yyi < (Count); yyi++)	\
-	    (To)[yyi] = (From)[yyi];	\
+	    (To)[yyi] = (From)[yyi];		\
 	}					\
       while (0)
 #  endif
@@ -1362,7 +1413,7 @@
 	YYSIZE_T yynewbytes;						\
 	YYCOPY (&yyptr->Stack, Stack, yysize);				\
 	Stack = &yyptr->Stack;						\
-	yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAX;	\
+	yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
 	yyptr += yynewbytes / sizeof (*yyptr);				\
       }									\
     while (0)
@@ -1372,28 +1423,29 @@
 #if defined (__STDC__) || defined (__cplusplus)
    typedef signed char yysigned_char;
 #else
-   typedef short yysigned_char;
+   typedef short int yysigned_char;
 #endif
 
 /* YYFINAL -- State number of the termination state. */
-#define YYFINAL  36
-#define YYLAST   1357
+#define YYFINAL  40
+/* YYLAST -- Last index in YYTABLE.  */
+#define YYLAST   1476
 
 /* YYNTOKENS -- Number of terminals. */
-#define YYNTOKENS  147
+#define YYNTOKENS  145
 /* YYNNTS -- Number of nonterminals. */
 #define YYNNTS  79
 /* YYNRULES -- Number of rules. */
 #define YYNRULES  285
 /* YYNRULES -- Number of states. */
-#define YYNSTATES  569
+#define YYNSTATES  566
 
 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 #define YYUNDEFTOK  2
-#define YYMAXUTOK   387
+#define YYMAXUTOK   385
 
-#define YYTRANSLATE(X) \
-  ((unsigned)(X) <= YYMAXUTOK ? yytranslate[X] : YYUNDEFTOK)
+#define YYTRANSLATE(YYX)						\
+  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
 
 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
 static const unsigned char yytranslate[] =
@@ -1402,15 +1454,15 @@
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     137,   138,   135,     2,   134,     2,     2,     2,     2,     2,
+     135,   136,   133,     2,   132,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     142,   133,   143,     2,     2,     2,     2,     2,     2,     2,
+     140,   131,   141,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,   139,   136,   141,     2,     2,     2,     2,     2,   146,
+       2,   137,   134,   139,     2,     2,     2,     2,     2,   144,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     140,     2,     2,   144,     2,   145,     2,     2,     2,     2,
+     138,     2,     2,   142,     2,   143,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
@@ -1436,13 +1488,13 @@
       95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
      105,   106,   107,   108,   109,   110,   111,   112,   113,   114,
      115,   116,   117,   118,   119,   120,   121,   122,   123,   124,
-     125,   126,   127,   128,   129,   130,   131,   132
+     125,   126,   127,   128,   129,   130
 };
 
 #if YYDEBUG
 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
    YYRHS.  */
-static const unsigned short yyprhs[] =
+static const unsigned short int yyprhs[] =
 {
        0,     0,     3,     5,     7,     9,    11,    13,    15,    17,
       19,    21,    23,    25,    27,    29,    31,    33,    35,    37,
@@ -1450,213 +1502,214 @@
       59,    61,    63,    65,    67,    69,    71,    73,    75,    77,
       79,    81,    83,    85,    87,    89,    91,    93,    95,    97,
       99,   101,   103,   105,   107,   109,   111,   113,   115,   117,
-     119,   122,   123,   125,   127,   129,   131,   133,   135,   137,
-     139,   140,   142,   143,   145,   147,   148,   150,   152,   154,
-     156,   157,   159,   161,   163,   165,   167,   169,   172,   174,
-     176,   177,   180,   182,   184,   185,   188,   189,   192,   193,
-     197,   200,   201,   203,   204,   208,   210,   213,   215,   217,
-     219,   221,   223,   225,   228,   230,   233,   239,   245,   251,
-     257,   261,   264,   270,   275,   278,   280,   282,   284,   288,
-     290,   294,   296,   297,   299,   303,   308,   312,   316,   321,
-     326,   330,   337,   343,   346,   349,   352,   355,   358,   361,
-     364,   367,   370,   373,   380,   386,   395,   402,   409,   417,
-     425,   432,   439,   448,   457,   461,   463,   465,   467,   469,
-     470,   472,   475,   476,   480,   481,   485,   489,   491,   495,
-     499,   500,   507,   508,   516,   517,   525,   528,   532,   534,
-     536,   538,   542,   546,   550,   554,   558,   562,   564,   565,
-     567,   569,   571,   572,   578,   582,   584,   588,   590,   591,
-     601,   603,   605,   610,   612,   614,   617,   621,   622,   624,
-     626,   628,   630,   632,   634,   636,   638,   640,   644,   646,
-     652,   654,   656,   658,   660,   663,   666,   669,   673,   676,
-     677,   679,   682,   685,   689,   699,   709,   718,   733,   735,
-     737,   744,   750,   753,   760,   768,   772,   778,   779,   780,
-     784,   787,   789,   795,   801,   808,   815,   820,   825,   832,
-     837,   842,   849,   856,   859,   868,   870,   872,   873,   877,
-     884,   888,   895,   898,   903,   910
+     119,   121,   122,   125,   126,   128,   130,   133,   134,   136,
+     138,   140,   142,   144,   146,   148,   150,   151,   153,   154,
+     156,   158,   159,   161,   163,   165,   167,   168,   170,   172,
+     174,   176,   178,   180,   183,   185,   187,   188,   191,   193,
+     195,   196,   199,   200,   203,   204,   208,   211,   212,   214,
+     215,   219,   221,   224,   226,   228,   230,   232,   234,   236,
+     239,   241,   244,   250,   256,   262,   268,   272,   275,   281,
+     286,   289,   291,   293,   295,   299,   301,   305,   307,   308,
+     310,   314,   319,   323,   327,   332,   337,   341,   348,   354,
+     357,   360,   363,   366,   369,   372,   375,   378,   381,   384,
+     391,   397,   406,   413,   420,   428,   436,   443,   450,   459,
+     468,   472,   474,   476,   478,   480,   481,   483,   486,   487,
+     491,   492,   496,   500,   502,   506,   510,   511,   518,   519,
+     527,   528,   536,   539,   543,   545,   549,   553,   557,   561,
+     563,   564,   570,   574,   576,   580,   582,   583,   593,   595,
+     597,   602,   604,   606,   609,   613,   614,   616,   618,   620,
+     622,   624,   626,   628,   630,   632,   636,   638,   644,   646,
+     648,   650,   652,   654,   656,   659,   662,   665,   669,   672,
+     673,   675,   678,   681,   685,   695,   705,   714,   729,   731,
+     733,   740,   746,   749,   756,   764,   768,   774,   775,   776,
+     780,   783,   785,   791,   797,   804,   811,   816,   821,   828,
+     833,   838,   845,   852,   855,   864,   866,   868,   869,   873,
+     880,   884,   891,   894,   899,   906
 };
 
 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
-static const short yyrhs[] =
+static const short int yyrhs[] =
 {
-     185,     0,    -1,     5,    -1,     6,    -1,    69,    -1,    70,
+     186,     0,    -1,    67,    -1,    68,    -1,    69,    -1,    70,
       -1,    71,    -1,    72,    -1,    73,    -1,    74,    -1,    75,
-      -1,    76,    -1,    77,    -1,    78,    -1,    79,    -1,    80,
+      -1,    76,    -1,    77,    -1,    78,    -1,   107,    -1,   108,
       -1,   109,    -1,   110,    -1,   111,    -1,   112,    -1,   113,
       -1,   114,    -1,   115,    -1,   116,    -1,   117,    -1,   118,
-      -1,   119,    -1,   120,    -1,   123,    -1,   124,    -1,   125,
+      -1,   121,    -1,   122,    -1,   123,    -1,    81,    -1,    82,
       -1,    83,    -1,    84,    -1,    85,    -1,    86,    -1,    87,
       -1,    88,    -1,    89,    -1,    90,    -1,    91,    -1,    92,
       -1,    93,    -1,    94,    -1,    95,    -1,    96,    -1,    97,
-      -1,    98,    -1,    99,    -1,   100,    -1,   101,    -1,   102,
-      -1,    89,    -1,    90,    -1,    91,    -1,    92,    -1,    19,
-      -1,    20,    -1,     9,    -1,    10,    -1,    11,    -1,   198,
-     133,    -1,    -1,    33,    -1,    35,    -1,    34,    -1,    36,
-      -1,    38,    -1,    37,    -1,    39,    -1,    41,    -1,    -1,
-     132,    -1,    -1,    37,    -1,    39,    -1,    -1,    33,    -1,
-      34,    -1,    35,    -1,    38,    -1,    -1,    56,    -1,    57,
-      -1,    58,    -1,    59,    -1,    60,    -1,    61,    -1,    55,
-       4,    -1,   110,    -1,   111,    -1,    -1,   165,   164,    -1,
-     130,    -1,   164,    -1,    -1,   167,   166,    -1,    -1,    48,
-       4,    -1,    -1,   134,    48,     4,    -1,    27,    16,    -1,
-      -1,   170,    -1,    -1,   134,   173,   172,    -1,   170,    -1,
-      48,     4,    -1,     9,    -1,    10,    -1,    11,    -1,    12,
-      -1,    40,    -1,   174,    -1,   175,   135,    -1,   210,    -1,
-     136,     4,    -1,   175,   137,   179,   138,   167,    -1,     8,
-     137,   179,   138,   167,    -1,   139,     4,   140,   175,   141,
-      -1,   142,     4,   140,   175,   143,    -1,   144,   180,   145,
-      -1,   144,   145,    -1,   142,   144,   180,   145,   143,    -1,
-     142,   144,   145,   143,    -1,   175,   165,    -1,   175,    -1,
-       8,    -1,   176,    -1,   178,   134,   176,    -1,   178,    -1,
-     178,   134,    30,    -1,    30,    -1,    -1,   175,    -1,   180,
-     134,   175,    -1,   175,   139,   183,   141,    -1,   175,   139,
-     141,    -1,   175,   146,    16,    -1,   175,   142,   183,   143,
-      -1,   175,   144,   183,   145,    -1,   175,   144,   145,    -1,
-     175,   142,   144,   183,   145,   143,    -1,   175,   142,   144,
-     145,   143,    -1,   175,    31,    -1,   175,    32,    -1,   175,
-     210,    -1,   175,   182,    -1,   175,    18,    -1,   155,     3,
-      -1,   155,     4,    -1,     9,    19,    -1,     9,    20,    -1,
-     156,     7,    -1,   151,   137,   181,    29,   175,   138,    -1,
-     108,   137,   181,   221,   138,    -1,   122,   137,   181,   134,
-     181,   134,   181,   138,    -1,   149,   137,   181,   134,   181,
-     138,    -1,   150,   137,   181,   134,   181,   138,    -1,    81,
-     153,   137,   181,   134,   181,   138,    -1,    82,   154,   137,
-     181,   134,   181,   138,    -1,   152,   137,   181,   134,   181,
-     138,    -1,   127,   137,   181,   134,   181,   138,    -1,   128,
-     137,   181,   134,   181,   134,   181,   138,    -1,   129,   137,
-     181,   134,   181,   134,   181,   138,    -1,   183,   134,   181,
-      -1,   181,    -1,    25,    -1,    26,    -1,   186,    -1,    -1,
-     187,    -1,   186,   187,    -1,    -1,    24,   188,   206,    -1,
-      -1,    23,   189,   207,    -1,    53,    52,   193,    -1,    17,
-      -1,   157,    13,   175,    -1,   157,    13,     8,    -1,    -1,
-     157,   160,   184,   181,   190,   172,    -1,    -1,   157,   158,
-     160,   184,   181,   191,   172,    -1,    -1,   157,   159,   160,
-     184,   175,   192,   172,    -1,    42,   195,    -1,    49,   133,
-     196,    -1,    16,    -1,    47,    -1,    46,    -1,    44,   133,
-     194,    -1,    45,   133,     4,    -1,    43,   133,    16,    -1,
-      62,   133,    16,    -1,   139,   197,   141,    -1,   197,   134,
-      16,    -1,    16,    -1,    -1,    14,    -1,    16,    -1,   198,
-      -1,    -1,   200,   134,   175,   165,   199,    -1,   175,   165,
-     199,    -1,   200,    -1,   200,   134,    30,    -1,    30,    -1,
-      -1,   163,   177,   198,   137,   201,   138,   167,   171,   168,
-      -1,    21,    -1,   144,    -1,   162,   160,   202,   203,    -1,
-      22,    -1,   145,    -1,   213,   205,    -1,   161,   160,   202,
-      -1,    -1,    54,    -1,     3,    -1,     4,    -1,     7,    -1,
-      19,    -1,    20,    -1,    31,    -1,    32,    -1,    18,    -1,
-     142,   183,   143,    -1,   182,    -1,    52,   208,    16,   134,
-      16,    -1,   148,    -1,   198,    -1,   210,    -1,   209,    -1,
-     175,   211,    -1,   213,   214,    -1,   204,   214,    -1,   215,
-     157,   216,    -1,   215,   218,    -1,    -1,    15,    -1,    63,
-     212,    -1,    63,     8,    -1,    64,    12,   211,    -1,    64,
-       9,   211,   134,    12,   211,   134,    12,   211,    -1,    65,
-     155,   211,   134,    12,   211,   139,   217,   141,    -1,    65,
-     155,   211,   134,    12,   211,   139,   141,    -1,    66,   163,
-     177,   211,   137,   220,   138,   167,    29,    12,   211,    67,
-      12,   211,    -1,    67,    -1,    68,    -1,   217,   155,   209,
-     134,    12,   211,    -1,   155,   209,   134,    12,   211,    -1,
-     157,   223,    -1,   175,   139,   211,   134,   211,   141,    -1,
-     219,   134,   139,   211,   134,   211,   141,    -1,   175,   211,
-     165,    -1,   220,   134,   175,   211,   165,    -1,    -1,    -1,
-     221,   134,   212,    -1,    51,    50,    -1,    50,    -1,   149,
-     175,   211,   134,   211,    -1,   150,   175,   211,   134,   211,
-      -1,    81,   153,   175,   211,   134,   211,    -1,    82,   154,
-     175,   211,   134,   211,    -1,   152,   212,   134,   212,    -1,
-     151,   212,    29,   175,    -1,   122,   212,   134,   212,   134,
-     212,    -1,   126,   212,   134,   175,    -1,   127,   212,   134,
-     212,    -1,   128,   212,   134,   212,   134,   212,    -1,   129,
-     212,   134,   212,   134,   212,    -1,   121,   219,    -1,   222,
-     163,   177,   211,   137,   220,   138,   167,    -1,   225,    -1,
-      28,    -1,    -1,   103,   175,   169,    -1,   103,   175,   134,
-       9,   211,   169,    -1,   104,   175,   169,    -1,   104,   175,
-     134,     9,   211,   169,    -1,   105,   212,    -1,   224,   106,
-     175,   211,    -1,   224,   107,   212,   134,   175,   211,    -1,
-     108,   175,   211,   221,    -1
+      -1,    98,    -1,    99,    -1,   100,    -1,    87,    -1,    88,
+      -1,    89,    -1,    90,    -1,    21,    -1,    22,    -1,     9,
+      -1,    10,    -1,    11,    -1,    14,    -1,    17,    -1,   154,
+      -1,    -1,   154,   131,    -1,    -1,    15,    -1,    18,    -1,
+     157,   131,    -1,    -1,    35,    -1,    37,    -1,    36,    -1,
+      38,    -1,    40,    -1,    39,    -1,    41,    -1,    43,    -1,
+      -1,   130,    -1,    -1,    39,    -1,    41,    -1,    -1,    35,
+      -1,    36,    -1,    37,    -1,    40,    -1,    -1,    54,    -1,
+      55,    -1,    56,    -1,    57,    -1,    58,    -1,    59,    -1,
+      53,     4,    -1,   108,    -1,   109,    -1,    -1,   166,   165,
+      -1,   128,    -1,   165,    -1,    -1,   168,   167,    -1,    -1,
+      46,     4,    -1,    -1,   132,    46,     4,    -1,    29,    17,
+      -1,    -1,   171,    -1,    -1,   132,   174,   173,    -1,   171,
+      -1,    46,     4,    -1,     9,    -1,    10,    -1,    11,    -1,
+      12,    -1,    42,    -1,   175,    -1,   176,   133,    -1,   208,
+      -1,   134,     4,    -1,   176,   135,   180,   136,   168,    -1,
+       8,   135,   180,   136,   168,    -1,   137,     4,   138,   176,
+     139,    -1,   140,     4,   138,   176,   141,    -1,   142,   181,
+     143,    -1,   142,   143,    -1,   140,   142,   181,   143,   141,
+      -1,   140,   142,   143,   141,    -1,   176,   166,    -1,   176,
+      -1,     8,    -1,   177,    -1,   179,   132,   177,    -1,   179,
+      -1,   179,   132,    32,    -1,    32,    -1,    -1,   176,    -1,
+     181,   132,   176,    -1,   176,   137,   184,   139,    -1,   176,
+     137,   139,    -1,   176,   144,    17,    -1,   176,   140,   184,
+     141,    -1,   176,   142,   184,   143,    -1,   176,   142,   143,
+      -1,   176,   140,   142,   184,   143,   141,    -1,   176,   140,
+     142,   143,   141,    -1,   176,    33,    -1,   176,    34,    -1,
+     176,   208,    -1,   176,   183,    -1,   176,    20,    -1,   152,
+       3,    -1,   152,     4,    -1,     9,    21,    -1,     9,    22,
+      -1,   153,     7,    -1,   148,   135,   182,    31,   176,   136,
+      -1,   106,   135,   182,   219,   136,    -1,   120,   135,   182,
+     132,   182,   132,   182,   136,    -1,   146,   135,   182,   132,
+     182,   136,    -1,   147,   135,   182,   132,   182,   136,    -1,
+      79,   150,   135,   182,   132,   182,   136,    -1,    80,   151,
+     135,   182,   132,   182,   136,    -1,   149,   135,   182,   132,
+     182,   136,    -1,   125,   135,   182,   132,   182,   136,    -1,
+     126,   135,   182,   132,   182,   132,   182,   136,    -1,   127,
+     135,   182,   132,   182,   132,   182,   136,    -1,   184,   132,
+     182,    -1,   182,    -1,    27,    -1,    28,    -1,   187,    -1,
+      -1,   188,    -1,   187,   188,    -1,    -1,    26,   189,   204,
+      -1,    -1,    25,   190,   205,    -1,    51,    50,   194,    -1,
+      19,    -1,   156,    13,   176,    -1,   156,    13,     8,    -1,
+      -1,   158,   161,   185,   182,   191,   173,    -1,    -1,   158,
+     159,   161,   185,   182,   192,   173,    -1,    -1,   158,   160,
+     161,   185,   176,   193,   173,    -1,    44,   195,    -1,    47,
+     131,   196,    -1,    17,    -1,    45,   131,    17,    -1,    60,
+     131,    17,    -1,   137,   197,   139,    -1,   197,   132,    17,
+      -1,    17,    -1,    -1,   198,   132,   176,   166,   155,    -1,
+     176,   166,   155,    -1,   198,    -1,   198,   132,    32,    -1,
+      32,    -1,    -1,   164,   178,   157,   135,   199,   136,   168,
+     172,   169,    -1,    23,    -1,   142,    -1,   163,   161,   200,
+     201,    -1,    24,    -1,   143,    -1,   211,   203,    -1,   162,
+     161,   200,    -1,    -1,    52,    -1,     3,    -1,     4,    -1,
+       7,    -1,    21,    -1,    22,    -1,    33,    -1,    34,    -1,
+      20,    -1,   140,   184,   141,    -1,   183,    -1,    50,   206,
+      17,   132,    17,    -1,     5,    -1,     6,    -1,   154,    -1,
+     157,    -1,   208,    -1,   207,    -1,   176,   209,    -1,   211,
+     212,    -1,   202,   212,    -1,   213,   156,   214,    -1,   213,
+     216,    -1,    -1,    16,    -1,    61,   210,    -1,    61,     8,
+      -1,    62,    12,   209,    -1,    62,     9,   209,   132,    12,
+     209,   132,    12,   209,    -1,    63,   152,   209,   132,    12,
+     209,   137,   215,   139,    -1,    63,   152,   209,   132,    12,
+     209,   137,   139,    -1,    64,   164,   178,   209,   135,   218,
+     136,   168,    31,    12,   209,    65,    12,   209,    -1,    65,
+      -1,    66,    -1,   215,   152,   207,   132,    12,   209,    -1,
+     152,   207,   132,    12,   209,    -1,   156,   221,    -1,   176,
+     137,   209,   132,   209,   139,    -1,   217,   132,   137,   209,
+     132,   209,   139,    -1,   176,   209,   166,    -1,   218,   132,
+     176,   209,   166,    -1,    -1,    -1,   219,   132,   210,    -1,
+      49,    48,    -1,    48,    -1,   146,   176,   209,   132,   209,
+      -1,   147,   176,   209,   132,   209,    -1,    79,   150,   176,
+     209,   132,   209,    -1,    80,   151,   176,   209,   132,   209,
+      -1,   149,   210,   132,   210,    -1,   148,   210,    31,   176,
+      -1,   120,   210,   132,   210,   132,   210,    -1,   124,   210,
+     132,   176,    -1,   125,   210,   132,   210,    -1,   126,   210,
+     132,   210,   132,   210,    -1,   127,   210,   132,   210,   132,
+     210,    -1,   119,   217,    -1,   220,   164,   178,   209,   135,
+     218,   136,   168,    -1,   223,    -1,    30,    -1,    -1,   101,
+     176,   170,    -1,   101,   176,   132,     9,   209,   170,    -1,
+     102,   176,   170,    -1,   102,   176,   132,     9,   209,   170,
+      -1,   103,   210,    -1,   222,   104,   176,   209,    -1,   222,
+     105,   210,   132,   176,   209,    -1,   106,   176,   209,   219,
+      -1
 };
 
 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
-static const unsigned short yyrline[] =
+static const unsigned short int yyrline[] =
 {
-       0,  1031,  1031,  1032,  1042,  1042,  1042,  1042,  1042,  1042,
-    1042,  1042,  1042,  1043,  1043,  1043,  1044,  1044,  1044,  1044,
-    1044,  1044,  1044,  1045,  1045,  1045,  1045,  1045,  1046,  1046,
-    1046,  1048,  1048,  1049,  1049,  1050,  1050,  1051,  1051,  1052,
-    1052,  1056,  1056,  1057,  1057,  1058,  1058,  1059,  1059,  1060,
-    1060,  1061,  1061,  1062,  1062,  1063,  1064,  1069,  1070,  1070,
-    1073,  1077,  1083,  1084,  1085,  1086,  1087,  1091,  1092,  1093,
-    1097,  1098,  1102,  1103,  1104,  1108,  1109,  1110,  1111,  1112,
-    1115,  1115,  1116,  1117,  1118,  1119,  1120,  1121,  1129,  1130,
-    1133,  1134,  1139,  1140,  1143,  1144,  1151,  1151,  1158,  1158,
-    1167,  1175,  1175,  1181,  1181,  1183,  1188,  1201,  1201,  1201,
-    1201,  1204,  1208,  1212,  1219,  1224,  1232,  1250,  1268,  1273,
-    1285,  1295,  1299,  1309,  1316,  1323,  1330,  1335,  1340,  1347,
-    1348,  1355,  1362,  1370,  1375,  1386,  1414,  1430,  1459,  1487,
-    1512,  1531,  1556,  1575,  1587,  1594,  1657,  1667,  1677,  1683,
-    1689,  1694,  1699,  1707,  1719,  1740,  1748,  1754,  1765,  1770,
-    1775,  1784,  1790,  1796,  1805,  1809,  1817,  1817,  1828,  1833,
-    1841,  1842,  1846,  1846,  1850,  1850,  1853,  1856,  1868,  1892,
-    1903,  1903,  1912,  1912,  1920,  1920,  1930,  1933,  1939,  1952,
-    1953,  1955,  1959,  1968,  1972,  1977,  1979,  1984,  1989,  1998,
-    1998,  1999,  1999,  2001,  2011,  2022,  2026,  2035,  2044,  2049,
-    2155,  2155,  2157,  2166,  2166,  2168,  2173,  2185,  2189,  2194,
-    2198,  2202,  2206,  2210,  2214,  2218,  2222,  2226,  2251,  2255,
-    2269,  2273,  2279,  2279,  2285,  2294,  2298,  2307,  2318,  2327,
-    2339,  2352,  2356,  2360,  2365,  2375,  2394,  2403,  2470,  2474,
-    2481,  2492,  2505,  2514,  2525,  2535,  2543,  2551,  2554,  2555,
-    2562,  2566,  2571,  2592,  2609,  2622,  2635,  2644,  2656,  2664,
-    2671,  2677,  2683,  2689,  2704,  2767,  2772,  2776,  2783,  2790,
-    2798,  2805,  2813,  2821,  2835,  2852
+       0,  1032,  1032,  1032,  1032,  1032,  1032,  1032,  1032,  1032,
+    1032,  1033,  1033,  1033,  1034,  1034,  1034,  1034,  1034,  1034,
+    1035,  1035,  1035,  1035,  1035,  1035,  1036,  1036,  1036,  1038,
+    1038,  1039,  1039,  1040,  1040,  1041,  1041,  1042,  1042,  1046,
+    1046,  1047,  1047,  1048,  1048,  1049,  1049,  1050,  1050,  1051,
+    1051,  1052,  1052,  1053,  1054,  1059,  1060,  1060,  1062,  1062,
+    1063,  1063,  1067,  1071,  1076,  1076,  1078,  1082,  1088,  1089,
+    1090,  1091,  1092,  1096,  1097,  1098,  1102,  1103,  1107,  1108,
+    1109,  1113,  1114,  1115,  1116,  1117,  1120,  1121,  1122,  1123,
+    1124,  1125,  1126,  1127,  1134,  1135,  1138,  1139,  1144,  1145,
+    1148,  1149,  1156,  1157,  1163,  1164,  1172,  1180,  1181,  1186,
+    1187,  1188,  1193,  1206,  1206,  1206,  1206,  1209,  1213,  1217,
+    1224,  1229,  1237,  1255,  1273,  1278,  1290,  1300,  1304,  1314,
+    1321,  1328,  1335,  1340,  1345,  1352,  1353,  1360,  1367,  1375,
+    1380,  1391,  1419,  1435,  1464,  1492,  1517,  1536,  1561,  1580,
+    1592,  1599,  1665,  1675,  1685,  1691,  1697,  1702,  1707,  1715,
+    1727,  1748,  1756,  1762,  1773,  1778,  1783,  1792,  1798,  1804,
+    1813,  1817,  1825,  1825,  1836,  1841,  1849,  1850,  1854,  1854,
+    1858,  1858,  1861,  1864,  1876,  1900,  1911,  1911,  1921,  1921,
+    1929,  1929,  1939,  1942,  1948,  1961,  1965,  1970,  1972,  1977,
+    1982,  1991,  2001,  2012,  2016,  2025,  2034,  2039,  2145,  2145,
+    2147,  2156,  2156,  2158,  2163,  2175,  2179,  2184,  2188,  2192,
+    2196,  2200,  2204,  2208,  2212,  2216,  2241,  2245,  2259,  2263,
+    2267,  2271,  2277,  2277,  2283,  2292,  2296,  2305,  2316,  2325,
+    2337,  2350,  2354,  2358,  2363,  2373,  2392,  2401,  2468,  2472,
+    2479,  2490,  2503,  2512,  2523,  2533,  2541,  2549,  2552,  2553,
+    2560,  2564,  2569,  2590,  2607,  2620,  2633,  2642,  2654,  2662,
+    2669,  2675,  2681,  2687,  2702,  2766,  2771,  2775,  2782,  2789,
+    2797,  2804,  2812,  2820,  2834,  2851
 };
 #endif
 
-#if YYDEBUG || YYERROR_VERBOSE
-/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
+#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
+/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
    First, the terminals, then, starting at YYNTOKENS, nonterminals. */
 static const char *const yytname[] =
 {
-  "$end", "error", "$undefined", "ESINT64VAL", "EUINT64VAL", "SINTVAL", 
-  "UINTVAL", "FPVAL", "VOID", "INTTYPE", "FLOAT", "DOUBLE", "LABEL", 
-  "TYPE", "VAR_ID", "LABELSTR", "STRINGCONSTANT", "IMPLEMENTATION", 
-  "ZEROINITIALIZER", "TRUETOK", "FALSETOK", "BEGINTOK", "ENDTOK", 
-  "DECLARE", "DEFINE", "GLOBAL", "CONSTANT", "SECTION", "VOLATILE", "TO", 
-  "DOTDOTDOT", "NULL_TOK", "UNDEF", "INTERNAL", "LINKONCE", "WEAK", 
-  "APPENDING", "DLLIMPORT", "DLLEXPORT", "EXTERN_WEAK", "OPAQUE", 
-  "EXTERNAL", "TARGET", "TRIPLE", "ENDIAN", "POINTERSIZE", "LITTLE", 
-  "BIG", "ALIGN", "DEPLIBS", "CALL", "TAIL", "ASM_TOK", "MODULE", 
-  "SIDEEFFECT", "CC_TOK", "CCC_TOK", "CSRETCC_TOK", "FASTCC_TOK", 
-  "COLDCC_TOK", "X86_STDCALLCC_TOK", "X86_FASTCALLCC_TOK", "DATALAYOUT", 
-  "RET", "BR", "SWITCH", "INVOKE", "UNWIND", "UNREACHABLE", "ADD", "SUB", 
-  "MUL", "UDIV", "SDIV", "FDIV", "UREM", "SREM", "FREM", "AND", "OR", 
-  "XOR", "ICMP", "FCMP", "EQ", "NE", "SLT", "SGT", "SLE", "SGE", "ULT", 
-  "UGT", "ULE", "UGE", "OEQ", "ONE", "OLT", "OGT", "OLE", "OGE", "ORD", 
-  "UNO", "UEQ", "UNE", "MALLOC", "ALLOCA", "FREE", "LOAD", "STORE", 
-  "GETELEMENTPTR", "TRUNC", "ZEXT", "SEXT", "FPTRUNC", "FPEXT", "BITCAST", 
-  "UITOFP", "SITOFP", "FPTOUI", "FPTOSI", "INTTOPTR", "PTRTOINT", 
-  "PHI_TOK", "SELECT", "SHL", "LSHR", "ASHR", "VAARG", "EXTRACTELEMENT", 
-  "INSERTELEMENT", "SHUFFLEVECTOR", "NORETURN", "DEFAULT", "HIDDEN", 
-  "'='", "','", "'*'", "'\\\\'", "'('", "')'", "'['", "'x'", "']'", "'<'", 
-  "'>'", "'{'", "'}'", "'c'", "$accept", "INTVAL", "ArithmeticOps", 
-  "LogicalOps", "CastOps", "ShiftOps", "IPredicates", "FPredicates", 
-  "IntType", "FPType", "OptAssign", "GVInternalLinkage", 
-  "GVExternalLinkage", "GVVisibilityStyle", "FunctionDeclareLinkage", 
-  "FunctionDefineLinkage", "OptCallingConv", "ParamAttr", "OptParamAttrs", 
-  "FuncAttr", "OptFuncAttrs", "OptAlign", "OptCAlign", "SectionString", 
-  "OptSection", "GlobalVarAttributes", "GlobalVarAttribute", "PrimType", 
-  "Types", "ArgType", "ResultTypes", "ArgTypeList", "ArgTypeListI", 
-  "TypeListI", "ConstVal", "ConstExpr", "ConstVector", "GlobalType", 
-  "Module", "DefinitionList", "Definition", "@1", "@2", "@3", "@4", "@5", 
-  "AsmBlock", "BigOrLittle", "TargetDefinition", "LibrariesDefinition", 
-  "LibList", "Name", "OptName", "ArgListH", "ArgList", "FunctionHeaderH", 
-  "BEGIN", "FunctionHeader", "END", "Function", "FunctionProto", 
-  "OptSideEffect", "ConstValueRef", "SymbolicValueRef", "ValueRef", 
-  "ResolvedVal", "BasicBlockList", "BasicBlock", "InstructionList", 
-  "BBTerminatorInst", "JumpTable", "Inst", "PHIList", "ValueRefList", 
-  "IndexList", "OptTailCall", "InstVal", "OptVolatile", "MemoryInst", 0
+  "$end", "error", "$undefined", "ESINT64VAL", "EUINT64VAL",
+  "LOCALVAL_ID", "GLOBALVAL_ID", "FPVAL", "VOID", "INTTYPE", "FLOAT",
+  "DOUBLE", "LABEL", "TYPE", "LOCALVAR", "GLOBALVAR", "LABELSTR",
+  "STRINGCONSTANT", "ATSTRINGCONSTANT", "IMPLEMENTATION",
+  "ZEROINITIALIZER", "TRUETOK", "FALSETOK", "BEGINTOK", "ENDTOK",
+  "DECLARE", "DEFINE", "GLOBAL", "CONSTANT", "SECTION", "VOLATILE", "TO",
+  "DOTDOTDOT", "NULL_TOK", "UNDEF", "INTERNAL", "LINKONCE", "WEAK",
+  "APPENDING", "DLLIMPORT", "DLLEXPORT", "EXTERN_WEAK", "OPAQUE",
+  "EXTERNAL", "TARGET", "TRIPLE", "ALIGN", "DEPLIBS", "CALL", "TAIL",
+  "ASM_TOK", "MODULE", "SIDEEFFECT", "CC_TOK", "CCC_TOK", "CSRETCC_TOK",
+  "FASTCC_TOK", "COLDCC_TOK", "X86_STDCALLCC_TOK", "X86_FASTCALLCC_TOK",
+  "DATALAYOUT", "RET", "BR", "SWITCH", "INVOKE", "UNWIND", "UNREACHABLE",
+  "ADD", "SUB", "MUL", "UDIV", "SDIV", "FDIV", "UREM", "SREM", "FREM",
+  "AND", "OR", "XOR", "ICMP", "FCMP", "EQ", "NE", "SLT", "SGT", "SLE",
+  "SGE", "ULT", "UGT", "ULE", "UGE", "OEQ", "ONE", "OLT", "OGT", "OLE",
+  "OGE", "ORD", "UNO", "UEQ", "UNE", "MALLOC", "ALLOCA", "FREE", "LOAD",
+  "STORE", "GETELEMENTPTR", "TRUNC", "ZEXT", "SEXT", "FPTRUNC", "FPEXT",
+  "BITCAST", "UITOFP", "SITOFP", "FPTOUI", "FPTOSI", "INTTOPTR",
+  "PTRTOINT", "PHI_TOK", "SELECT", "SHL", "LSHR", "ASHR", "VAARG",
+  "EXTRACTELEMENT", "INSERTELEMENT", "SHUFFLEVECTOR", "NORETURN",
+  "DEFAULT", "HIDDEN", "'='", "','", "'*'", "'\\\\'", "'('", "')'", "'['",
+  "'x'", "']'", "'<'", "'>'", "'{'", "'}'", "'c'", "$accept",
+  "ArithmeticOps", "LogicalOps", "CastOps", "ShiftOps", "IPredicates",
+  "FPredicates", "IntType", "FPType", "LocalName", "OptLocalName",
+  "OptLocalAssign", "GlobalName", "OptGlobalAssign", "GVInternalLinkage",
+  "GVExternalLinkage", "GVVisibilityStyle", "FunctionDeclareLinkage",
+  "FunctionDefineLinkage", "OptCallingConv", "ParamAttr", "OptParamAttrs",
+  "FuncAttr", "OptFuncAttrs", "OptAlign", "OptCAlign", "SectionString",
+  "OptSection", "GlobalVarAttributes", "GlobalVarAttribute", "PrimType",
+  "Types", "ArgType", "ResultTypes", "ArgTypeList", "ArgTypeListI",
+  "TypeListI", "ConstVal", "ConstExpr", "ConstVector", "GlobalType",
+  "Module", "DefinitionList", "Definition", "@1", "@2", "@3", "@4", "@5",
+  "AsmBlock", "TargetDefinition", "LibrariesDefinition", "LibList",
+  "ArgListH", "ArgList", "FunctionHeaderH", "BEGIN", "FunctionHeader",
+  "END", "Function", "FunctionProto", "OptSideEffect", "ConstValueRef",
+  "SymbolicValueRef", "ValueRef", "ResolvedVal", "BasicBlockList",
+  "BasicBlock", "InstructionList", "BBTerminatorInst", "JumpTable", "Inst",
+  "PHIList", "ValueRefList", "IndexList", "OptTailCall", "InstVal",
+  "OptVolatile", "MemoryInst", 0
 };
 #endif
 
 # ifdef YYPRINT
 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
    token YYLEX-NUM.  */
-static const unsigned short yytoknum[] =
+static const unsigned short int yytoknum[] =
 {
        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
@@ -1671,43 +1724,43 @@
      355,   356,   357,   358,   359,   360,   361,   362,   363,   364,
      365,   366,   367,   368,   369,   370,   371,   372,   373,   374,
      375,   376,   377,   378,   379,   380,   381,   382,   383,   384,
-     385,   386,   387,    61,    44,    42,    92,    40,    41,    91,
-     120,    93,    60,    62,   123,   125,    99
+     385,    61,    44,    42,    92,    40,    41,    91,   120,    93,
+      60,    62,   123,   125,    99
 };
 # endif
 
 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
 static const unsigned char yyr1[] =
 {
-       0,   147,   148,   148,   149,   149,   149,   149,   149,   149,
-     149,   149,   149,   150,   150,   150,   151,   151,   151,   151,
-     151,   151,   151,   151,   151,   151,   151,   151,   152,   152,
-     152,   153,   153,   153,   153,   153,   153,   153,   153,   153,
-     153,   154,   154,   154,   154,   154,   154,   154,   154,   154,
-     154,   154,   154,   154,   154,   154,   154,   155,   156,   156,
-     157,   157,   158,   158,   158,   158,   158,   159,   159,   159,
-     160,   160,   161,   161,   161,   162,   162,   162,   162,   162,
-     163,   163,   163,   163,   163,   163,   163,   163,   164,   164,
-     165,   165,   166,   166,   167,   167,   168,   168,   169,   169,
-     170,   171,   171,   172,   172,   173,   173,   174,   174,   174,
-     174,   175,   175,   175,   175,   175,   175,   175,   175,   175,
-     175,   175,   175,   175,   176,   177,   177,   178,   178,   179,
-     179,   179,   179,   180,   180,   181,   181,   181,   181,   181,
-     181,   181,   181,   181,   181,   181,   181,   181,   181,   181,
-     181,   181,   181,   182,   182,   182,   182,   182,   182,   182,
-     182,   182,   182,   182,   183,   183,   184,   184,   185,   185,
-     186,   186,   188,   187,   189,   187,   187,   187,   187,   187,
-     190,   187,   191,   187,   192,   187,   187,   187,   193,   194,
-     194,   195,   195,   195,   195,   196,   197,   197,   197,   198,
-     198,   199,   199,   200,   200,   201,   201,   201,   201,   202,
-     203,   203,   204,   205,   205,   206,   207,   208,   208,   209,
-     209,   209,   209,   209,   209,   209,   209,   209,   209,   209,
-     210,   210,   211,   211,   212,   213,   213,   214,   215,   215,
-     215,   216,   216,   216,   216,   216,   216,   216,   216,   216,
-     217,   217,   218,   219,   219,   220,   220,   220,   221,   221,
-     222,   222,   223,   223,   223,   223,   223,   223,   223,   223,
-     223,   223,   223,   223,   223,   223,   224,   224,   225,   225,
-     225,   225,   225,   225,   225,   225
+       0,   145,   146,   146,   146,   146,   146,   146,   146,   146,
+     146,   147,   147,   147,   148,   148,   148,   148,   148,   148,
+     148,   148,   148,   148,   148,   148,   149,   149,   149,   150,
+     150,   150,   150,   150,   150,   150,   150,   150,   150,   151,
+     151,   151,   151,   151,   151,   151,   151,   151,   151,   151,
+     151,   151,   151,   151,   151,   152,   153,   153,   154,   154,
+     155,   155,   156,   156,   157,   157,   158,   158,   159,   159,
+     159,   159,   159,   160,   160,   160,   161,   161,   162,   162,
+     162,   163,   163,   163,   163,   163,   164,   164,   164,   164,
+     164,   164,   164,   164,   165,   165,   166,   166,   167,   167,
+     168,   168,   169,   169,   170,   170,   171,   172,   172,   173,
+     173,   174,   174,   175,   175,   175,   175,   176,   176,   176,
+     176,   176,   176,   176,   176,   176,   176,   176,   176,   176,
+     177,   178,   178,   179,   179,   180,   180,   180,   180,   181,
+     181,   182,   182,   182,   182,   182,   182,   182,   182,   182,
+     182,   182,   182,   182,   182,   182,   182,   182,   182,   183,
+     183,   183,   183,   183,   183,   183,   183,   183,   183,   183,
+     184,   184,   185,   185,   186,   186,   187,   187,   189,   188,
+     190,   188,   188,   188,   188,   188,   191,   188,   192,   188,
+     193,   188,   188,   188,   194,   195,   195,   196,   197,   197,
+     197,   198,   198,   199,   199,   199,   199,   200,   201,   201,
+     202,   203,   203,   204,   205,   206,   206,   207,   207,   207,
+     207,   207,   207,   207,   207,   207,   207,   207,   208,   208,
+     208,   208,   209,   209,   210,   211,   211,   212,   213,   213,
+     213,   214,   214,   214,   214,   214,   214,   214,   214,   214,
+     215,   215,   216,   217,   217,   218,   218,   218,   219,   219,
+     220,   220,   221,   221,   221,   221,   221,   221,   221,   221,
+     221,   221,   221,   221,   221,   221,   222,   222,   223,   223,
+     223,   223,   223,   223,   223,   223
 };
 
 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
@@ -1719,23 +1772,23 @@
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       2,     0,     1,     1,     1,     1,     1,     1,     1,     1,
-       0,     1,     0,     1,     1,     0,     1,     1,     1,     1,
-       0,     1,     1,     1,     1,     1,     1,     2,     1,     1,
-       0,     2,     1,     1,     0,     2,     0,     2,     0,     3,
-       2,     0,     1,     0,     3,     1,     2,     1,     1,     1,
-       1,     1,     1,     2,     1,     2,     5,     5,     5,     5,
-       3,     2,     5,     4,     2,     1,     1,     1,     3,     1,
-       3,     1,     0,     1,     3,     4,     3,     3,     4,     4,
-       3,     6,     5,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     6,     5,     8,     6,     6,     7,     7,
-       6,     6,     8,     8,     3,     1,     1,     1,     1,     0,
-       1,     2,     0,     3,     0,     3,     3,     1,     3,     3,
-       0,     6,     0,     7,     0,     7,     2,     3,     1,     1,
-       1,     3,     3,     3,     3,     3,     3,     1,     0,     1,
-       1,     1,     0,     5,     3,     1,     3,     1,     0,     9,
-       1,     1,     4,     1,     1,     2,     3,     0,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     3,     1,     5,
+       1,     0,     2,     0,     1,     1,     2,     0,     1,     1,
+       1,     1,     1,     1,     1,     1,     0,     1,     0,     1,
+       1,     0,     1,     1,     1,     1,     0,     1,     1,     1,
+       1,     1,     1,     2,     1,     1,     0,     2,     1,     1,
+       0,     2,     0,     2,     0,     3,     2,     0,     1,     0,
+       3,     1,     2,     1,     1,     1,     1,     1,     1,     2,
+       1,     2,     5,     5,     5,     5,     3,     2,     5,     4,
+       2,     1,     1,     1,     3,     1,     3,     1,     0,     1,
+       3,     4,     3,     3,     4,     4,     3,     6,     5,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     6,
+       5,     8,     6,     6,     7,     7,     6,     6,     8,     8,
+       3,     1,     1,     1,     1,     0,     1,     2,     0,     3,
+       0,     3,     3,     1,     3,     3,     0,     6,     0,     7,
+       0,     7,     2,     3,     1,     3,     3,     3,     3,     1,
+       0,     5,     3,     1,     3,     1,     0,     9,     1,     1,
+       4,     1,     1,     2,     3,     0,     1,     1,     1,     1,
+       1,     1,     1,     1,     1,     3,     1,     5,     1,     1,
        1,     1,     1,     1,     2,     2,     2,     3,     2,     0,
        1,     2,     2,     3,     9,     9,     8,    14,     1,     1,
        6,     5,     2,     6,     7,     3,     5,     0,     0,     3,
@@ -1747,529 +1800,538 @@
 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
    means the default is an error.  */
-static const unsigned short yydefact[] =
+static const unsigned short int yydefact[] =
 {
-      61,   199,   200,   177,   174,   172,     0,     0,     0,    70,
-       0,    61,   170,     0,    72,    75,     0,     0,     0,     0,
-     186,     0,     0,     0,    62,    64,    63,    65,    67,    66,
-      68,    69,    71,    70,    70,     0,     1,   171,    60,    73,
-      74,    70,   175,    76,    77,    78,    79,    70,   239,   173,
-     239,     0,     0,     0,     0,   198,   187,   188,   176,     2,
-       3,   179,   107,   108,   109,   110,   111,     0,     0,     0,
-       0,   230,   112,   178,   231,   114,     0,     0,   166,   167,
-       0,    80,    80,   240,   236,    61,   213,   214,   215,   235,
-     193,   190,   189,   191,   192,   194,   197,     0,   132,   115,
-       0,     0,     0,     0,   121,   133,     0,   113,   132,     0,
-       0,   107,   108,   109,     0,     0,     0,   180,     0,    81,
-      82,    83,    84,    85,    86,     0,   216,     0,   277,   238,
-       0,   195,   131,    90,   127,   129,     0,     0,     0,     0,
-       0,     0,   120,     0,   182,   184,   150,   151,   148,   149,
-     152,   147,   143,   144,     4,     5,     6,     7,     8,     9,
-      10,    11,    12,    13,    14,    15,     0,     0,     0,    16,
-      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
-      27,     0,    28,    29,    30,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   146,   145,   103,    87,
-     126,   125,     0,   210,   211,   212,   276,   261,     0,     0,
-       0,     0,    80,   248,   249,     0,     0,     0,     0,     0,
+      67,    58,    64,    59,    65,   183,   180,   178,     0,     0,
+       0,     0,     0,     0,    76,     0,    67,   176,    78,    81,
+       0,     0,   192,     0,     0,    62,     0,    66,    68,    70,
+      69,    71,    73,    72,    74,    75,    77,    76,    76,     0,
+       1,   177,    79,    80,    76,   181,    82,    83,    84,    85,
+      76,   239,   179,   239,     0,     0,   200,   193,   194,   182,
+     228,   229,   185,   113,   114,   115,   116,   117,     0,     0,
+       0,     0,   230,   231,   118,   184,   120,     0,     0,   172,
+     173,     0,    86,    86,   240,   236,    63,   211,   212,   213,
+     235,   195,   196,   199,     0,   138,   121,     0,     0,     0,
+       0,   127,   139,     0,   119,   138,     0,     0,   113,   114,
+     115,     0,     0,     0,   186,     0,    87,    88,    89,    90,
+      91,    92,     0,   214,     0,   277,   238,     0,   197,   137,
+      96,   133,   135,     0,     0,     0,     0,     0,     0,   126,
+       0,   188,   190,   156,   157,   154,   155,   158,   153,   149,
+     150,     2,     3,     4,     5,     6,     7,     8,     9,    10,
+      11,    12,    13,     0,     0,     0,    14,    15,    16,    17,
+      18,    19,    20,    21,    22,    23,    24,    25,     0,    26,
+      27,    28,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   152,   151,   109,    93,   132,   131,     0,
+     208,   209,   210,   276,   261,     0,     0,     0,     0,    86,
+     248,   249,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   237,    86,
+     252,     0,   275,   198,   130,     0,   100,     0,     0,   129,
+       0,   140,   100,   109,   109,    29,    30,    31,    32,    33,
+      34,    35,    36,    37,    38,     0,    53,    54,    49,    50,
+      51,    52,    39,    40,    41,    42,    43,    44,    45,    46,
+      47,    48,     0,     0,     0,     0,     0,     0,   142,   171,
+       0,     0,     0,   146,     0,   143,     0,     0,     0,     0,
+       0,   187,     0,   260,   242,     0,   241,     0,     0,    55,
+       0,     0,     0,     0,   104,   104,   282,     0,     0,   273,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   237,    80,   252,     0,   275,   196,   124,     0,    94,
-       0,     0,   123,     0,   134,    94,   103,   103,    31,    32,
-      33,    34,    35,    36,    37,    38,    39,    40,     0,    55,
-      56,    51,    52,    53,    54,    41,    42,    43,    44,    45,
-      46,    47,    48,    49,    50,     0,     0,     0,     0,     0,
-       0,   136,   165,     0,     0,     0,   140,     0,   137,     0,
-       0,     0,     0,     0,   181,     0,   260,   242,     0,   241,
-       0,     0,    57,     0,     0,     0,     0,    98,    98,   282,
-       0,     0,   273,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,    88,    89,    91,   130,   128,
-     117,   118,   119,   122,   116,   183,   185,     0,     0,   258,
-       0,     0,     0,     0,     0,   135,   121,   133,     0,   138,
-     139,     0,     0,     0,     0,     0,     0,   105,   103,   208,
-     219,   220,   221,   226,   222,   223,   224,   225,   217,     0,
-     228,   233,   232,   234,     0,   243,     0,     0,     0,     0,
-       0,   278,     0,   280,   258,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,    92,
-      93,    95,     0,     0,     0,     0,     0,     0,     0,   164,
-     142,     0,     0,     0,     0,     0,   100,   106,   104,   207,
-      90,   205,     0,   218,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   285,     0,     0,     0,   269,   270,
-       0,     0,     0,     0,   267,   266,     0,   283,     0,     0,
-       0,     0,   154,     0,     0,     0,     0,   141,     0,     0,
-       0,     0,   202,     0,    94,     0,   227,     0,     0,   257,
-       0,     0,    98,    99,    98,     0,     0,     0,     0,     0,
-     262,   263,   257,     0,     0,     0,   259,     0,   161,     0,
-       0,   156,   157,   153,   160,   201,   204,   206,    90,   101,
-       0,     0,     0,     0,     0,   264,   265,     0,   279,   281,
-       0,     0,   268,   271,   272,     0,   284,   158,   159,     0,
-       0,     0,   202,   102,    96,   229,     0,     0,    90,     0,
-      94,   253,     0,    94,   155,   162,   163,   203,     0,   209,
-       0,   246,     0,     0,   255,     0,     0,   254,   274,    97,
-     244,     0,   245,     0,    90,     0,     0,     0,   256,     0,
-       0,     0,     0,   251,     0,     0,   250,     0,   247
+       0,     0,    94,    95,    97,   136,   134,   123,   124,   125,
+     128,   122,   189,   191,     0,     0,   258,     0,     0,     0,
+       0,     0,   141,   127,   139,     0,   144,   145,     0,     0,
+       0,     0,     0,     0,   111,   109,   206,   217,   218,   219,
+     224,   220,   221,   222,   223,   215,     0,   226,   233,   232,
+     234,     0,   243,     0,     0,     0,     0,     0,   278,     0,
+     280,   258,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,    98,    99,   101,     0,
+       0,     0,     0,     0,     0,     0,   170,   148,     0,     0,
+       0,     0,     0,   106,   112,   110,   205,    96,   203,     0,
+     216,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,   285,     0,     0,     0,   269,   270,     0,     0,     0,
+       0,   267,   266,     0,   283,     0,     0,     0,     0,   160,
+       0,     0,     0,     0,   147,     0,     0,     0,     0,    61,
+       0,   100,     0,   225,     0,     0,   257,     0,     0,   104,
+     105,   104,     0,     0,     0,     0,     0,   262,   263,   257,
+       0,     0,     0,   259,     0,   167,     0,     0,   162,   163,
+     159,   166,    60,   202,   204,    96,   107,     0,     0,     0,
+       0,     0,   264,   265,     0,   279,   281,     0,     0,   268,
+     271,   272,     0,   284,   164,   165,     0,     0,     0,    61,
+     108,   102,   227,     0,     0,    96,     0,   100,   253,     0,
+     100,   161,   168,   169,   201,     0,   207,     0,   246,     0,
+       0,   255,     0,     0,   254,   274,   103,   244,     0,   245,
+       0,    96,     0,     0,     0,   256,     0,     0,     0,     0,
+     251,     0,     0,   250,     0,   247
 };
 
 /* YYDEFGOTO[NTERM-NUM]. */
-static const short yydefgoto[] =
+static const short int yydefgoto[] =
 {
-      -1,    71,   192,   193,   194,   195,   258,   275,   114,   115,
-       9,    33,    34,    35,    41,    47,   125,   327,   237,   401,
-     330,   539,   381,   357,   524,   294,   358,    72,   116,   134,
-     202,   135,   136,   106,   282,   370,   283,    80,    10,    11,
-      12,    15,    14,   198,   246,   247,    58,    93,    20,    56,
-      97,    74,   496,   421,   422,   126,   205,    48,    88,    49,
-      42,   424,   371,    75,   373,   299,    50,    84,    85,   231,
-     543,   129,   312,   504,   404,   232,   233,   234,   235
+      -1,   189,   190,   191,   192,   255,   272,   111,   112,    72,
+     493,    12,    73,    14,    37,    38,    39,    44,    50,   122,
+     324,   234,   398,   327,   536,   378,   354,   521,   291,   355,
+      74,   113,   131,   199,   132,   133,   103,   279,   367,   280,
+      81,    15,    16,    17,    19,    18,   195,   243,   244,    59,
+      22,    57,    94,   418,   419,   123,   202,    51,    89,    52,
+      45,   421,   368,    76,   370,   296,    53,    85,    86,   228,
+     540,   126,   309,   501,   401,   229,   230,   231,   232
 };
 
 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
    STATE-NUM.  */
-#define YYPACT_NINF -413
-static const short yypact[] =
+#define YYPACT_NINF -440
+static const short int yypact[] =
 {
-     401,  -413,  -413,  -413,  -413,  -413,   110,  -107,    30,    67,
-      77,   527,  -413,   -43,     2,   238,   -16,     8,    47,    84,
-    -413,    -4,   132,   791,  -413,  -413,  -413,  -413,  -413,  -413,
-    -413,  -413,  -413,    91,    91,   149,  -413,  -413,  -413,  -413,
-    -413,    91,  -413,  -413,  -413,  -413,  -413,    91,   147,  -413,
-      20,   210,   208,   280,   226,   273,  -413,  -413,  -413,  -413,
-    -413,   160,  -413,  -413,  -413,  -413,  -413,   295,   299,     3,
-       7,  -413,  -413,   140,  -413,  -413,   149,   149,  -413,  -413,
-     954,   192,   192,  -413,  -413,   184,  -413,  -413,  -413,  -413,
-    -413,  -413,  -413,  -413,  -413,  -413,  -413,   -65,   549,  -413,
-     167,   171,    22,   160,  -413,   140,   -81,  -413,   549,   954,
-    1045,    95,   311,   312,   284,   313,   602,  -413,   317,  -413,
-    -413,  -413,  -413,  -413,  -413,  1125,  -413,    -7,  1228,  -413,
-     306,  -413,  -413,   140,  -413,   191,   193,  1045,  1045,   186,
-     -64,  1045,  -413,   194,  -413,   140,  -413,  -413,  -413,  -413,
-    -413,  -413,  -413,  -413,  -413,  -413,  -413,  -413,  -413,  -413,
-    -413,  -413,  -413,  -413,  -413,  -413,   251,   501,   207,  -413,
-    -413,  -413,  -413,  -413,  -413,  -413,  -413,  -413,  -413,  -413,
-    -413,   209,  -413,  -413,  -413,   214,   215,   216,    49,  1138,
-     120,   314,   219,   222,   224,   225,  -413,  -413,   230,  -413,
-     160,   140,   184,  -413,  -413,  -413,  -413,  -413,   315,  1185,
-     175,   357,   192,  -413,  -413,   251,   501,  1045,  1045,  1045,
-    1045,  1045,  1045,  1045,  1045,  1045,  1045,  1045,  1045,  1045,
-    1045,  -413,   192,  -413,   195,  -413,  -413,   203,   693,  -413,
-     126,    46,  -413,   228,   140,  -413,   230,   230,  -413,  -413,
-    -413,  -413,  -413,  -413,  -413,  -413,  -413,  -413,   231,  -413,
-    -413,  -413,  -413,  -413,  -413,  -413,  -413,  -413,  -413,  -413,
-    -413,  -413,  -413,  -413,  -413,   235,   954,   954,   954,   954,
-     954,  -413,  -413,    29,   500,   -24,  -413,   -27,  -413,   954,
-     954,   954,   954,    39,  -413,   241,  -413,   160,   746,  -413,
-     873,   873,  -413,   873,  1125,  1045,  1045,   123,   159,  -413,
-     746,   146,   233,   245,   248,   249,   250,   252,   746,   746,
-     356,   253,  1125,  1045,  1045,  -413,  -413,  -413,  -413,  -413,
-     -18,  -413,  -413,  -413,   -18,  -413,  -413,   954,   954,  -413,
-     254,   255,   256,   259,   954,  -413,   262,   602,   -12,  -413,
-    -413,   265,   274,   367,   275,   391,   407,  -413,   230,   774,
-    -413,  -413,  -413,  -413,  -413,  -413,  -413,  -413,   358,   954,
-    -413,  -413,  -413,  -413,   282,  -413,   285,   873,   746,   746,
-      35,  -413,    43,  -413,  -413,   873,   281,  1045,  1045,  1045,
-    1045,  1045,   289,   292,  1045,  1045,   873,   746,   293,  -413,
-    -413,  -413,   294,   301,   -25,   954,   954,   954,   954,  -413,
-    -413,   271,   954,   954,  1045,   954,  -413,  -413,  -413,  -413,
-     140,   302,   303,  -413,   417,    25,   427,   428,   305,   310,
-     318,   873,   441,   873,   319,   322,   873,   323,   140,  -413,
-     324,   325,   873,   873,   140,  -413,   309,  -413,  1045,   954,
-     954,  1045,  -413,   326,   328,   327,   335,  -413,   332,   333,
-     131,   336,    34,  1028,  -413,   339,  -413,   873,   873,  1045,
-     873,   873,   341,  -413,   341,   873,   342,  1045,  1045,  1045,
-    -413,  -413,  1045,   746,   340,   345,  -413,   954,  -413,   954,
-     954,  -413,  -413,  -413,  -413,  -413,  -413,  -413,   140,    10,
-     431,   343,   346,   746,    63,  -413,  -413,   400,  -413,  -413,
-     338,   873,  -413,  -413,  -413,   144,  -413,  -413,  -413,   351,
-     352,   354,    34,  -413,   403,  -413,   472,    -3,  -413,  1045,
-    -413,  -413,   355,  -413,  -413,  -413,  -413,  -413,   489,  -413,
-     873,  -413,  1000,    15,   203,   746,    66,  -413,   -18,  -413,
-    -413,   361,  -413,  1000,  -413,   485,   486,   368,   203,   873,
-     873,   491,   434,  -413,   873,   492,  -413,   873,  -413
+     298,  -440,  -440,  -440,  -440,  -440,  -440,  -440,     7,   -91,
+      83,    26,   134,    37,    52,   152,   776,  -440,   178,   108,
+      49,    56,  -440,   107,   233,  -440,   945,  -440,  -440,  -440,
+    -440,  -440,  -440,  -440,  -440,  -440,  -440,   123,   123,    76,
+    -440,  -440,  -440,  -440,   123,  -440,  -440,  -440,  -440,  -440,
+     123,   238,  -440,    27,   240,   241,   242,  -440,  -440,  -440,
+    -440,  -440,   125,  -440,  -440,  -440,  -440,  -440,   257,   258,
+       4,    24,  -440,  -440,  -440,   103,  -440,    76,    76,  -440,
+    -440,  1189,   175,   175,  -440,  -440,   171,  -440,  -440,  -440,
+    -440,  -440,  -440,  -440,   -34,   851,  -440,   126,   130,   109,
+     125,  -440,   103,   -78,  -440,   851,  1189,  1205,    55,   256,
+     262,   200,   263,   622,  -440,   267,  -440,  -440,  -440,  -440,
+    -440,  -440,  1224,  -440,    -8,  1349,  -440,   255,  -440,  -440,
+     103,  -440,   141,   138,  1205,  1205,   140,   -64,  1205,  -440,
+     143,  -440,   103,  -440,  -440,  -440,  -440,  -440,  -440,  -440,
+    -440,  -440,  -440,  -440,  -440,  -440,  -440,  -440,  -440,  -440,
+    -440,  -440,  -440,   450,   481,   145,  -440,  -440,  -440,  -440,
+    -440,  -440,  -440,  -440,  -440,  -440,  -440,  -440,   147,  -440,
+    -440,  -440,   148,   149,   154,   807,  1253,   387,   273,   157,
+     162,   164,   165,  -440,  -440,   169,  -440,   125,   103,   198,
+    -440,  -440,  -440,  -440,  -440,   227,  1267,   228,   293,   175,
+    -440,  -440,   450,   481,  1205,  1205,  1205,  1205,  1205,  1205,
+    1205,  1205,  1205,  1205,  1205,  1205,  1205,  1205,  -440,   175,
+    -440,   120,  -440,  -440,   133,  1114,  -440,    21,   -72,  -440,
+     166,   103,  -440,   169,   169,  -440,  -440,  -440,  -440,  -440,
+    -440,  -440,  -440,  -440,  -440,   168,  -440,  -440,  -440,  -440,
+    -440,  -440,  -440,  -440,  -440,  -440,  -440,  -440,  -440,  -440,
+    -440,  -440,   173,  1189,  1189,  1189,  1189,  1189,  -440,  -440,
+     -31,   473,   -68,  -440,   -49,  -440,  1189,  1189,  1189,  1189,
+      16,  -440,   174,  -440,   125,   764,  -440,   902,   902,  -440,
+     902,  1224,  1205,  1205,     3,    30,  -440,   764,    36,   182,
+     187,   188,   189,   190,   193,   764,   764,   275,   194,  1224,
+    1205,  1205,  -440,  -440,  -440,  -440,  -440,   -53,  -440,  -440,
+    -440,   -53,  -440,  -440,  1189,  1189,  -440,   195,   196,   197,
+     201,  1189,  -440,   191,   622,   -36,  -440,  -440,   203,   204,
+     279,   205,   313,   334,  -440,   169,  1154,  -440,  -440,  -440,
+    -440,  -440,  -440,  -440,  -440,   288,  1189,  -440,  -440,  -440,
+    -440,   211,  -440,   214,   902,   764,   764,    35,  -440,    39,
+    -440,  -440,   902,   210,  1205,  1205,  1205,  1205,  1205,   216,
+     220,  1205,  1205,   902,   764,   221,  -440,  -440,  -440,   222,
+     223,   -30,  1189,  1189,  1189,  1189,  -440,  -440,   215,  1189,
+    1189,  1205,  1189,  -440,  -440,  -440,  -440,   103,   225,   229,
+    -440,   341,   -16,   352,   356,   234,   239,   245,   902,   366,
+     902,   248,   249,   902,   250,   103,  -440,   252,   253,   902,
+     902,   103,  -440,   237,  -440,  1205,  1189,  1189,  1205,  -440,
+     268,   251,   271,   274,  -440,   254,   272,    79,   281,    33,
+    1170,  -440,   277,  -440,   902,   902,  1205,   902,   902,   278,
+    -440,   278,   902,   286,  1205,  1205,  1205,  -440,  -440,  1205,
+     764,   294,   296,  -440,  1189,  -440,  1189,  1189,  -440,  -440,
+    -440,  -440,  -440,  -440,  -440,   103,    31,   357,   301,   236,
+     764,    -4,  -440,  -440,   342,  -440,  -440,   295,   902,  -440,
+    -440,  -440,    40,  -440,  -440,  -440,   300,   302,   306,    33,
+    -440,   343,  -440,   382,    10,  -440,  1205,  -440,  -440,   304,
+    -440,  -440,  -440,  -440,  -440,   403,  -440,   902,  -440,  1027,
+      14,   133,   764,    22,  -440,   -53,  -440,  -440,   305,  -440,
+    1027,  -440,   432,   433,   314,   133,   902,   902,   435,   390,
+    -440,   902,   440,  -440,   902,  -440
 };
 
 /* YYPGOTO[NTERM-NUM].  */
-static const short yypgoto[] =
+static const short int yypgoto[] =
 {
-    -413,  -413,   379,   385,   389,   390,   304,   307,  -210,  -413,
-     439,  -413,  -413,   145,  -413,  -413,  -192,  -305,  -412,  -413,
-    -235,  -413,  -303,    26,  -413,  -201,  -413,  -413,   -14,   288,
-    -255,  -413,   420,   429,   -58,  -112,  -187,   239,  -413,  -413,
-     518,  -413,  -413,  -413,  -413,  -413,  -413,  -413,  -413,  -413,
-    -413,     0,    11,  -413,  -413,   448,  -413,  -413,  -413,  -413,
-    -413,  -413,  -403,   -73,   103,  -151,  -413,   482,  -413,  -413,
-    -413,  -413,  -413,    53,   153,  -413,  -413,  -413,  -413
+    -440,   331,   332,   333,   335,   259,   264,  -206,  -440,     0,
+     -58,   376,     6,  -440,  -440,  -440,    34,  -440,  -440,  -172,
+    -322,  -396,  -440,  -239,  -440,  -285,   -33,  -440,  -218,  -440,
+    -440,   -25,   230,  -270,  -440,   359,   367,   139,  -109,  -159,
+     170,  -440,  -440,   453,  -440,  -440,  -440,  -440,  -440,  -440,
+    -440,  -440,  -440,  -440,  -440,   393,  -440,  -440,  -440,  -440,
+    -440,  -440,  -439,   -89,   124,  -209,  -440,   417,  -440,  -440,
+    -440,  -440,  -440,    13,   105,  -440,  -440,  -440,  -440
 };
 
 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
    positive, shift that token.  If negative, reduce the rule which
    number is the opposite.  If zero, do what YYDEFACT says.
-   If YYTABLE_NINF, parse error.  */
-#define YYTABLE_NINF -170
-static const short yytable[] =
+   If YYTABLE_NINF, syntax error.  */
+#define YYTABLE_NINF -176
+static const short int yytable[] =
 {
-      13,   303,   285,   287,   196,   383,   302,   101,   462,    73,
-     334,    13,    59,    60,   203,   103,    62,    63,    64,    65,
-     304,     1,   117,     2,   302,   400,    21,    59,    60,   400,
-     103,    62,    63,    64,    65,    83,     1,   355,     2,    39,
-     322,    40,    86,   197,   431,   335,   336,    66,     1,   377,
-       2,   144,   433,   141,    59,    60,   105,   103,   111,   112,
-     113,    65,    66,     1,   142,     2,   355,   396,   309,   130,
-     141,   313,   314,   315,   316,   317,   131,    36,   320,   321,
-      23,   243,    22,   432,   133,    13,   522,   356,   105,    66,
-      38,   432,   325,   326,   133,   555,   145,   348,   -57,   -57,
-      24,    25,    26,    27,    28,    29,    30,   344,    31,   451,
-     344,   201,   399,   452,   146,   147,   544,    51,   350,   349,
-     325,   326,   344,   240,   241,    59,    60,   244,   103,   111,
-     112,   113,    65,   411,     1,    55,     2,   204,   541,   551,
-     399,    52,   558,    67,   325,   326,    68,   102,    57,    69,
-     557,    70,   104,    16,    17,    18,   552,   418,    67,   344,
-      66,    68,    83,   344,    69,    87,    70,   139,   466,   508,
-     345,   509,    19,   398,    78,    79,   325,   326,    76,    77,
-      53,   107,   425,   108,   300,    67,    81,   301,    68,   332,
-     281,    69,    82,    70,   400,   298,   399,   529,     1,    32,
-       2,   530,   295,   307,   308,   298,   310,   311,   298,   298,
-     298,   298,   298,   318,   319,   298,   298,    54,   339,   340,
-     341,   342,   343,    32,   133,   372,    90,   372,   372,   499,
-     372,   351,   352,   353,   354,   196,   437,   372,   439,   440,
-     441,   400,    95,   400,   445,   372,   372,   118,   119,   120,
-     121,   122,   123,   124,    91,    92,    67,   380,   107,    68,
-     108,   107,    69,   108,    70,   286,   107,   331,   108,   493,
-     347,    43,    44,    45,   197,   107,    46,   108,   529,   402,
-     403,   107,   533,   108,    94,   385,   409,   148,   149,    96,
-     201,   378,   379,   382,   107,   546,   108,    98,   548,    99,
-     486,   323,   324,   100,   372,   372,   372,   137,   201,   397,
-     298,   138,   372,   325,   326,   109,   110,   542,   -58,   -59,
-     150,   199,   236,   372,   372,   238,   512,   513,   514,   242,
-     288,   239,   245,   553,   248,   249,   250,   251,   252,   253,
-     254,   255,   256,   257,   276,   420,   277,   453,   454,   455,
-     456,   278,   279,   280,   458,   459,   289,   461,   372,   290,
-     372,   291,   292,   372,   293,   296,   302,   386,   337,   372,
-     372,   333,   338,   298,   438,   298,   298,   298,   359,   387,
-     444,   298,   388,   389,   390,   394,   391,   395,   405,   406,
-     407,   484,   485,   408,   372,   372,   414,   372,   372,   412,
-     460,  -169,   372,   374,   375,   410,   376,   416,   413,   415,
-     372,   417,   423,   384,   457,     1,   426,     2,     3,   427,
-     436,   392,   393,   442,     4,     5,   443,   448,   449,   519,
-     372,   520,   521,   465,   483,   450,   463,   298,   372,   467,
-     468,   464,   469,     6,   470,   473,   482,   525,   432,   498,
-       7,   538,   471,   451,     8,   503,   475,   477,   478,   479,
-     487,   489,   495,   298,   298,   298,   488,   372,   503,   490,
-     491,   492,   372,   500,   494,   507,   511,   526,   517,   531,
-     428,   429,   430,   518,   540,   527,   372,   372,   435,   534,
-     535,   372,   536,   549,   372,   556,   547,   559,   560,   446,
-     447,   565,   561,   564,   567,    59,    60,   227,   103,   111,
-     112,   113,    65,   228,     1,   545,     2,   229,   230,   305,
-     259,   260,   495,   306,   128,   523,   329,  -168,   143,    37,
-     127,   140,    89,   537,   472,   515,   474,   434,     0,   476,
-      66,     1,     0,     2,     3,   480,   481,     0,     0,     0,
-       4,     5,     0,     0,    59,    60,     0,   103,    62,    63,
-      64,    65,     0,     1,     0,     2,     0,     0,     0,     6,
-     501,   502,     0,   505,   506,     0,     7,     0,   510,   132,
-       8,     0,     0,     0,     0,     0,   516,     0,     0,    66,
-     261,   262,   263,   264,   265,   266,   267,   268,   269,   270,
-     271,   272,   273,   274,     0,     0,   528,    59,    60,     0,
-       0,     0,     0,     0,   532,     0,     1,     0,     2,     0,
-     151,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   152,   153,     0,    67,     0,     0,    68,
-       0,     0,    69,   550,    70,   346,     0,     0,   554,     0,
+      11,    75,   300,   331,   193,   397,    13,   306,    98,   397,
+     310,   311,   312,   313,   314,   200,    11,   317,   318,   299,
+     380,   459,    13,   299,   194,   332,   333,   282,   284,    60,
+      61,   374,   100,    63,    64,    65,    66,   301,     1,     2,
+      23,     3,     4,    84,   428,   352,   102,     1,   430,   393,
+       3,    87,    20,   552,   138,   322,   323,   319,   -55,   -55,
+     352,   104,   353,   105,   341,   139,    67,    21,   138,   329,
+     130,    77,    78,   346,   102,   396,   143,   144,    82,   240,
+     130,   429,   142,   341,    83,   429,    11,    28,    29,    30,
+      31,    32,    33,    34,   347,    35,   341,   198,   127,   519,
+     548,   341,   448,    79,    80,   128,   449,   408,   342,   237,
+     238,   554,   395,   241,    60,    61,   341,   100,    63,    64,
+      65,    66,   345,     1,     2,   463,     3,     4,   526,   541,
+     322,   323,   527,    24,   201,   377,   104,   415,   105,   322,
+     323,   322,   323,    46,    47,    48,    99,    26,    49,   538,
+     396,    67,    40,   549,   104,   555,   105,    25,    68,   396,
+     328,    69,   379,   104,    70,   105,    71,   101,    27,   104,
+      88,   105,   526,   382,   397,   434,   530,   436,   437,   438,
+      54,   295,    36,   442,   505,     1,   506,    55,     3,   304,
+     305,   295,   307,   308,   295,   295,   295,   295,   295,   315,
+     316,   295,   295,   145,   146,   292,   369,   422,   369,   369,
+     130,   369,   104,     2,   105,   490,     4,    42,   369,    43,
+     114,   397,   496,   397,   320,   321,   369,   369,   115,   116,
+     117,   118,   119,   120,   121,   193,   104,   297,   105,   483,
+     298,   322,   323,    68,    56,   141,    69,   106,   107,    70,
+      58,    71,   136,    36,    84,   194,   344,    91,    92,    93,
+      95,    96,    97,   -56,   134,   509,   510,   511,   135,   -57,
+     147,   196,   233,   235,   236,   293,   198,   375,   376,   242,
+     273,   239,   274,   275,   276,   369,   369,   369,   543,   277,
+     285,   545,   286,   369,   198,   394,   295,   287,  -175,   288,
+     289,   290,   299,   334,   369,   369,   391,   330,   335,   356,
+     411,   -63,     1,     2,   383,     3,     4,     5,   539,   384,
+     385,   386,   387,     6,     7,   388,   392,   402,   403,   404,
+     413,   417,   407,   405,   550,   409,   410,   412,   414,   369,
+     420,   369,     8,   423,   369,     9,   424,   433,   439,    10,
+     369,   369,   440,   445,   446,   447,   454,   460,   462,   295,
+     435,   295,   295,   295,   464,   461,   441,   295,   465,   466,
+     470,   467,   479,   524,   522,   369,   369,   468,   369,   369,
+     448,   472,   474,   369,   475,   476,   457,   485,   429,   535,
+     488,   369,    60,    61,   537,   100,   108,   109,   110,    66,
+     484,     1,     2,   486,     3,     4,   487,   546,   489,   497,
+     504,   369,   336,   337,   338,   339,   340,   491,   508,   369,
+     480,   371,   372,   295,   373,   348,   349,   350,   351,    67,
+     514,   381,   515,   523,   528,   495,   531,   553,   532,   389,
+     390,   500,   533,   544,   556,   557,   558,   561,   369,   295,
+     295,   295,   564,   369,   500,   562,   224,   225,   226,   492,
+     227,   534,   125,   520,   140,   326,   137,   369,   369,    41,
+      90,   302,   369,   399,   400,   369,   124,   303,    60,    61,
+     406,   100,   108,   109,   110,    66,   431,     1,     2,     0,
+       3,     4,   512,     0,     0,     0,     0,     0,   425,   426,
+     427,   542,   256,   257,     0,     0,   432,     0,     0,     0,
+       0,     0,     0,     0,     0,    67,     0,   443,   444,   492,
+       0,    68,     0,     0,    69,     0,     0,    70,     0,    71,
+     283,   245,   246,   247,   248,   249,   250,   251,   252,   253,
+     254,   450,   451,   452,   453,     0,     0,     0,   455,   456,
+       0,   458,   469,     0,   471,     0,     0,   473,     0,     0,
+       0,     0,     0,   477,   478,     0,     0,     0,   258,   259,
+     260,   261,   262,   263,   264,   265,   266,   267,   268,   269,
+     270,   271,     0,     0,     0,   481,   482,     0,   498,   499,
+       0,   502,   503,     0,     0,     0,   507,     0,     0,     0,
+       0,     0,     0,     0,   513,     0,     0,    68,     0,     0,
+      69,     0,     0,    70,     0,    71,   343,     0,     0,     0,
+       0,     0,     0,   516,   525,   517,   518,    60,    61,     0,
+       0,     0,   529,     0,     0,     0,     1,     2,     0,     3,
+       4,     0,   148,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   149,   150,     0,     0,     0,
+       0,   547,     0,     0,     0,     0,   551,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   562,   563,     0,     0,     0,   566,     0,     0,
-     568,   154,   155,   156,   157,   158,   159,   160,   161,   162,
-     163,   164,   165,   166,   167,    67,     0,     0,    68,     0,
-       0,    69,     0,    70,     0,     0,     0,     0,    59,    60,
-       0,   103,    62,    63,    64,    65,     0,     1,     0,     2,
-     168,   169,   170,   171,   172,   173,   174,   175,   176,   177,
-     178,   179,   180,   328,   181,   182,   183,   184,     0,   185,
-     186,   187,     0,    66,     0,     0,     0,   107,     0,   108,
-       0,   188,     0,     0,   189,     0,   190,     0,   191,   360,
-     361,    59,    60,   362,     0,     0,     0,     0,     0,     0,
-       1,     0,     2,     0,   363,   364,   365,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   366,   367,    59,
-      60,     0,   103,    62,    63,    64,    65,     0,     1,     0,
-       2,     0,     0,     0,     0,     0,    59,    60,   368,    61,
-      62,    63,    64,    65,   419,     1,     0,     2,     0,     0,
-       0,     0,     0,     0,    66,   154,   155,   156,   157,   158,
-     159,   160,   161,   162,   163,   164,   165,   166,   167,    67,
-       0,    66,    68,     0,     0,    69,     0,    70,     0,     0,
+     559,   560,     0,     0,     0,   563,     0,     0,   565,   151,
+     152,   153,   154,   155,   156,   157,   158,   159,   160,   161,
+     162,   163,   164,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   168,   169,   170,   171,   172,   173,
-     174,   175,   176,   177,   178,   179,   180,     0,   181,   182,
-     183,   184,     0,   185,   186,   187,   360,   361,    59,    60,
-     362,   107,     0,   108,     0,     0,     0,     1,   369,     2,
-       0,   363,   364,   365,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   366,   367,     0,     0,     0,     0,
-      67,     0,     0,    68,     0,     0,    69,     0,    70,     0,
-       0,     0,     0,     0,     0,   368,     0,    67,     0,     0,
-      68,     0,     0,    69,     0,    70,     0,     0,     0,     0,
-       0,     0,   154,   155,   156,   157,   158,   159,   160,   161,
-     162,   163,   164,   165,   166,   167,     0,     0,     0,    59,
-      60,     0,   103,   111,   112,   113,    65,     0,     1,     0,
-       2,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   168,   169,   170,   171,   172,   173,   174,   175,   176,
-     177,   178,   179,   180,    66,   181,   182,   183,   184,     0,
-     185,   186,   187,   360,   361,     0,     0,   362,     0,     0,
-       0,     0,     0,     0,     0,   369,     0,     0,   363,   364,
-     365,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   366,   367,    59,    60,     0,   103,    62,    63,    64,
-      65,     0,     1,     0,     2,     0,     0,     0,     0,     0,
-      59,    60,   368,   103,    62,    63,    64,    65,   497,     1,
-       0,     2,     0,     0,     0,     0,     0,     0,    66,   154,
-     155,   156,   157,   158,   159,   160,   161,   162,   163,   164,
-     165,   166,   167,     0,     0,    66,     0,     0,     0,     0,
-      67,     0,     0,    68,     0,     0,    69,     0,    70,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   168,   169,
-     170,   171,   172,   173,   174,   175,   176,   177,   178,   179,
-     180,     0,   181,   182,   183,   184,     0,   185,   186,   187,
-      59,    60,     0,   200,    62,    63,    64,    65,     0,     1,
-       0,     2,   369,    59,    60,     0,   103,   111,   112,   113,
-      65,     0,     1,     0,     2,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,    67,    66,     0,    68,     0,     0,
-      69,     0,    70,     0,     0,     0,     0,     0,    66,     0,
-       0,    67,     0,     0,    68,     0,     0,    69,     0,    70,
-      59,    60,     0,   297,    62,    63,    64,    65,     0,     1,
-       0,     2,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   165,   166,
+     167,   168,   169,   170,   171,   172,   173,   174,   175,   176,
+     177,     0,   178,   179,   180,   181,     0,   182,   183,   184,
+       0,     0,     0,     0,     0,   104,     0,   105,     0,   185,
+       0,     0,   186,     0,   187,     0,   188,   357,   358,    60,
+      61,   359,     0,     0,     0,     0,  -174,     0,     1,     2,
+       0,     3,     4,     0,   360,   361,   362,     0,     0,   -63,
+       1,     2,     0,     3,     4,     5,     0,   363,   364,     0,
+       0,     6,     7,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,    60,    61,   365,   100,   108,   109,   110,    66,
+       8,     1,     2,     9,     3,     4,     0,    10,     0,     0,
+       0,   151,   152,   153,   154,   155,   156,   157,   158,   159,
+     160,   161,   162,   163,   164,     0,     0,     0,     0,    67,
+       0,     0,     0,     0,     0,     0,    60,    61,     0,   100,
+      63,    64,    65,    66,     0,     1,     2,     0,     3,     4,
+     165,   166,   167,   168,   169,   170,   171,   172,   173,   174,
+     175,   176,   177,   129,   178,   179,   180,   181,     0,   182,
+     183,   184,     0,    67,     0,     0,     0,   104,     0,   105,
+       0,     0,     0,     0,   366,   357,   358,    60,    61,   359,
+       0,     0,     0,     0,     0,     0,     1,     2,     0,     3,
+       4,     0,   360,   361,   362,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   363,   364,     0,     0,     0,
+       0,    68,     0,     0,    69,     0,   278,    70,     0,    71,
+      60,    61,   365,    62,    63,    64,    65,    66,     0,     1,
+       2,     0,     3,     4,     0,     0,     0,     0,     0,   151,
+     152,   153,   154,   155,   156,   157,   158,   159,   160,   161,
+     162,   163,   164,     0,     0,    68,     0,    67,    69,     0,
+       0,    70,     0,    71,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   165,   166,
+     167,   168,   169,   170,   171,   172,   173,   174,   175,   176,
+     177,     0,   178,   179,   180,   181,     0,   182,   183,   184,
+     357,   358,     0,     0,   359,     0,     0,     0,     0,     0,
+       0,     0,   366,     0,     0,     0,     0,   360,   361,   362,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,    66,     0,     0,     0,     0,
+     363,   364,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   365,     0,    68,
+       0,     0,    69,     0,     0,    70,     0,    71,     0,     0,
+       0,     0,     0,     0,   151,   152,   153,   154,   155,   156,
+     157,   158,   159,   160,   161,   162,   163,   164,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,    60,
+      61,     0,   100,    63,    64,    65,    66,     0,     1,     2,
+       0,     3,     4,   165,   166,   167,   168,   169,   170,   171,
+     172,   173,   174,   175,   176,   177,   325,   178,   179,   180,
+     181,     0,   182,   183,   184,     0,    67,     0,     0,    60,
+      61,     0,   100,    63,    64,    65,    66,   366,     1,     2,
+       0,     3,     4,     0,     0,    60,    61,     0,   100,    63,
+      64,    65,    66,     0,     1,     2,   416,     3,     4,     0,
+       0,     0,     0,     0,    60,    61,    67,   100,   108,   109,
+     110,    66,   494,     1,     2,     0,     3,     4,     0,     0,
+      60,    61,    67,   100,    63,    64,    65,    66,     0,     1,
+       2,     0,     3,     4,     0,     0,     0,     0,     0,    60,
+      61,    67,   197,    63,    64,    65,    66,     0,     1,     2,
+       0,     3,     4,     0,     0,     0,     0,    67,    68,     0,
+       0,    69,     0,     0,    70,     0,    71,     0,    60,    61,
+       0,   100,   108,   109,   110,    66,    67,     1,     2,     0,
+       3,     4,    60,    61,     0,   294,    63,    64,    65,    66,
+       0,     1,     2,     0,     3,     4,     0,     0,    68,     0,
+       0,    69,     0,     0,    70,    67,    71,     0,     0,     0,
+       0,     0,     0,     0,    68,     0,     0,    69,     0,    67,
+      70,     0,    71,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,    68,     0,     0,    69,     0,     0,    70,
+       0,    71,     0,     0,     0,     0,     0,     0,     0,    68,
+       0,     0,    69,     0,     0,    70,     0,    71,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,    68,     0,
+       0,    69,     0,     0,    70,     0,    71,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   203,
+       0,     0,     0,     0,     0,     0,     0,    68,     0,     0,
+      69,     0,     0,    70,     0,   281,     0,   204,   205,     0,
+       0,    68,     0,     0,    69,     0,     0,    70,     0,    71,
+     206,   207,   208,   209,   210,   211,   151,   152,   153,   154,
+     155,   156,   157,   158,   159,   160,   161,   162,   212,   213,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   206,     0,     0,     0,
-       0,    67,     0,     0,    68,     0,     0,    69,     0,    70,
-       0,     0,     0,     0,    67,     0,     0,    68,   207,   208,
-      69,     0,   284,     0,     0,     0,     0,     0,     0,     0,
-       0,   209,   210,   211,   212,   213,   214,   154,   155,   156,
-     157,   158,   159,   160,   161,   162,   163,   164,   165,   215,
-     216,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,    67,     0,     0,    68,     0,     0,    69,     0,    70,
-       0,   217,   218,   219,     0,     0,   220,   169,   170,   171,
-     172,   173,   174,   175,   176,   177,   178,   179,   180,   221,
-     222,   182,   183,   184,   223,   224,   225,   226
+     214,   215,   216,     0,     0,   217,   166,   167,   168,   169,
+     170,   171,   172,   173,   174,   175,   176,   177,   218,   219,
+     179,   180,   181,   220,   221,   222,   223
 };
 
-static const short yycheck[] =
+static const short int yycheck[] =
 {
-       0,   211,   189,   190,   116,   308,     9,     4,   420,    23,
-     245,    11,     5,     6,    21,     8,     9,    10,    11,    12,
-     212,    14,    80,    16,     9,   330,   133,     5,     6,   334,
-       8,     9,    10,    11,    12,    15,    14,    27,    16,    37,
-     232,    39,    22,   116,     9,   246,   247,    40,    14,   304,
-      16,   109,     9,   134,     5,     6,    70,     8,     9,    10,
-      11,    12,    40,    14,   145,    16,    27,   322,   219,   134,
-     134,   222,   223,   224,   225,   226,   141,     0,   229,   230,
-      13,   145,    52,    48,    98,    85,   498,    48,   102,    40,
-     133,    48,   110,   111,   108,    29,   110,   284,     3,     4,
-      33,    34,    35,    36,    37,    38,    39,   134,    41,   134,
-     134,   125,   130,   138,    19,    20,   528,   133,   145,   143,
-     110,   111,   134,   137,   138,     5,     6,   141,     8,     9,
-      10,    11,    12,   145,    14,   139,    16,   144,   141,   542,
-     130,   133,   554,   136,   110,   111,   139,   144,    16,   142,
-     553,   144,   145,    43,    44,    45,   141,   358,   136,   134,
-      40,   139,    15,   134,   142,   145,   144,   145,   143,   472,
-     141,   474,    62,   324,    25,    26,   110,   111,    33,    34,
-     133,   135,   369,   137,     9,   136,    41,    12,   139,   143,
-     141,   142,    47,   144,   499,   209,   130,   134,    14,   132,
-      16,   138,   202,   217,   218,   219,   220,   221,   222,   223,
-     224,   225,   226,   227,   228,   229,   230,   133,   276,   277,
-     278,   279,   280,   132,   238,   298,    16,   300,   301,   464,
-     303,   289,   290,   291,   292,   347,   387,   310,   389,   390,
-     391,   546,    16,   548,   395,   318,   319,    55,    56,    57,
-      58,    59,    60,    61,    46,    47,   136,   134,   135,   139,
-     137,   135,   142,   137,   144,   145,   135,   141,   137,   138,
-     284,    33,    34,    35,   347,   135,    38,   137,   134,   337,
-     338,   135,   138,   137,     4,   139,   344,     3,     4,    16,
-     304,   305,   306,   134,   135,   530,   137,   137,   533,     4,
-     451,   106,   107,     4,   377,   378,   379,   140,   322,   323,
-     324,   140,   385,   110,   111,    76,    77,   527,     7,     7,
-       7,     4,    16,   396,   397,   134,   477,   478,   479,   143,
-      16,   138,   138,   543,    83,    84,    85,    86,    87,    88,
-      89,    90,    91,    92,   137,   359,   137,   405,   406,   407,
-     408,   137,   137,   137,   412,   413,   137,   415,   431,   137,
-     433,   137,   137,   436,   134,    50,     9,   134,   137,   442,
-     443,   143,   137,   387,   388,   389,   390,   391,   137,   134,
-     394,   395,   134,   134,   134,    29,   134,   134,   134,   134,
-     134,   449,   450,   134,   467,   468,    29,   470,   471,   134,
-     414,     0,   475,   300,   301,   143,   303,    16,   134,   134,
-     483,     4,    54,   310,   143,    14,   134,    16,    17,   134,
-     139,   318,   319,   134,    23,    24,   134,   134,   134,   487,
-     503,   489,   490,    16,   448,   134,   134,   451,   511,    12,
-      12,   138,   137,    42,   134,     4,   137,    16,    48,   463,
-      49,    48,   134,   134,    53,   469,   134,   134,   134,   134,
-     134,   134,   462,   477,   478,   479,   138,   540,   482,   134,
-     138,   138,   545,   134,   138,   134,   134,   134,   138,   141,
-     377,   378,   379,   138,    12,   139,   559,   560,   385,   138,
-     138,   564,   138,     4,   567,   134,   141,    12,    12,   396,
-     397,    67,   134,    12,    12,     5,     6,   128,     8,     9,
-      10,    11,    12,   128,    14,   529,    16,   128,   128,   215,
-      19,    20,   522,   216,    85,   499,   238,     0,   108,    11,
-      82,   102,    50,   522,   431,   482,   433,   384,    -1,   436,
-      40,    14,    -1,    16,    17,   442,   443,    -1,    -1,    -1,
-      23,    24,    -1,    -1,     5,     6,    -1,     8,     9,    10,
-      11,    12,    -1,    14,    -1,    16,    -1,    -1,    -1,    42,
-     467,   468,    -1,   470,   471,    -1,    49,    -1,   475,    30,
-      53,    -1,    -1,    -1,    -1,    -1,   483,    -1,    -1,    40,
+       0,    26,   208,   242,   113,   327,     0,   216,     4,   331,
+     219,   220,   221,   222,   223,    23,    16,   226,   227,     9,
+     305,   417,    16,     9,   113,   243,   244,   186,   187,     5,
+       6,   301,     8,     9,    10,    11,    12,   209,    14,    15,
+     131,    17,    18,    16,     9,    29,    71,    14,     9,   319,
+      17,    24,    45,    31,   132,   108,   109,   229,     3,     4,
+      29,   133,    46,   135,   132,   143,    42,    60,   132,   141,
+      95,    37,    38,   141,    99,   128,    21,    22,    44,   143,
+     105,    46,   107,   132,    50,    46,    86,    35,    36,    37,
+      38,    39,    40,    41,   143,    43,   132,   122,   132,   495,
+     539,   132,   132,    27,    28,   139,   136,   143,   139,   134,
+     135,   550,   321,   138,     5,     6,   132,     8,     9,    10,
+      11,    12,   281,    14,    15,   141,    17,    18,   132,   525,
+     108,   109,   136,    50,   142,   132,   133,   355,   135,   108,
+     109,   108,   109,    35,    36,    37,   142,    13,    40,   139,
+     128,    42,     0,   139,   133,   551,   135,   131,   134,   128,
+     139,   137,   132,   133,   140,   135,   142,   143,   131,   133,
+     143,   135,   132,   137,   496,   384,   136,   386,   387,   388,
+     131,   206,   130,   392,   469,    14,   471,   131,    17,   214,
+     215,   216,   217,   218,   219,   220,   221,   222,   223,   224,
+     225,   226,   227,     3,     4,   199,   295,   366,   297,   298,
+     235,   300,   133,    15,   135,   136,    18,    39,   307,    41,
+      81,   543,   461,   545,   104,   105,   315,   316,    53,    54,
+      55,    56,    57,    58,    59,   344,   133,     9,   135,   448,
+      12,   108,   109,   134,   137,   106,   137,    77,    78,   140,
+      17,   142,   143,   130,    16,   344,   281,    17,    17,    17,
+     135,     4,     4,     7,   138,   474,   475,   476,   138,     7,
+       7,     4,    17,   132,   136,    48,   301,   302,   303,   136,
+     135,   141,   135,   135,   135,   374,   375,   376,   527,   135,
+      17,   530,   135,   382,   319,   320,   321,   135,     0,   135,
+     135,   132,     9,   135,   393,   394,    31,   141,   135,   135,
+      31,    13,    14,    15,   132,    17,    18,    19,   524,   132,
+     132,   132,   132,    25,    26,   132,   132,   132,   132,   132,
+      17,   356,   141,   132,   540,   132,   132,   132,     4,   428,
+      52,   430,    44,   132,   433,    47,   132,   137,   132,    51,
+     439,   440,   132,   132,   132,   132,   141,   132,    17,   384,
+     385,   386,   387,   388,    12,   136,   391,   392,    12,   135,
+       4,   132,   135,   137,    17,   464,   465,   132,   467,   468,
+     132,   132,   132,   472,   132,   132,   411,   136,    46,    46,
+     136,   480,     5,     6,    12,     8,     9,    10,    11,    12,
+     132,    14,    15,   132,    17,    18,   132,     4,   136,   132,
+     132,   500,   273,   274,   275,   276,   277,   136,   132,   508,
+     445,   297,   298,   448,   300,   286,   287,   288,   289,    42,
+     136,   307,   136,   132,   139,   460,   136,   132,   136,   315,
+     316,   466,   136,   139,    12,    12,   132,    12,   537,   474,
+     475,   476,    12,   542,   479,    65,   125,   125,   125,   459,
+     125,   519,    86,   496,   105,   235,    99,   556,   557,    16,
+      53,   212,   561,   334,   335,   564,    83,   213,     5,     6,
+     341,     8,     9,    10,    11,    12,   381,    14,    15,    -1,
+      17,    18,   479,    -1,    -1,    -1,    -1,    -1,   374,   375,
+     376,   526,    21,    22,    -1,    -1,   382,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    42,    -1,   393,   394,   519,
+      -1,   134,    -1,    -1,   137,    -1,    -1,   140,    -1,   142,
+     143,    81,    82,    83,    84,    85,    86,    87,    88,    89,
+      90,   402,   403,   404,   405,    -1,    -1,    -1,   409,   410,
+      -1,   412,   428,    -1,   430,    -1,    -1,   433,    -1,    -1,
+      -1,    -1,    -1,   439,   440,    -1,    -1,    -1,    87,    88,
       89,    90,    91,    92,    93,    94,    95,    96,    97,    98,
-      99,   100,   101,   102,    -1,    -1,   503,     5,     6,    -1,
-      -1,    -1,    -1,    -1,   511,    -1,    14,    -1,    16,    -1,
-      18,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    31,    32,    -1,   136,    -1,    -1,   139,
-      -1,    -1,   142,   540,   144,   145,    -1,    -1,   545,    -1,
+      99,   100,    -1,    -1,    -1,   446,   447,    -1,   464,   465,
+      -1,   467,   468,    -1,    -1,    -1,   472,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   480,    -1,    -1,   134,    -1,    -1,
+     137,    -1,    -1,   140,    -1,   142,   143,    -1,    -1,    -1,
+      -1,    -1,    -1,   484,   500,   486,   487,     5,     6,    -1,
+      -1,    -1,   508,    -1,    -1,    -1,    14,    15,    -1,    17,
+      18,    -1,    20,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    33,    34,    -1,    -1,    -1,
+      -1,   537,    -1,    -1,    -1,    -1,   542,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   559,   560,    -1,    -1,    -1,   564,    -1,    -1,
-     567,    69,    70,    71,    72,    73,    74,    75,    76,    77,
-      78,    79,    80,    81,    82,   136,    -1,    -1,   139,    -1,
-      -1,   142,    -1,   144,    -1,    -1,    -1,    -1,     5,     6,
-      -1,     8,     9,    10,    11,    12,    -1,    14,    -1,    16,
-     108,   109,   110,   111,   112,   113,   114,   115,   116,   117,
-     118,   119,   120,    30,   122,   123,   124,   125,    -1,   127,
-     128,   129,    -1,    40,    -1,    -1,    -1,   135,    -1,   137,
-      -1,   139,    -1,    -1,   142,    -1,   144,    -1,   146,     3,
-       4,     5,     6,     7,    -1,    -1,    -1,    -1,    -1,    -1,
-      14,    -1,    16,    -1,    18,    19,    20,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    31,    32,     5,
-       6,    -1,     8,     9,    10,    11,    12,    -1,    14,    -1,
-      16,    -1,    -1,    -1,    -1,    -1,     5,     6,    52,     8,
-       9,    10,    11,    12,    30,    14,    -1,    16,    -1,    -1,
-      -1,    -1,    -1,    -1,    40,    69,    70,    71,    72,    73,
-      74,    75,    76,    77,    78,    79,    80,    81,    82,   136,
-      -1,    40,   139,    -1,    -1,   142,    -1,   144,    -1,    -1,
+     556,   557,    -1,    -1,    -1,   561,    -1,    -1,   564,    67,
+      68,    69,    70,    71,    72,    73,    74,    75,    76,    77,
+      78,    79,    80,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   108,   109,   110,   111,   112,   113,
-     114,   115,   116,   117,   118,   119,   120,    -1,   122,   123,
-     124,   125,    -1,   127,   128,   129,     3,     4,     5,     6,
-       7,   135,    -1,   137,    -1,    -1,    -1,    14,   142,    16,
-      -1,    18,    19,    20,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    31,    32,    -1,    -1,    -1,    -1,
-     136,    -1,    -1,   139,    -1,    -1,   142,    -1,   144,    -1,
-      -1,    -1,    -1,    -1,    -1,    52,    -1,   136,    -1,    -1,
-     139,    -1,    -1,   142,    -1,   144,    -1,    -1,    -1,    -1,
-      -1,    -1,    69,    70,    71,    72,    73,    74,    75,    76,
-      77,    78,    79,    80,    81,    82,    -1,    -1,    -1,     5,
-       6,    -1,     8,     9,    10,    11,    12,    -1,    14,    -1,
-      16,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   108,   109,   110,   111,   112,   113,   114,   115,   116,
-     117,   118,   119,   120,    40,   122,   123,   124,   125,    -1,
-     127,   128,   129,     3,     4,    -1,    -1,     7,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   142,    -1,    -1,    18,    19,
-      20,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    31,    32,     5,     6,    -1,     8,     9,    10,    11,
-      12,    -1,    14,    -1,    16,    -1,    -1,    -1,    -1,    -1,
-       5,     6,    52,     8,     9,    10,    11,    12,    30,    14,
-      -1,    16,    -1,    -1,    -1,    -1,    -1,    -1,    40,    69,
-      70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
-      80,    81,    82,    -1,    -1,    40,    -1,    -1,    -1,    -1,
-     136,    -1,    -1,   139,    -1,    -1,   142,    -1,   144,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   108,   109,
-     110,   111,   112,   113,   114,   115,   116,   117,   118,   119,
-     120,    -1,   122,   123,   124,   125,    -1,   127,   128,   129,
-       5,     6,    -1,     8,     9,    10,    11,    12,    -1,    14,
-      -1,    16,   142,     5,     6,    -1,     8,     9,    10,    11,
-      12,    -1,    14,    -1,    16,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   136,    40,    -1,   139,    -1,    -1,
-     142,    -1,   144,    -1,    -1,    -1,    -1,    -1,    40,    -1,
-      -1,   136,    -1,    -1,   139,    -1,    -1,   142,    -1,   144,
-       5,     6,    -1,     8,     9,    10,    11,    12,    -1,    14,
-      -1,    16,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   106,   107,
+     108,   109,   110,   111,   112,   113,   114,   115,   116,   117,
+     118,    -1,   120,   121,   122,   123,    -1,   125,   126,   127,
+      -1,    -1,    -1,    -1,    -1,   133,    -1,   135,    -1,   137,
+      -1,    -1,   140,    -1,   142,    -1,   144,     3,     4,     5,
+       6,     7,    -1,    -1,    -1,    -1,     0,    -1,    14,    15,
+      -1,    17,    18,    -1,    20,    21,    22,    -1,    -1,    13,
+      14,    15,    -1,    17,    18,    19,    -1,    33,    34,    -1,
+      -1,    25,    26,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,     5,     6,    50,     8,     9,    10,    11,    12,
+      44,    14,    15,    47,    17,    18,    -1,    51,    -1,    -1,
+      -1,    67,    68,    69,    70,    71,    72,    73,    74,    75,
+      76,    77,    78,    79,    80,    -1,    -1,    -1,    -1,    42,
+      -1,    -1,    -1,    -1,    -1,    -1,     5,     6,    -1,     8,
+       9,    10,    11,    12,    -1,    14,    15,    -1,    17,    18,
+     106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
+     116,   117,   118,    32,   120,   121,   122,   123,    -1,   125,
+     126,   127,    -1,    42,    -1,    -1,    -1,   133,    -1,   135,
+      -1,    -1,    -1,    -1,   140,     3,     4,     5,     6,     7,
+      -1,    -1,    -1,    -1,    -1,    -1,    14,    15,    -1,    17,
+      18,    -1,    20,    21,    22,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    33,    34,    -1,    -1,    -1,
+      -1,   134,    -1,    -1,   137,    -1,   139,   140,    -1,   142,
+       5,     6,    50,     8,     9,    10,    11,    12,    -1,    14,
+      15,    -1,    17,    18,    -1,    -1,    -1,    -1,    -1,    67,
+      68,    69,    70,    71,    72,    73,    74,    75,    76,    77,
+      78,    79,    80,    -1,    -1,   134,    -1,    42,   137,    -1,
+      -1,   140,    -1,   142,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   106,   107,
+     108,   109,   110,   111,   112,   113,   114,   115,   116,   117,
+     118,    -1,   120,   121,   122,   123,    -1,   125,   126,   127,
+       3,     4,    -1,    -1,     7,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   140,    -1,    -1,    -1,    -1,    20,    21,    22,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    40,    -1,    -1,    -1,    -1,
+      33,    34,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    50,    -1,   134,
+      -1,    -1,   137,    -1,    -1,   140,    -1,   142,    -1,    -1,
+      -1,    -1,    -1,    -1,    67,    68,    69,    70,    71,    72,
+      73,    74,    75,    76,    77,    78,    79,    80,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     5,
+       6,    -1,     8,     9,    10,    11,    12,    -1,    14,    15,
+      -1,    17,    18,   106,   107,   108,   109,   110,   111,   112,
+     113,   114,   115,   116,   117,   118,    32,   120,   121,   122,
+     123,    -1,   125,   126,   127,    -1,    42,    -1,    -1,     5,
+       6,    -1,     8,     9,    10,    11,    12,   140,    14,    15,
+      -1,    17,    18,    -1,    -1,     5,     6,    -1,     8,     9,
+      10,    11,    12,    -1,    14,    15,    32,    17,    18,    -1,
+      -1,    -1,    -1,    -1,     5,     6,    42,     8,     9,    10,
+      11,    12,    32,    14,    15,    -1,    17,    18,    -1,    -1,
+       5,     6,    42,     8,     9,    10,    11,    12,    -1,    14,
+      15,    -1,    17,    18,    -1,    -1,    -1,    -1,    -1,     5,
+       6,    42,     8,     9,    10,    11,    12,    -1,    14,    15,
+      -1,    17,    18,    -1,    -1,    -1,    -1,    42,   134,    -1,
+      -1,   137,    -1,    -1,   140,    -1,   142,    -1,     5,     6,
+      -1,     8,     9,    10,    11,    12,    42,    14,    15,    -1,
+      17,    18,     5,     6,    -1,     8,     9,    10,    11,    12,
+      -1,    14,    15,    -1,    17,    18,    -1,    -1,   134,    -1,
+      -1,   137,    -1,    -1,   140,    42,   142,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   134,    -1,    -1,   137,    -1,    42,
+     140,    -1,   142,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   134,    -1,    -1,   137,    -1,    -1,   140,
+      -1,   142,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   134,
+      -1,    -1,   137,    -1,    -1,   140,    -1,   142,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   134,    -1,
+      -1,   137,    -1,    -1,   140,    -1,   142,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    30,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   134,    -1,    -1,
+     137,    -1,    -1,   140,    -1,   142,    -1,    48,    49,    -1,
+      -1,   134,    -1,    -1,   137,    -1,    -1,   140,    -1,   142,
+      61,    62,    63,    64,    65,    66,    67,    68,    69,    70,
+      71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    28,    -1,    -1,    -1,
-      -1,   136,    -1,    -1,   139,    -1,    -1,   142,    -1,   144,
-      -1,    -1,    -1,    -1,   136,    -1,    -1,   139,    50,    51,
-     142,    -1,   144,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    63,    64,    65,    66,    67,    68,    69,    70,    71,
-      72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
-      82,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   136,    -1,    -1,   139,    -1,    -1,   142,    -1,   144,
-      -1,   103,   104,   105,    -1,    -1,   108,   109,   110,   111,
-     112,   113,   114,   115,   116,   117,   118,   119,   120,   121,
-     122,   123,   124,   125,   126,   127,   128,   129
+     101,   102,   103,    -1,    -1,   106,   107,   108,   109,   110,
+     111,   112,   113,   114,   115,   116,   117,   118,   119,   120,
+     121,   122,   123,   124,   125,   126,   127
 };
 
 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
    symbol of state STATE-NUM.  */
 static const unsigned char yystos[] =
 {
-       0,    14,    16,    17,    23,    24,    42,    49,    53,   157,
-     185,   186,   187,   198,   189,   188,    43,    44,    45,    62,
-     195,   133,    52,    13,    33,    34,    35,    36,    37,    38,
-      39,    41,   132,   158,   159,   160,     0,   187,   133,    37,
-      39,   161,   207,    33,    34,    35,    38,   162,   204,   206,
-     213,   133,   133,   133,   133,   139,   196,    16,   193,     5,
-       6,     8,     9,    10,    11,    12,    40,   136,   139,   142,
-     144,   148,   174,   175,   198,   210,   160,   160,    25,    26,
-     184,   160,   160,    15,   214,   215,    22,   145,   205,   214,
-      16,    46,    47,   194,     4,    16,    16,   197,   137,     4,
-       4,     4,   144,     8,   145,   175,   180,   135,   137,   184,
-     184,     9,    10,    11,   155,   156,   175,   181,    55,    56,
-      57,    58,    59,    60,    61,   163,   202,   202,   157,   218,
-     134,   141,    30,   175,   176,   178,   179,   140,   140,   145,
-     180,   134,   145,   179,   181,   175,    19,    20,     3,     4,
-       7,    18,    31,    32,    69,    70,    71,    72,    73,    74,
-      75,    76,    77,    78,    79,    80,    81,    82,   108,   109,
-     110,   111,   112,   113,   114,   115,   116,   117,   118,   119,
-     120,   122,   123,   124,   125,   127,   128,   129,   139,   142,
-     144,   146,   149,   150,   151,   152,   182,   210,   190,     4,
-       8,   175,   177,    21,   144,   203,    28,    50,    51,    63,
-      64,    65,    66,    67,    68,    81,    82,   103,   104,   105,
-     108,   121,   122,   126,   127,   128,   129,   149,   150,   151,
-     152,   216,   222,   223,   224,   225,    16,   165,   134,   138,
-     175,   175,   143,   145,   175,   138,   191,   192,    83,    84,
-      85,    86,    87,    88,    89,    90,    91,    92,   153,    19,
-      20,    89,    90,    91,    92,    93,    94,    95,    96,    97,
-      98,    99,   100,   101,   102,   154,   137,   137,   137,   137,
-     137,   141,   181,   183,   144,   183,   145,   183,    16,   137,
-     137,   137,   137,   134,   172,   198,    50,     8,   175,   212,
-       9,    12,     9,   155,   163,   153,   154,   175,   175,   212,
-     175,   175,   219,   212,   212,   212,   212,   212,   175,   175,
-     212,   212,   163,   106,   107,   110,   111,   164,    30,   176,
-     167,   141,   143,   143,   167,   172,   172,   137,   137,   181,
-     181,   181,   181,   181,   134,   141,   145,   175,   183,   143,
-     145,   181,   181,   181,   181,    27,    48,   170,   173,   137,
-       3,     4,     7,    18,    19,    20,    31,    32,    52,   142,
-     182,   209,   210,   211,   211,   211,   211,   177,   175,   175,
-     134,   169,   134,   169,   211,   139,   134,   134,   134,   134,
-     134,   134,   211,   211,    29,   134,   177,   175,   212,   130,
-     164,   166,   181,   181,   221,   134,   134,   134,   134,   181,
-     143,   145,   134,   134,    29,   134,    16,     4,   172,    30,
-     175,   200,   201,    54,   208,   183,   134,   134,   211,   211,
-     211,     9,    48,     9,   221,   211,   139,   212,   175,   212,
-     212,   212,   134,   134,   175,   212,   211,   211,   134,   134,
-     134,   134,   138,   181,   181,   181,   181,   143,   181,   181,
-     175,   181,   165,   134,   138,    16,   143,    12,    12,   137,
-     134,   134,   211,     4,   211,   134,   211,   134,   134,   134,
-     211,   211,   137,   175,   181,   181,   212,   134,   138,   134,
-     134,   138,   138,   138,   138,   198,   199,    30,   175,   167,
-     134,   211,   211,   175,   220,   211,   211,   134,   169,   169,
-     211,   134,   212,   212,   212,   220,   211,   138,   138,   181,
-     181,   181,   165,   170,   171,    16,   134,   139,   211,   134,
-     138,   141,   211,   138,   138,   138,   138,   199,    48,   168,
-      12,   141,   155,   217,   165,   175,   167,   141,   167,     4,
-     211,   209,   141,   155,   211,    29,   134,   209,   165,    12,
-      12,   134,   211,   211,    12,    67,   211,    12,   211
+       0,    14,    15,    17,    18,    19,    25,    26,    44,    47,
+      51,   154,   156,   157,   158,   186,   187,   188,   190,   189,
+      45,    60,   195,   131,    50,   131,    13,   131,    35,    36,
+      37,    38,    39,    40,    41,    43,   130,   159,   160,   161,
+       0,   188,    39,    41,   162,   205,    35,    36,    37,    40,
+     163,   202,   204,   211,   131,   131,   137,   196,    17,   194,
+       5,     6,     8,     9,    10,    11,    12,    42,   134,   137,
+     140,   142,   154,   157,   175,   176,   208,   161,   161,    27,
+      28,   185,   161,   161,    16,   212,   213,    24,   143,   203,
+     212,    17,    17,    17,   197,   135,     4,     4,     4,   142,
+       8,   143,   176,   181,   133,   135,   185,   185,     9,    10,
+      11,   152,   153,   176,   182,    53,    54,    55,    56,    57,
+      58,    59,   164,   200,   200,   156,   216,   132,   139,    32,
+     176,   177,   179,   180,   138,   138,   143,   181,   132,   143,
+     180,   182,   176,    21,    22,     3,     4,     7,    20,    33,
+      34,    67,    68,    69,    70,    71,    72,    73,    74,    75,
+      76,    77,    78,    79,    80,   106,   107,   108,   109,   110,
+     111,   112,   113,   114,   115,   116,   117,   118,   120,   121,
+     122,   123,   125,   126,   127,   137,   140,   142,   144,   146,
+     147,   148,   149,   183,   208,   191,     4,     8,   176,   178,
+      23,   142,   201,    30,    48,    49,    61,    62,    63,    64,
+      65,    66,    79,    80,   101,   102,   103,   106,   119,   120,
+     124,   125,   126,   127,   146,   147,   148,   149,   214,   220,
+     221,   222,   223,    17,   166,   132,   136,   176,   176,   141,
+     143,   176,   136,   192,   193,    81,    82,    83,    84,    85,
+      86,    87,    88,    89,    90,   150,    21,    22,    87,    88,
+      89,    90,    91,    92,    93,    94,    95,    96,    97,    98,
+      99,   100,   151,   135,   135,   135,   135,   135,   139,   182,
+     184,   142,   184,   143,   184,    17,   135,   135,   135,   135,
+     132,   173,   157,    48,     8,   176,   210,     9,    12,     9,
+     152,   164,   150,   151,   176,   176,   210,   176,   176,   217,
+     210,   210,   210,   210,   210,   176,   176,   210,   210,   164,
+     104,   105,   108,   109,   165,    32,   177,   168,   139,   141,
+     141,   168,   173,   173,   135,   135,   182,   182,   182,   182,
+     182,   132,   139,   143,   176,   184,   141,   143,   182,   182,
+     182,   182,    29,    46,   171,   174,   135,     3,     4,     7,
+      20,    21,    22,    33,    34,    50,   140,   183,   207,   208,
+     209,   209,   209,   209,   178,   176,   176,   132,   170,   132,
+     170,   209,   137,   132,   132,   132,   132,   132,   132,   209,
+     209,    31,   132,   178,   176,   210,   128,   165,   167,   182,
+     182,   219,   132,   132,   132,   132,   182,   141,   143,   132,
+     132,    31,   132,    17,     4,   173,    32,   176,   198,   199,
+      52,   206,   184,   132,   132,   209,   209,   209,     9,    46,
+       9,   219,   209,   137,   210,   176,   210,   210,   210,   132,
+     132,   176,   210,   209,   209,   132,   132,   132,   132,   136,
+     182,   182,   182,   182,   141,   182,   182,   176,   182,   166,
+     132,   136,    17,   141,    12,    12,   135,   132,   132,   209,
+       4,   209,   132,   209,   132,   132,   132,   209,   209,   135,
+     176,   182,   182,   210,   132,   136,   132,   132,   136,   136,
+     136,   136,   154,   155,    32,   176,   168,   132,   209,   209,
+     176,   218,   209,   209,   132,   170,   170,   209,   132,   210,
+     210,   210,   218,   209,   136,   136,   182,   182,   182,   166,
+     171,   172,    17,   132,   137,   209,   132,   136,   139,   209,
+     136,   136,   136,   136,   155,    46,   169,    12,   139,   152,
+     215,   166,   176,   168,   139,   168,     4,   209,   207,   139,
+     152,   209,    31,   132,   207,   166,    12,    12,   132,   209,
+     209,    12,    65,   209,    12,   209
 };
 
-#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
-# define YYSIZE_T __SIZE_TYPE__
-#endif
-#if ! defined (YYSIZE_T) && defined (size_t)
-# define YYSIZE_T size_t
-#endif
-#if ! defined (YYSIZE_T)
-# if defined (__STDC__) || defined (__cplusplus)
-#  include  /* INFRINGES ON USER NAME SPACE */
-#  define YYSIZE_T size_t
-# endif
-#endif
-#if ! defined (YYSIZE_T)
-# define YYSIZE_T unsigned int
-#endif
-
 #define yyerrok		(yyerrstatus = 0)
 #define yyclearin	(yychar = YYEMPTY)
-#define YYEMPTY		-2
+#define YYEMPTY		(-2)
 #define YYEOF		0
 
 #define YYACCEPT	goto yyacceptlab
 #define YYABORT		goto yyabortlab
-#define YYERROR		goto yyerrlab1
+#define YYERROR		goto yyerrorlab
+
 
 /* Like YYERROR except do call yyerror.  This remains here temporarily
    to ease the transition to the new meaning of YYERROR, for GCC.
@@ -2285,34 +2347,71 @@
     {								\
       yychar = (Token);						\
       yylval = (Value);						\
-      yychar1 = YYTRANSLATE (yychar);				\
+      yytoken = YYTRANSLATE (yychar);				\
       YYPOPSTACK;						\
       goto yybackup;						\
     }								\
   else								\
-    { 								\
-      yyerror ("syntax error: cannot back up");			\
+    {								\
+      yyerror (YY_("syntax error: cannot back up")); \
       YYERROR;							\
     }								\
 while (0)
 
+
 #define YYTERROR	1
 #define YYERRCODE	256
 
-/* YYLLOC_DEFAULT -- Compute the default location (before the actions
-   are run).  */
 
+/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
+   If N is 0, then set CURRENT to the empty location which ends
+   the previous symbol: RHS[0] (always defined).  */
+
+#define YYRHSLOC(Rhs, K) ((Rhs)[K])
 #ifndef YYLLOC_DEFAULT
-# define YYLLOC_DEFAULT(Current, Rhs, N)           \
-  Current.first_line   = Rhs[1].first_line;      \
-  Current.first_column = Rhs[1].first_column;    \
-  Current.last_line    = Rhs[N].last_line;       \
-  Current.last_column  = Rhs[N].last_column;
+# define YYLLOC_DEFAULT(Current, Rhs, N)				\
+    do									\
+      if (N)								\
+	{								\
+	  (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;	\
+	  (Current).first_column = YYRHSLOC (Rhs, 1).first_column;	\
+	  (Current).last_line    = YYRHSLOC (Rhs, N).last_line;		\
+	  (Current).last_column  = YYRHSLOC (Rhs, N).last_column;	\
+	}								\
+      else								\
+	{								\
+	  (Current).first_line   = (Current).last_line   =		\
+	    YYRHSLOC (Rhs, 0).last_line;				\
+	  (Current).first_column = (Current).last_column =		\
+	    YYRHSLOC (Rhs, 0).last_column;				\
+	}								\
+    while (0)
+#endif
+
+
+/* YY_LOCATION_PRINT -- Print the location on the stream.
+   This macro was not mandated originally: define only if we know
+   we won't break user code: when these are the locations we know.  */
+
+#ifndef YY_LOCATION_PRINT
+# if YYLTYPE_IS_TRIVIAL
+#  define YY_LOCATION_PRINT(File, Loc)			\
+     fprintf (File, "%d.%d-%d.%d",			\
+              (Loc).first_line, (Loc).first_column,	\
+              (Loc).last_line,  (Loc).last_column)
+# else
+#  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
+# endif
 #endif
 
+
 /* YYLEX -- calling `yylex' with the right arguments.  */
 
-#define YYLEX	yylex ()
+#ifdef YYLEX_PARAM
+# define YYLEX yylex (YYLEX_PARAM)
+#else
+# define YYLEX yylex ()
+#endif
 
 /* Enable debugging if requested.  */
 #if YYDEBUG
@@ -2327,19 +2426,86 @@
   if (yydebug)					\
     YYFPRINTF Args;				\
 } while (0)
-# define YYDSYMPRINT(Args)			\
-do {						\
-  if (yydebug)					\
-    yysymprint Args;				\
+
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location)		\
+do {								\
+  if (yydebug)							\
+    {								\
+      YYFPRINTF (stderr, "%s ", Title);				\
+      yysymprint (stderr,					\
+                  Type, Value);	\
+      YYFPRINTF (stderr, "\n");					\
+    }								\
+} while (0)
+
+/*------------------------------------------------------------------.
+| yy_stack_print -- Print the state stack from its BOTTOM up to its |
+| TOP (included).                                                   |
+`------------------------------------------------------------------*/
+
+#if defined (__STDC__) || defined (__cplusplus)
+static void
+yy_stack_print (short int *bottom, short int *top)
+#else
+static void
+yy_stack_print (bottom, top)
+    short int *bottom;
+    short int *top;
+#endif
+{
+  YYFPRINTF (stderr, "Stack now");
+  for (/* Nothing. */; bottom <= top; ++bottom)
+    YYFPRINTF (stderr, " %d", *bottom);
+  YYFPRINTF (stderr, "\n");
+}
+
+# define YY_STACK_PRINT(Bottom, Top)				\
+do {								\
+  if (yydebug)							\
+    yy_stack_print ((Bottom), (Top));				\
+} while (0)
+
+
+/*------------------------------------------------.
+| Report that the YYRULE is going to be reduced.  |
+`------------------------------------------------*/
+
+#if defined (__STDC__) || defined (__cplusplus)
+static void
+yy_reduce_print (int yyrule)
+#else
+static void
+yy_reduce_print (yyrule)
+    int yyrule;
+#endif
+{
+  int yyi;
+  unsigned long int yylno = yyrline[yyrule];
+  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu), ",
+             yyrule - 1, yylno);
+  /* Print the symbols being reduced, and their result.  */
+  for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
+    YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
+  YYFPRINTF (stderr, "-> %s\n", yytname[yyr1[yyrule]]);
+}
+
+# define YY_REDUCE_PRINT(Rule)		\
+do {					\
+  if (yydebug)				\
+    yy_reduce_print (Rule);		\
 } while (0)
+
 /* Nonzero means print parse trace.  It is left uninitialized so that
    multiple parsers can coexist.  */
 int yydebug;
 #else /* !YYDEBUG */
 # define YYDPRINTF(Args)
-# define YYDSYMPRINT(Args)
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
+# define YY_STACK_PRINT(Bottom, Top)
+# define YY_REDUCE_PRINT(Rule)
 #endif /* !YYDEBUG */
 
+
 /* YYINITDEPTH -- initial size of the parser's stacks.  */
 #ifndef	YYINITDEPTH
 # define YYINITDEPTH 200
@@ -2349,13 +2515,9 @@
    if the built-in stack extension method is used).
 
    Do not make this value too large; the results are undefined if
-   SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
+   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
    evaluated with infinite-precision integer arithmetic.  */
 
-#if YYMAXDEPTH == 0
-# undef YYMAXDEPTH
-#endif
-
 #ifndef YYMAXDEPTH
 # define YYMAXDEPTH 10000
 #endif
@@ -2377,7 +2539,7 @@
      const char *yystr;
 #   endif
 {
-  register const char *yys = yystr;
+  const char *yys = yystr;
 
   while (*yys++ != '\0')
     continue;
@@ -2402,8 +2564,8 @@
      const char *yysrc;
 #   endif
 {
-  register char *yyd = yydest;
-  register const char *yys = yysrc;
+  char *yyd = yydest;
+  const char *yys = yysrc;
 
   while ((*yyd++ = *yys++) != '\0')
     continue;
@@ -2413,124 +2575,186 @@
 #  endif
 # endif
 
-#endif /* !YYERROR_VERBOSE */
+# ifndef yytnamerr
+/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
+   quotes and backslashes, so that it's suitable for yyerror.  The
+   heuristic is that double-quoting is unnecessary unless the string
+   contains an apostrophe, a comma, or backslash (other than
+   backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
+   null, do not copy; instead, return the length of what the result
+   would have been.  */
+static YYSIZE_T
+yytnamerr (char *yyres, const char *yystr)
+{
+  if (*yystr == '"')
+    {
+      size_t yyn = 0;
+      char const *yyp = yystr;
+
+      for (;;)
+	switch (*++yyp)
+	  {
+	  case '\'':
+	  case ',':
+	    goto do_not_strip_quotes;
+
+	  case '\\':
+	    if (*++yyp != '\\')
+	      goto do_not_strip_quotes;
+	    /* Fall through.  */
+	  default:
+	    if (yyres)
+	      yyres[yyn] = *yyp;
+	    yyn++;
+	    break;
+
+	  case '"':
+	    if (yyres)
+	      yyres[yyn] = '\0';
+	    return yyn;
+	  }
+    do_not_strip_quotes: ;
+    }
+
+  if (! yyres)
+    return yystrlen (yystr);
+
+  return yystpcpy (yyres, yystr) - yyres;
+}
+# endif
+
+#endif /* YYERROR_VERBOSE */
 
 
 
 #if YYDEBUG
-/*-----------------------------.
-| Print this symbol on YYOUT.  |
-`-----------------------------*/
+/*--------------------------------.
+| Print this symbol on YYOUTPUT.  |
+`--------------------------------*/
 
-static void
 #if defined (__STDC__) || defined (__cplusplus)
-yysymprint (FILE* yyout, int yytype, YYSTYPE yyvalue)
+static void
+yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
 #else
-yysymprint (yyout, yytype, yyvalue)
-    FILE* yyout;
+static void
+yysymprint (yyoutput, yytype, yyvaluep)
+    FILE *yyoutput;
     int yytype;
-    YYSTYPE yyvalue;
+    YYSTYPE *yyvaluep;
 #endif
 {
   /* Pacify ``unused variable'' warnings.  */
-  (void) yyvalue;
+  (void) yyvaluep;
 
   if (yytype < YYNTOKENS)
-    {
-      YYFPRINTF (yyout, "token %s (", yytname[yytype]);
-# ifdef YYPRINT
-      YYPRINT (yyout, yytoknum[yytype], yyvalue);
-# endif
-    }
+    YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
   else
-    YYFPRINTF (yyout, "nterm %s (", yytname[yytype]);
+    YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
 
+
+# ifdef YYPRINT
+  if (yytype < YYNTOKENS)
+    YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
+# endif
   switch (yytype)
     {
       default:
         break;
     }
-  YYFPRINTF (yyout, ")");
+  YYFPRINTF (yyoutput, ")");
 }
-#endif /* YYDEBUG. */
-
 
+#endif /* ! YYDEBUG */
 /*-----------------------------------------------.
 | Release the memory associated to this symbol.  |
 `-----------------------------------------------*/
 
-static void
 #if defined (__STDC__) || defined (__cplusplus)
-yydestruct (int yytype, YYSTYPE yyvalue)
+static void
+yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
 #else
-yydestruct (yytype, yyvalue)
+static void
+yydestruct (yymsg, yytype, yyvaluep)
+    const char *yymsg;
     int yytype;
-    YYSTYPE yyvalue;
+    YYSTYPE *yyvaluep;
 #endif
 {
   /* Pacify ``unused variable'' warnings.  */
-  (void) yyvalue;
+  (void) yyvaluep;
+
+  if (!yymsg)
+    yymsg = "Deleting";
+  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
 
   switch (yytype)
     {
+
       default:
         break;
     }
 }
-
 
 
-/* The user can define YYPARSE_PARAM as the name of an argument to be passed
-   into yyparse.  The argument should have type void *.
-   It should actually point to an object.
-   Grammar actions can access the variable by casting it
-   to the proper pointer type.  */
+/* Prevent warnings from -Wmissing-prototypes.  */
 
 #ifdef YYPARSE_PARAM
 # if defined (__STDC__) || defined (__cplusplus)
-#  define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
-#  define YYPARSE_PARAM_DECL
+int yyparse (void *YYPARSE_PARAM);
 # else
-#  define YYPARSE_PARAM_ARG YYPARSE_PARAM
-#  define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
+int yyparse ();
 # endif
-#else /* !YYPARSE_PARAM */
-# define YYPARSE_PARAM_ARG
-# define YYPARSE_PARAM_DECL
-#endif /* !YYPARSE_PARAM */
-
-/* Prevent warning if -Wstrict-prototypes.  */
-#ifdef __GNUC__
-# ifdef YYPARSE_PARAM
-int yyparse (void *);
-# else
+#else /* ! YYPARSE_PARAM */
+#if defined (__STDC__) || defined (__cplusplus)
 int yyparse (void);
-# endif
+#else
+int yyparse ();
 #endif
+#endif /* ! YYPARSE_PARAM */
+
 
 
-/* The lookahead symbol.  */
+/* The look-ahead symbol.  */
 int yychar;
 
-/* The semantic value of the lookahead symbol.  */
+/* The semantic value of the look-ahead symbol.  */
 YYSTYPE yylval;
 
-/* Number of parse errors so far.  */
+/* Number of syntax errors so far.  */
 int yynerrs;
 
 
+
+/*----------.
+| yyparse.  |
+`----------*/
+
+#ifdef YYPARSE_PARAM
+# if defined (__STDC__) || defined (__cplusplus)
+int yyparse (void *YYPARSE_PARAM)
+# else
+int yyparse (YYPARSE_PARAM)
+  void *YYPARSE_PARAM;
+# endif
+#else /* ! YYPARSE_PARAM */
+#if defined (__STDC__) || defined (__cplusplus)
+int
+yyparse (void)
+#else
 int
-yyparse (YYPARSE_PARAM_ARG)
-     YYPARSE_PARAM_DECL
+yyparse ()
+
+#endif
+#endif
 {
   
-  register int yystate;
-  register int yyn;
+  int yystate;
+  int yyn;
   int yyresult;
   /* Number of tokens to shift before error messages enabled.  */
   int yyerrstatus;
-  /* Lookahead token as an internal (translated) token number.  */
-  int yychar1 = 0;
+  /* Look-ahead token as an internal (translated) token number.  */
+  int yytoken = 0;
 
   /* Three stacks and their tools:
      `yyss': related to states,
@@ -2541,14 +2765,14 @@
      to reallocate them elsewhere.  */
 
   /* The state stack.  */
-  short	yyssa[YYINITDEPTH];
-  short *yyss = yyssa;
-  register short *yyssp;
+  short int yyssa[YYINITDEPTH];
+  short int *yyss = yyssa;
+  short int *yyssp;
 
   /* The semantic value stack.  */
   YYSTYPE yyvsa[YYINITDEPTH];
   YYSTYPE *yyvs = yyvsa;
-  register YYSTYPE *yyvsp;
+  YYSTYPE *yyvsp;
 
 
 
@@ -2594,7 +2818,7 @@
  yysetstate:
   *yyssp = yystate;
 
-  if (yyssp >= yyss + yystacksize - 1)
+  if (yyss + yystacksize - 1 <= yyssp)
     {
       /* Get the current used size of the three stacks, in elements.  */
       YYSIZE_T yysize = yyssp - yyss + 1;
@@ -2605,14 +2829,14 @@
 	   these so that the &'s don't force the real ones into
 	   memory.  */
 	YYSTYPE *yyvs1 = yyvs;
-	short *yyss1 = yyss;
+	short int *yyss1 = yyss;
 
 
 	/* Each stack pointer address is followed by the size of the
 	   data in use in that stack, in bytes.  This used to be a
 	   conditional around just the two extra args, but that might
 	   be undefined if yyoverflow is a macro.  */
-	yyoverflow ("parser stack overflow",
+	yyoverflow (YY_("memory exhausted"),
 		    &yyss1, yysize * sizeof (*yyssp),
 		    &yyvs1, yysize * sizeof (*yyvsp),
 
@@ -2623,21 +2847,21 @@
       }
 #else /* no yyoverflow */
 # ifndef YYSTACK_RELOCATE
-      goto yyoverflowlab;
+      goto yyexhaustedlab;
 # else
       /* Extend the stack our own way.  */
-      if (yystacksize >= YYMAXDEPTH)
-	goto yyoverflowlab;
+      if (YYMAXDEPTH <= yystacksize)
+	goto yyexhaustedlab;
       yystacksize *= 2;
-      if (yystacksize > YYMAXDEPTH)
+      if (YYMAXDEPTH < yystacksize)
 	yystacksize = YYMAXDEPTH;
 
       {
-	short *yyss1 = yyss;
+	short int *yyss1 = yyss;
 	union yyalloc *yyptr =
 	  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
 	if (! yyptr)
-	  goto yyoverflowlab;
+	  goto yyexhaustedlab;
 	YYSTACK_RELOCATE (yyss);
 	YYSTACK_RELOCATE (yyvs);
 
@@ -2655,7 +2879,7 @@
       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
 		  (unsigned long int) yystacksize));
 
-      if (yyssp >= yyss + yystacksize - 1)
+      if (yyss + yystacksize - 1 <= yyssp)
 	YYABORT;
     }
 
@@ -2669,50 +2893,39 @@
 yybackup:
 
 /* Do appropriate processing given the current state.  */
-/* Read a lookahead token if we need one and don't already have one.  */
+/* Read a look-ahead token if we need one and don't already have one.  */
 /* yyresume: */
 
-  /* First try to decide what to do without reference to lookahead token.  */
+  /* First try to decide what to do without reference to look-ahead token.  */
 
   yyn = yypact[yystate];
   if (yyn == YYPACT_NINF)
     goto yydefault;
 
-  /* Not known => get a lookahead token if don't already have one.  */
-
-  /* yychar is either YYEMPTY or YYEOF
-     or a valid token in external form.  */
+  /* Not known => get a look-ahead token if don't already have one.  */
 
+  /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */
   if (yychar == YYEMPTY)
     {
       YYDPRINTF ((stderr, "Reading a token: "));
       yychar = YYLEX;
     }
 
-  /* Convert token to internal form (in yychar1) for indexing tables with.  */
-
-  if (yychar <= 0)		/* This means end of input.  */
+  if (yychar <= YYEOF)
     {
-      yychar1 = 0;
-      yychar = YYEOF;		/* Don't call YYLEX any more.  */
-
+      yychar = yytoken = YYEOF;
       YYDPRINTF ((stderr, "Now at end of input.\n"));
     }
   else
     {
-      yychar1 = YYTRANSLATE (yychar);
-
-      /* We have to keep this `#if YYDEBUG', since we use variables
-	 which are defined only if `YYDEBUG' is set.  */
-      YYDPRINTF ((stderr, "Next token is "));
-      YYDSYMPRINT ((stderr, yychar1, yylval));
-      YYDPRINTF ((stderr, "\n"));
+      yytoken = YYTRANSLATE (yychar);
+      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
     }
 
-  /* If the proper action on seeing token YYCHAR1 is to reduce or to
+  /* If the proper action on seeing token YYTOKEN is to reduce or to
      detect an error, take that action.  */
-  yyn += yychar1;
-  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yychar1)
+  yyn += yytoken;
+  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
     goto yydefault;
   yyn = yytable[yyn];
   if (yyn <= 0)
@@ -2726,9 +2939,8 @@
   if (yyn == YYFINAL)
     YYACCEPT;
 
-  /* Shift the lookahead token.  */
-  YYDPRINTF ((stderr, "Shifting token %d (%s), ",
-	      yychar, yytname[yychar1]));
+  /* Shift the look-ahead token.  */
+  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
 
   /* Discard the token being shifted unless it is eof.  */
   if (yychar != YYEOF)
@@ -2774,490 +2986,485 @@
   yyval = yyvsp[1-yylen];
 
 
-
-#if YYDEBUG
-  /* We have to keep this `#if YYDEBUG', since we use variables which
-     are defined only if `YYDEBUG' is set.  */
-  if (yydebug)
-    {
-      int yyi;
-
-      YYFPRINTF (stderr, "Reducing via rule %d (line %d), ",
-		 yyn - 1, yyrline[yyn]);
-
-      /* Print the symbols being reduced, and their result.  */
-      for (yyi = yyprhs[yyn]; yyrhs[yyi] >= 0; yyi++)
-	YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
-      YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);
-    }
-#endif
+  YY_REDUCE_PRINT (yyn);
   switch (yyn)
     {
-        case 3:
-#line 1032 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    {
-  if (yyvsp[0].UIntVal > (uint32_t)INT32_MAX)     // Outside of my range!
-    GEN_ERROR("Value too large for type!");
-  yyval.SIntVal = (int32_t)yyvsp[0].UIntVal;
-  CHECK_FOR_ERROR
-}
+        case 29:
+#line 1038 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.IPredicate) = ICmpInst::ICMP_EQ; ;}
+    break;
+
+  case 30:
+#line 1038 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.IPredicate) = ICmpInst::ICMP_NE; ;}
     break;
 
   case 31:
-#line 1048 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.IPredicate = ICmpInst::ICMP_EQ; }
+#line 1039 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.IPredicate) = ICmpInst::ICMP_SLT; ;}
     break;
 
   case 32:
-#line 1048 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.IPredicate = ICmpInst::ICMP_NE; }
+#line 1039 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.IPredicate) = ICmpInst::ICMP_SGT; ;}
     break;
 
   case 33:
-#line 1049 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.IPredicate = ICmpInst::ICMP_SLT; }
+#line 1040 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.IPredicate) = ICmpInst::ICMP_SLE; ;}
     break;
 
   case 34:
-#line 1049 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.IPredicate = ICmpInst::ICMP_SGT; }
+#line 1040 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.IPredicate) = ICmpInst::ICMP_SGE; ;}
     break;
 
   case 35:
-#line 1050 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.IPredicate = ICmpInst::ICMP_SLE; }
+#line 1041 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.IPredicate) = ICmpInst::ICMP_ULT; ;}
     break;
 
   case 36:
-#line 1050 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.IPredicate = ICmpInst::ICMP_SGE; }
+#line 1041 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.IPredicate) = ICmpInst::ICMP_UGT; ;}
     break;
 
   case 37:
-#line 1051 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.IPredicate = ICmpInst::ICMP_ULT; }
+#line 1042 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.IPredicate) = ICmpInst::ICMP_ULE; ;}
     break;
 
   case 38:
-#line 1051 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.IPredicate = ICmpInst::ICMP_UGT; }
+#line 1042 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.IPredicate) = ICmpInst::ICMP_UGE; ;}
     break;
 
   case 39:
-#line 1052 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.IPredicate = ICmpInst::ICMP_ULE; }
+#line 1046 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.FPredicate) = FCmpInst::FCMP_OEQ; ;}
     break;
 
   case 40:
-#line 1052 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.IPredicate = ICmpInst::ICMP_UGE; }
+#line 1046 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.FPredicate) = FCmpInst::FCMP_ONE; ;}
     break;
 
   case 41:
-#line 1056 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.FPredicate = FCmpInst::FCMP_OEQ; }
+#line 1047 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.FPredicate) = FCmpInst::FCMP_OLT; ;}
     break;
 
   case 42:
-#line 1056 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.FPredicate = FCmpInst::FCMP_ONE; }
+#line 1047 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.FPredicate) = FCmpInst::FCMP_OGT; ;}
     break;
 
   case 43:
-#line 1057 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.FPredicate = FCmpInst::FCMP_OLT; }
+#line 1048 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.FPredicate) = FCmpInst::FCMP_OLE; ;}
     break;
 
   case 44:
-#line 1057 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.FPredicate = FCmpInst::FCMP_OGT; }
+#line 1048 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.FPredicate) = FCmpInst::FCMP_OGE; ;}
     break;
 
   case 45:
-#line 1058 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.FPredicate = FCmpInst::FCMP_OLE; }
+#line 1049 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.FPredicate) = FCmpInst::FCMP_ORD; ;}
     break;
 
   case 46:
-#line 1058 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.FPredicate = FCmpInst::FCMP_OGE; }
+#line 1049 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.FPredicate) = FCmpInst::FCMP_UNO; ;}
     break;
 
   case 47:
-#line 1059 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.FPredicate = FCmpInst::FCMP_ORD; }
+#line 1050 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.FPredicate) = FCmpInst::FCMP_UEQ; ;}
     break;
 
   case 48:
-#line 1059 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.FPredicate = FCmpInst::FCMP_UNO; }
+#line 1050 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.FPredicate) = FCmpInst::FCMP_UNE; ;}
     break;
 
   case 49:
-#line 1060 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.FPredicate = FCmpInst::FCMP_UEQ; }
+#line 1051 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.FPredicate) = FCmpInst::FCMP_ULT; ;}
     break;
 
   case 50:
-#line 1060 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.FPredicate = FCmpInst::FCMP_UNE; }
+#line 1051 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.FPredicate) = FCmpInst::FCMP_UGT; ;}
     break;
 
   case 51:
-#line 1061 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.FPredicate = FCmpInst::FCMP_ULT; }
+#line 1052 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.FPredicate) = FCmpInst::FCMP_ULE; ;}
     break;
 
   case 52:
-#line 1061 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.FPredicate = FCmpInst::FCMP_UGT; }
+#line 1052 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.FPredicate) = FCmpInst::FCMP_UGE; ;}
     break;
 
   case 53:
-#line 1062 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.FPredicate = FCmpInst::FCMP_ULE; }
+#line 1053 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.FPredicate) = FCmpInst::FCMP_TRUE; ;}
     break;
 
   case 54:
-#line 1062 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.FPredicate = FCmpInst::FCMP_UGE; }
-    break;
-
-  case 55:
-#line 1063 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.FPredicate = FCmpInst::FCMP_TRUE; }
+#line 1054 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.FPredicate) = FCmpInst::FCMP_FALSE; ;}
     break;
 
-  case 56:
-#line 1064 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.FPredicate = FCmpInst::FCMP_FALSE; }
+  case 61:
+#line 1063 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.StrVal) = 0; ;}
     break;
 
-  case 60:
-#line 1073 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 62:
+#line 1067 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    yyval.StrVal = yyvsp[-1].StrVal;
+    (yyval.StrVal) = (yyvsp[-1].StrVal);
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 61:
-#line 1077 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 63:
+#line 1071 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    yyval.StrVal = 0;
+    (yyval.StrVal) = 0;
     CHECK_FOR_ERROR
-  }
-    break;
-
-  case 62:
-#line 1083 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.Linkage = GlobalValue::InternalLinkage; }
-    break;
-
-  case 63:
-#line 1084 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.Linkage = GlobalValue::WeakLinkage; }
-    break;
-
-  case 64:
-#line 1085 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.Linkage = GlobalValue::LinkOnceLinkage; }
-    break;
-
-  case 65:
-#line 1086 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.Linkage = GlobalValue::AppendingLinkage; }
+  ;}
     break;
 
   case 66:
-#line 1087 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.Linkage = GlobalValue::DLLExportLinkage; }
+#line 1078 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    {
+    (yyval.StrVal) = (yyvsp[-1].StrVal);
+    CHECK_FOR_ERROR
+  ;}
     break;
 
   case 67:
-#line 1091 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.Linkage = GlobalValue::DLLImportLinkage; }
+#line 1082 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    {
+    (yyval.StrVal) = 0;
+    CHECK_FOR_ERROR
+  ;}
     break;
 
   case 68:
-#line 1092 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.Linkage = GlobalValue::ExternalWeakLinkage; }
+#line 1088 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.Linkage) = GlobalValue::InternalLinkage; ;}
     break;
 
   case 69:
-#line 1093 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.Linkage = GlobalValue::ExternalLinkage; }
+#line 1089 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.Linkage) = GlobalValue::WeakLinkage; ;}
     break;
 
   case 70:
-#line 1097 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.Visibility = GlobalValue::DefaultVisibility; }
+#line 1090 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.Linkage) = GlobalValue::LinkOnceLinkage; ;}
     break;
 
   case 71:
-#line 1098 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.Visibility = GlobalValue::HiddenVisibility;  }
+#line 1091 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.Linkage) = GlobalValue::AppendingLinkage; ;}
     break;
 
   case 72:
-#line 1102 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.Linkage = GlobalValue::ExternalLinkage; }
+#line 1092 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.Linkage) = GlobalValue::DLLExportLinkage; ;}
     break;
 
   case 73:
-#line 1103 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.Linkage = GlobalValue::DLLImportLinkage; }
+#line 1096 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.Linkage) = GlobalValue::DLLImportLinkage; ;}
     break;
 
   case 74:
-#line 1104 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.Linkage = GlobalValue::ExternalWeakLinkage; }
+#line 1097 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.Linkage) = GlobalValue::ExternalWeakLinkage; ;}
     break;
 
   case 75:
-#line 1108 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.Linkage = GlobalValue::ExternalLinkage; }
+#line 1098 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.Linkage) = GlobalValue::ExternalLinkage; ;}
     break;
 
   case 76:
-#line 1109 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.Linkage = GlobalValue::InternalLinkage; }
+#line 1102 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.Visibility) = GlobalValue::DefaultVisibility; ;}
     break;
 
   case 77:
-#line 1110 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.Linkage = GlobalValue::LinkOnceLinkage; }
+#line 1103 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.Visibility) = GlobalValue::HiddenVisibility;  ;}
     break;
 
   case 78:
-#line 1111 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.Linkage = GlobalValue::WeakLinkage; }
+#line 1107 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.Linkage) = GlobalValue::ExternalLinkage; ;}
     break;
 
   case 79:
-#line 1112 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.Linkage = GlobalValue::DLLExportLinkage; }
+#line 1108 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.Linkage) = GlobalValue::DLLImportLinkage; ;}
     break;
 
   case 80:
-#line 1115 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.UIntVal = CallingConv::C; }
+#line 1109 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.Linkage) = GlobalValue::ExternalWeakLinkage; ;}
     break;
 
   case 81:
-#line 1116 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.UIntVal = CallingConv::C; }
+#line 1113 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.Linkage) = GlobalValue::ExternalLinkage; ;}
     break;
 
   case 82:
-#line 1117 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.UIntVal = CallingConv::CSRet; }
+#line 1114 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.Linkage) = GlobalValue::InternalLinkage; ;}
     break;
 
   case 83:
-#line 1118 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.UIntVal = CallingConv::Fast; }
+#line 1115 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.Linkage) = GlobalValue::LinkOnceLinkage; ;}
     break;
 
   case 84:
-#line 1119 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.UIntVal = CallingConv::Cold; }
+#line 1116 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.Linkage) = GlobalValue::WeakLinkage; ;}
     break;
 
   case 85:
-#line 1120 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.UIntVal = CallingConv::X86_StdCall; }
+#line 1117 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.Linkage) = GlobalValue::DLLExportLinkage; ;}
     break;
 
   case 86:
-#line 1121 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.UIntVal = CallingConv::X86_FastCall; }
+#line 1120 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.UIntVal) = CallingConv::C; ;}
     break;
 
   case 87:
-#line 1122 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    {
-                   if ((unsigned)yyvsp[0].UInt64Val != yyvsp[0].UInt64Val)
-                     GEN_ERROR("Calling conv too large!");
-                   yyval.UIntVal = yyvsp[0].UInt64Val;
-                  CHECK_FOR_ERROR
-                 }
+#line 1121 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.UIntVal) = CallingConv::C; ;}
     break;
 
   case 88:
-#line 1129 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.ParamAttrs = FunctionType::ZExtAttribute; }
+#line 1122 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.UIntVal) = CallingConv::CSRet; ;}
     break;
 
   case 89:
-#line 1130 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.ParamAttrs = FunctionType::SExtAttribute; }
+#line 1123 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.UIntVal) = CallingConv::Fast; ;}
     break;
 
   case 90:
-#line 1133 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.ParamAttrs = FunctionType::NoAttributeSet; }
+#line 1124 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.UIntVal) = CallingConv::Cold; ;}
     break;
 
   case 91:
-#line 1134 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    {
-                yyval.ParamAttrs = FunctionType::ParameterAttributes(yyvsp[-1].ParamAttrs | yyvsp[0].ParamAttrs);
-              }
+#line 1125 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.UIntVal) = CallingConv::X86_StdCall; ;}
     break;
 
   case 92:
-#line 1139 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.ParamAttrs = FunctionType::NoReturnAttribute; }
+#line 1126 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.UIntVal) = CallingConv::X86_FastCall; ;}
+    break;
+
+  case 93:
+#line 1127 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    {
+                   if ((unsigned)(yyvsp[0].UInt64Val) != (yyvsp[0].UInt64Val))
+                     GEN_ERROR("Calling conv too large!");
+                   (yyval.UIntVal) = (yyvsp[0].UInt64Val);
+                  CHECK_FOR_ERROR
+                 ;}
     break;
 
   case 94:
-#line 1143 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.ParamAttrs = FunctionType::NoAttributeSet; }
+#line 1134 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.ParamAttrs) = FunctionType::ZExtAttribute; ;}
     break;
 
   case 95:
-#line 1144 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    {
-                yyval.ParamAttrs = FunctionType::ParameterAttributes(yyvsp[-1].ParamAttrs | yyvsp[0].ParamAttrs);
-              }
+#line 1135 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.ParamAttrs) = FunctionType::SExtAttribute; ;}
     break;
 
   case 96:
-#line 1151 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.UIntVal = 0; }
+#line 1138 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.ParamAttrs) = FunctionType::NoAttributeSet; ;}
     break;
 
   case 97:
-#line 1152 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 1139 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-  yyval.UIntVal = yyvsp[0].UInt64Val;
-  if (yyval.UIntVal != 0 && !isPowerOf2_32(yyval.UIntVal))
-    GEN_ERROR("Alignment must be a power of two!");
-  CHECK_FOR_ERROR
-}
+                (yyval.ParamAttrs) = FunctionType::ParameterAttributes((yyvsp[-1].ParamAttrs) | (yyvsp[0].ParamAttrs));
+              ;}
     break;
 
   case 98:
-#line 1158 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.UIntVal = 0; }
-    break;
-
-  case 99:
-#line 1159 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    {
-  yyval.UIntVal = yyvsp[0].UInt64Val;
-  if (yyval.UIntVal != 0 && !isPowerOf2_32(yyval.UIntVal))
-    GEN_ERROR("Alignment must be a power of two!");
-  CHECK_FOR_ERROR
-}
+#line 1144 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.ParamAttrs) = FunctionType::NoReturnAttribute; ;}
     break;
 
   case 100:
-#line 1167 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    {
-  for (unsigned i = 0, e = strlen(yyvsp[0].StrVal); i != e; ++i)
-    if (yyvsp[0].StrVal[i] == '"' || yyvsp[0].StrVal[i] == '\\')
-      GEN_ERROR("Invalid character in section name!");
-  yyval.StrVal = yyvsp[0].StrVal;
-  CHECK_FOR_ERROR
-}
+#line 1148 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.ParamAttrs) = FunctionType::NoAttributeSet; ;}
     break;
 
   case 101:
-#line 1175 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.StrVal = 0; }
+#line 1149 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    {
+                (yyval.ParamAttrs) = FunctionType::ParameterAttributes((yyvsp[-1].ParamAttrs) | (yyvsp[0].ParamAttrs));
+              ;}
     break;
 
   case 102:
-#line 1176 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.StrVal = yyvsp[0].StrVal; }
+#line 1156 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.UIntVal) = 0; ;}
     break;
 
   case 103:
-#line 1181 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    {}
+#line 1157 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    {
+  (yyval.UIntVal) = (yyvsp[0].UInt64Val);
+  if ((yyval.UIntVal) != 0 && !isPowerOf2_32((yyval.UIntVal)))
+    GEN_ERROR("Alignment must be a power of two!");
+  CHECK_FOR_ERROR
+;}
     break;
 
   case 104:
-#line 1182 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    {}
+#line 1163 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.UIntVal) = 0; ;}
     break;
 
   case 105:
-#line 1183 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 1164 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    CurGV->setSection(yyvsp[0].StrVal);
-    free(yyvsp[0].StrVal);
-    CHECK_FOR_ERROR
-  }
+  (yyval.UIntVal) = (yyvsp[0].UInt64Val);
+  if ((yyval.UIntVal) != 0 && !isPowerOf2_32((yyval.UIntVal)))
+    GEN_ERROR("Alignment must be a power of two!");
+  CHECK_FOR_ERROR
+;}
     break;
 
   case 106:
-#line 1188 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 1172 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    if (yyvsp[0].UInt64Val != 0 && !isPowerOf2_32(yyvsp[0].UInt64Val))
-      GEN_ERROR("Alignment must be a power of two!");
-    CurGV->setAlignment(yyvsp[0].UInt64Val);
-    CHECK_FOR_ERROR
-  }
+  for (unsigned i = 0, e = strlen((yyvsp[0].StrVal)); i != e; ++i)
+    if ((yyvsp[0].StrVal)[i] == '"' || (yyvsp[0].StrVal)[i] == '\\')
+      GEN_ERROR("Invalid character in section name!");
+  (yyval.StrVal) = (yyvsp[0].StrVal);
+  CHECK_FOR_ERROR
+;}
     break;
 
-  case 111:
-#line 1204 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    {
-    yyval.TypeVal = new PATypeHolder(OpaqueType::get());
-    CHECK_FOR_ERROR
-  }
+  case 107:
+#line 1180 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.StrVal) = 0; ;}
     break;
 
-  case 112:
-#line 1208 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    {
-    yyval.TypeVal = new PATypeHolder(yyvsp[0].PrimType);
-    CHECK_FOR_ERROR
-  }
+  case 108:
+#line 1181 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.StrVal) = (yyvsp[0].StrVal); ;}
+    break;
+
+  case 109:
+#line 1186 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    {;}
+    break;
+
+  case 110:
+#line 1187 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    {;}
+    break;
+
+  case 111:
+#line 1188 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    {
+    CurGV->setSection((yyvsp[0].StrVal));
+    free((yyvsp[0].StrVal));
+    CHECK_FOR_ERROR
+  ;}
     break;
 
-  case 113:
-#line 1212 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 112:
+#line 1193 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    {
+    if ((yyvsp[0].UInt64Val) != 0 && !isPowerOf2_32((yyvsp[0].UInt64Val)))
+      GEN_ERROR("Alignment must be a power of two!");
+    CurGV->setAlignment((yyvsp[0].UInt64Val));
+    CHECK_FOR_ERROR
+  ;}
+    break;
+
+  case 117:
+#line 1209 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    {
+    (yyval.TypeVal) = new PATypeHolder(OpaqueType::get());
+    CHECK_FOR_ERROR
+  ;}
+    break;
+
+  case 118:
+#line 1213 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    {
+    (yyval.TypeVal) = new PATypeHolder((yyvsp[0].PrimType));
+    CHECK_FOR_ERROR
+  ;}
+    break;
+
+  case 119:
+#line 1217 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {                             // Pointer type?
-    if (*yyvsp[-1].TypeVal == Type::LabelTy)
+    if (*(yyvsp[-1].TypeVal) == Type::LabelTy)
       GEN_ERROR("Cannot form a pointer to a basic block");
-    yyval.TypeVal = new PATypeHolder(HandleUpRefs(PointerType::get(*yyvsp[-1].TypeVal)));
-    delete yyvsp[-1].TypeVal;
+    (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(PointerType::get(*(yyvsp[-1].TypeVal))));
+    delete (yyvsp[-1].TypeVal);
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 114:
-#line 1219 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 120:
+#line 1224 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {            // Named types are also simple types...
-    const Type* tmp = getTypeVal(yyvsp[0].ValIDVal);
+    const Type* tmp = getTypeVal((yyvsp[0].ValIDVal));
     CHECK_FOR_ERROR
-    yyval.TypeVal = new PATypeHolder(tmp);
-  }
+    (yyval.TypeVal) = new PATypeHolder(tmp);
+  ;}
     break;
 
-  case 115:
-#line 1224 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 121:
+#line 1229 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {                   // Type UpReference
-    if (yyvsp[0].UInt64Val > (uint64_t)~0U) GEN_ERROR("Value out of range!");
+    if ((yyvsp[0].UInt64Val) > (uint64_t)~0U) GEN_ERROR("Value out of range!");
     OpaqueType *OT = OpaqueType::get();        // Use temporary placeholder
-    UpRefs.push_back(UpRefRecord((unsigned)yyvsp[0].UInt64Val, OT));  // Add to vector...
-    yyval.TypeVal = new PATypeHolder(OT);
+    UpRefs.push_back(UpRefRecord((unsigned)(yyvsp[0].UInt64Val), OT));  // Add to vector...
+    (yyval.TypeVal) = new PATypeHolder(OT);
     UR_OUT("New Upreference!\n");
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 116:
-#line 1232 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 122:
+#line 1237 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
     std::vector Params;
     std::vector Attrs;
-    Attrs.push_back(yyvsp[0].ParamAttrs);
-    for (TypeWithAttrsList::iterator I=yyvsp[-2].TypeWithAttrsList->begin(), E=yyvsp[-2].TypeWithAttrsList->end(); I != E; ++I) {
+    Attrs.push_back((yyvsp[0].ParamAttrs));
+    for (TypeWithAttrsList::iterator I=(yyvsp[-2].TypeWithAttrsList)->begin(), E=(yyvsp[-2].TypeWithAttrsList)->end(); I != E; ++I) {
       Params.push_back(I->Ty->get());
       if (I->Ty->get() != Type::VoidTy)
         Attrs.push_back(I->Attrs);
@@ -3265,21 +3472,21 @@
     bool isVarArg = Params.size() && Params.back() == Type::VoidTy;
     if (isVarArg) Params.pop_back();
 
-    FunctionType *FT = FunctionType::get(*yyvsp[-4].TypeVal, Params, isVarArg, Attrs);
-    delete yyvsp[-2].TypeWithAttrsList;   // Delete the argument list
-    delete yyvsp[-4].TypeVal;   // Delete the return type handle
-    yyval.TypeVal = new PATypeHolder(HandleUpRefs(FT)); 
+    FunctionType *FT = FunctionType::get(*(yyvsp[-4].TypeVal), Params, isVarArg, Attrs);
+    delete (yyvsp[-2].TypeWithAttrsList);   // Delete the argument list
+    delete (yyvsp[-4].TypeVal);   // Delete the return type handle
+    (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(FT)); 
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 117:
-#line 1250 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 123:
+#line 1255 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
     std::vector Params;
     std::vector Attrs;
-    Attrs.push_back(yyvsp[0].ParamAttrs);
-    for (TypeWithAttrsList::iterator I=yyvsp[-2].TypeWithAttrsList->begin(), E=yyvsp[-2].TypeWithAttrsList->end(); I != E; ++I) {
+    Attrs.push_back((yyvsp[0].ParamAttrs));
+    for (TypeWithAttrsList::iterator I=(yyvsp[-2].TypeWithAttrsList)->begin(), E=(yyvsp[-2].TypeWithAttrsList)->end(); I != E; ++I) {
       Params.push_back(I->Ty->get());
       if (I->Ty->get() != Type::VoidTy)
         Attrs.push_back(I->Attrs);
@@ -3287,303 +3494,303 @@
     bool isVarArg = Params.size() && Params.back() == Type::VoidTy;
     if (isVarArg) Params.pop_back();
 
-    FunctionType *FT = FunctionType::get(yyvsp[-4].PrimType, Params, isVarArg, Attrs);
-    delete yyvsp[-2].TypeWithAttrsList;      // Delete the argument list
-    yyval.TypeVal = new PATypeHolder(HandleUpRefs(FT)); 
+    FunctionType *FT = FunctionType::get((yyvsp[-4].PrimType), Params, isVarArg, Attrs);
+    delete (yyvsp[-2].TypeWithAttrsList);      // Delete the argument list
+    (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(FT)); 
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 118:
-#line 1268 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 124:
+#line 1273 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {          // Sized array type?
-    yyval.TypeVal = new PATypeHolder(HandleUpRefs(ArrayType::get(*yyvsp[-1].TypeVal, (unsigned)yyvsp[-3].UInt64Val)));
-    delete yyvsp[-1].TypeVal;
+    (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(ArrayType::get(*(yyvsp[-1].TypeVal), (unsigned)(yyvsp[-3].UInt64Val))));
+    delete (yyvsp[-1].TypeVal);
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 119:
-#line 1273 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 125:
+#line 1278 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {          // Packed array type?
-     const llvm::Type* ElemTy = yyvsp[-1].TypeVal->get();
-     if ((unsigned)yyvsp[-3].UInt64Val != yyvsp[-3].UInt64Val)
+     const llvm::Type* ElemTy = (yyvsp[-1].TypeVal)->get();
+     if ((unsigned)(yyvsp[-3].UInt64Val) != (yyvsp[-3].UInt64Val))
         GEN_ERROR("Unsigned result not equal to signed result");
      if (!ElemTy->isFloatingPoint() && !ElemTy->isInteger())
         GEN_ERROR("Element type of a PackedType must be primitive");
-     if (!isPowerOf2_32(yyvsp[-3].UInt64Val))
+     if (!isPowerOf2_32((yyvsp[-3].UInt64Val)))
        GEN_ERROR("Vector length should be a power of 2!");
-     yyval.TypeVal = new PATypeHolder(HandleUpRefs(PackedType::get(*yyvsp[-1].TypeVal, (unsigned)yyvsp[-3].UInt64Val)));
-     delete yyvsp[-1].TypeVal;
+     (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(PackedType::get(*(yyvsp[-1].TypeVal), (unsigned)(yyvsp[-3].UInt64Val))));
+     delete (yyvsp[-1].TypeVal);
      CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 120:
-#line 1285 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 126:
+#line 1290 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {                        // Structure type?
     std::vector Elements;
-    for (std::list::iterator I = yyvsp[-1].TypeList->begin(),
-           E = yyvsp[-1].TypeList->end(); I != E; ++I)
+    for (std::list::iterator I = (yyvsp[-1].TypeList)->begin(),
+           E = (yyvsp[-1].TypeList)->end(); I != E; ++I)
       Elements.push_back(*I);
 
-    yyval.TypeVal = new PATypeHolder(HandleUpRefs(StructType::get(Elements)));
-    delete yyvsp[-1].TypeList;
+    (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(StructType::get(Elements)));
+    delete (yyvsp[-1].TypeList);
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 121:
-#line 1295 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 127:
+#line 1300 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {                                  // Empty structure type?
-    yyval.TypeVal = new PATypeHolder(StructType::get(std::vector()));
+    (yyval.TypeVal) = new PATypeHolder(StructType::get(std::vector()));
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 122:
-#line 1299 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 128:
+#line 1304 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
     std::vector Elements;
-    for (std::list::iterator I = yyvsp[-2].TypeList->begin(),
-           E = yyvsp[-2].TypeList->end(); I != E; ++I)
+    for (std::list::iterator I = (yyvsp[-2].TypeList)->begin(),
+           E = (yyvsp[-2].TypeList)->end(); I != E; ++I)
       Elements.push_back(*I);
 
-    yyval.TypeVal = new PATypeHolder(HandleUpRefs(StructType::get(Elements, true)));
-    delete yyvsp[-2].TypeList;
+    (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(StructType::get(Elements, true)));
+    delete (yyvsp[-2].TypeList);
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 123:
-#line 1309 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 129:
+#line 1314 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {                         // Empty structure type?
-    yyval.TypeVal = new PATypeHolder(StructType::get(std::vector(), true));
+    (yyval.TypeVal) = new PATypeHolder(StructType::get(std::vector(), true));
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 124:
-#line 1316 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 130:
+#line 1321 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     { 
-    yyval.TypeWithAttrs.Ty = yyvsp[-1].TypeVal; 
-    yyval.TypeWithAttrs.Attrs = yyvsp[0].ParamAttrs; 
-  }
+    (yyval.TypeWithAttrs).Ty = (yyvsp[-1].TypeVal); 
+    (yyval.TypeWithAttrs).Attrs = (yyvsp[0].ParamAttrs); 
+  ;}
     break;
 
-  case 125:
-#line 1323 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 131:
+#line 1328 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[0].TypeVal)->getDescription());
-    if (!(*yyvsp[0].TypeVal)->isFirstClassType())
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[0].TypeVal))->getDescription());
+    if (!(*(yyvsp[0].TypeVal))->isFirstClassType())
       GEN_ERROR("LLVM functions cannot return aggregate types!");
-    yyval.TypeVal = yyvsp[0].TypeVal;
-  }
+    (yyval.TypeVal) = (yyvsp[0].TypeVal);
+  ;}
     break;
 
-  case 126:
-#line 1330 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 132:
+#line 1335 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    yyval.TypeVal = new PATypeHolder(Type::VoidTy);
-  }
+    (yyval.TypeVal) = new PATypeHolder(Type::VoidTy);
+  ;}
     break;
 
-  case 127:
-#line 1335 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 133:
+#line 1340 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    yyval.TypeWithAttrsList = new TypeWithAttrsList();
-    yyval.TypeWithAttrsList->push_back(yyvsp[0].TypeWithAttrs);
+    (yyval.TypeWithAttrsList) = new TypeWithAttrsList();
+    (yyval.TypeWithAttrsList)->push_back((yyvsp[0].TypeWithAttrs));
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 128:
-#line 1340 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 134:
+#line 1345 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    (yyval.TypeWithAttrsList=yyvsp[-2].TypeWithAttrsList)->push_back(yyvsp[0].TypeWithAttrs);
+    ((yyval.TypeWithAttrsList)=(yyvsp[-2].TypeWithAttrsList))->push_back((yyvsp[0].TypeWithAttrs));
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 130:
-#line 1348 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 136:
+#line 1353 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    yyval.TypeWithAttrsList=yyvsp[-2].TypeWithAttrsList;
+    (yyval.TypeWithAttrsList)=(yyvsp[-2].TypeWithAttrsList);
     TypeWithAttrs TWA; TWA.Attrs = FunctionType::NoAttributeSet;
     TWA.Ty = new PATypeHolder(Type::VoidTy);
-    yyval.TypeWithAttrsList->push_back(TWA);
+    (yyval.TypeWithAttrsList)->push_back(TWA);
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 131:
-#line 1355 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 137:
+#line 1360 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    yyval.TypeWithAttrsList = new TypeWithAttrsList;
+    (yyval.TypeWithAttrsList) = new TypeWithAttrsList;
     TypeWithAttrs TWA; TWA.Attrs = FunctionType::NoAttributeSet;
     TWA.Ty = new PATypeHolder(Type::VoidTy);
-    yyval.TypeWithAttrsList->push_back(TWA);
+    (yyval.TypeWithAttrsList)->push_back(TWA);
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 132:
-#line 1362 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 138:
+#line 1367 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    yyval.TypeWithAttrsList = new TypeWithAttrsList();
+    (yyval.TypeWithAttrsList) = new TypeWithAttrsList();
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 133:
-#line 1370 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 139:
+#line 1375 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    yyval.TypeList = new std::list();
-    yyval.TypeList->push_back(*yyvsp[0].TypeVal); delete yyvsp[0].TypeVal;
+    (yyval.TypeList) = new std::list();
+    (yyval.TypeList)->push_back(*(yyvsp[0].TypeVal)); delete (yyvsp[0].TypeVal);
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 134:
-#line 1375 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 140:
+#line 1380 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    (yyval.TypeList=yyvsp[-2].TypeList)->push_back(*yyvsp[0].TypeVal); delete yyvsp[0].TypeVal;
+    ((yyval.TypeList)=(yyvsp[-2].TypeList))->push_back(*(yyvsp[0].TypeVal)); delete (yyvsp[0].TypeVal);
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 135:
-#line 1386 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 141:
+#line 1391 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     { // Nonempty unsized arr
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-3].TypeVal)->getDescription());
-    const ArrayType *ATy = dyn_cast(yyvsp[-3].TypeVal->get());
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-3].TypeVal))->getDescription());
+    const ArrayType *ATy = dyn_cast((yyvsp[-3].TypeVal)->get());
     if (ATy == 0)
       GEN_ERROR("Cannot make array constant with type: '" + 
-                     (*yyvsp[-3].TypeVal)->getDescription() + "'!");
+                     (*(yyvsp[-3].TypeVal))->getDescription() + "'!");
     const Type *ETy = ATy->getElementType();
     int NumElements = ATy->getNumElements();
 
     // Verify that we have the correct size...
-    if (NumElements != -1 && NumElements != (int)yyvsp[-1].ConstVector->size())
+    if (NumElements != -1 && NumElements != (int)(yyvsp[-1].ConstVector)->size())
       GEN_ERROR("Type mismatch: constant sized array initialized with " +
-                     utostr(yyvsp[-1].ConstVector->size()) +  " arguments, but has size of " + 
+                     utostr((yyvsp[-1].ConstVector)->size()) +  " arguments, but has size of " + 
                      itostr(NumElements) + "!");
 
     // Verify all elements are correct type!
-    for (unsigned i = 0; i < yyvsp[-1].ConstVector->size(); i++) {
-      if (ETy != (*yyvsp[-1].ConstVector)[i]->getType())
+    for (unsigned i = 0; i < (yyvsp[-1].ConstVector)->size(); i++) {
+      if (ETy != (*(yyvsp[-1].ConstVector))[i]->getType())
         GEN_ERROR("Element #" + utostr(i) + " is not of type '" + 
                        ETy->getDescription() +"' as required!\nIt is of type '"+
-                       (*yyvsp[-1].ConstVector)[i]->getType()->getDescription() + "'.");
+                       (*(yyvsp[-1].ConstVector))[i]->getType()->getDescription() + "'.");
     }
 
-    yyval.ConstVal = ConstantArray::get(ATy, *yyvsp[-1].ConstVector);
-    delete yyvsp[-3].TypeVal; delete yyvsp[-1].ConstVector;
+    (yyval.ConstVal) = ConstantArray::get(ATy, *(yyvsp[-1].ConstVector));
+    delete (yyvsp[-3].TypeVal); delete (yyvsp[-1].ConstVector);
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 136:
-#line 1414 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 142:
+#line 1419 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription());
-    const ArrayType *ATy = dyn_cast(yyvsp[-2].TypeVal->get());
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-2].TypeVal))->getDescription());
+    const ArrayType *ATy = dyn_cast((yyvsp[-2].TypeVal)->get());
     if (ATy == 0)
       GEN_ERROR("Cannot make array constant with type: '" + 
-                     (*yyvsp[-2].TypeVal)->getDescription() + "'!");
+                     (*(yyvsp[-2].TypeVal))->getDescription() + "'!");
 
     int NumElements = ATy->getNumElements();
     if (NumElements != -1 && NumElements != 0) 
       GEN_ERROR("Type mismatch: constant sized array initialized with 0"
                      " arguments, but has size of " + itostr(NumElements) +"!");
-    yyval.ConstVal = ConstantArray::get(ATy, std::vector());
-    delete yyvsp[-2].TypeVal;
+    (yyval.ConstVal) = ConstantArray::get(ATy, std::vector());
+    delete (yyvsp[-2].TypeVal);
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 137:
-#line 1430 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 143:
+#line 1435 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription());
-    const ArrayType *ATy = dyn_cast(yyvsp[-2].TypeVal->get());
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-2].TypeVal))->getDescription());
+    const ArrayType *ATy = dyn_cast((yyvsp[-2].TypeVal)->get());
     if (ATy == 0)
       GEN_ERROR("Cannot make array constant with type: '" + 
-                     (*yyvsp[-2].TypeVal)->getDescription() + "'!");
+                     (*(yyvsp[-2].TypeVal))->getDescription() + "'!");
 
     int NumElements = ATy->getNumElements();
     const Type *ETy = ATy->getElementType();
-    char *EndStr = UnEscapeLexed(yyvsp[0].StrVal, true);
-    if (NumElements != -1 && NumElements != (EndStr-yyvsp[0].StrVal))
+    char *EndStr = UnEscapeLexed((yyvsp[0].StrVal), true);
+    if (NumElements != -1 && NumElements != (EndStr-(yyvsp[0].StrVal)))
       GEN_ERROR("Can't build string constant of size " + 
-                     itostr((int)(EndStr-yyvsp[0].StrVal)) +
+                     itostr((int)(EndStr-(yyvsp[0].StrVal))) +
                      " when array has size " + itostr(NumElements) + "!");
     std::vector Vals;
     if (ETy == Type::Int8Ty) {
-      for (unsigned char *C = (unsigned char *)yyvsp[0].StrVal; 
+      for (unsigned char *C = (unsigned char *)(yyvsp[0].StrVal); 
         C != (unsigned char*)EndStr; ++C)
       Vals.push_back(ConstantInt::get(ETy, *C));
     } else {
-      free(yyvsp[0].StrVal);
+      free((yyvsp[0].StrVal));
       GEN_ERROR("Cannot build string arrays of non byte sized elements!");
     }
-    free(yyvsp[0].StrVal);
-    yyval.ConstVal = ConstantArray::get(ATy, Vals);
-    delete yyvsp[-2].TypeVal;
+    free((yyvsp[0].StrVal));
+    (yyval.ConstVal) = ConstantArray::get(ATy, Vals);
+    delete (yyvsp[-2].TypeVal);
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 138:
-#line 1459 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 144:
+#line 1464 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     { // Nonempty unsized arr
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-3].TypeVal)->getDescription());
-    const PackedType *PTy = dyn_cast(yyvsp[-3].TypeVal->get());
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-3].TypeVal))->getDescription());
+    const PackedType *PTy = dyn_cast((yyvsp[-3].TypeVal)->get());
     if (PTy == 0)
       GEN_ERROR("Cannot make packed constant with type: '" + 
-                     (*yyvsp[-3].TypeVal)->getDescription() + "'!");
+                     (*(yyvsp[-3].TypeVal))->getDescription() + "'!");
     const Type *ETy = PTy->getElementType();
     int NumElements = PTy->getNumElements();
 
     // Verify that we have the correct size...
-    if (NumElements != -1 && NumElements != (int)yyvsp[-1].ConstVector->size())
+    if (NumElements != -1 && NumElements != (int)(yyvsp[-1].ConstVector)->size())
       GEN_ERROR("Type mismatch: constant sized packed initialized with " +
-                     utostr(yyvsp[-1].ConstVector->size()) +  " arguments, but has size of " + 
+                     utostr((yyvsp[-1].ConstVector)->size()) +  " arguments, but has size of " + 
                      itostr(NumElements) + "!");
 
     // Verify all elements are correct type!
-    for (unsigned i = 0; i < yyvsp[-1].ConstVector->size(); i++) {
-      if (ETy != (*yyvsp[-1].ConstVector)[i]->getType())
+    for (unsigned i = 0; i < (yyvsp[-1].ConstVector)->size(); i++) {
+      if (ETy != (*(yyvsp[-1].ConstVector))[i]->getType())
         GEN_ERROR("Element #" + utostr(i) + " is not of type '" + 
            ETy->getDescription() +"' as required!\nIt is of type '"+
-           (*yyvsp[-1].ConstVector)[i]->getType()->getDescription() + "'.");
+           (*(yyvsp[-1].ConstVector))[i]->getType()->getDescription() + "'.");
     }
 
-    yyval.ConstVal = ConstantPacked::get(PTy, *yyvsp[-1].ConstVector);
-    delete yyvsp[-3].TypeVal; delete yyvsp[-1].ConstVector;
+    (yyval.ConstVal) = ConstantPacked::get(PTy, *(yyvsp[-1].ConstVector));
+    delete (yyvsp[-3].TypeVal); delete (yyvsp[-1].ConstVector);
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 139:
-#line 1487 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 145:
+#line 1492 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    const StructType *STy = dyn_cast(yyvsp[-3].TypeVal->get());
+    const StructType *STy = dyn_cast((yyvsp[-3].TypeVal)->get());
     if (STy == 0)
       GEN_ERROR("Cannot make struct constant with type: '" + 
-                     (*yyvsp[-3].TypeVal)->getDescription() + "'!");
+                     (*(yyvsp[-3].TypeVal))->getDescription() + "'!");
 
-    if (yyvsp[-1].ConstVector->size() != STy->getNumContainedTypes())
+    if ((yyvsp[-1].ConstVector)->size() != STy->getNumContainedTypes())
       GEN_ERROR("Illegal number of initializers for structure type!");
 
     // Check to ensure that constants are compatible with the type initializer!
-    for (unsigned i = 0, e = yyvsp[-1].ConstVector->size(); i != e; ++i)
-      if ((*yyvsp[-1].ConstVector)[i]->getType() != STy->getElementType(i))
+    for (unsigned i = 0, e = (yyvsp[-1].ConstVector)->size(); i != e; ++i)
+      if ((*(yyvsp[-1].ConstVector))[i]->getType() != STy->getElementType(i))
         GEN_ERROR("Expected type '" +
                        STy->getElementType(i)->getDescription() +
                        "' for element #" + utostr(i) +
@@ -3593,21 +3800,21 @@
     if (STy->isPacked())
       GEN_ERROR("Unpacked Initializer to packed type '" + STy->getDescription() + "'");
 
-    yyval.ConstVal = ConstantStruct::get(STy, *yyvsp[-1].ConstVector);
-    delete yyvsp[-3].TypeVal; delete yyvsp[-1].ConstVector;
+    (yyval.ConstVal) = ConstantStruct::get(STy, *(yyvsp[-1].ConstVector));
+    delete (yyvsp[-3].TypeVal); delete (yyvsp[-1].ConstVector);
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 140:
-#line 1512 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 146:
+#line 1517 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription());
-    const StructType *STy = dyn_cast(yyvsp[-2].TypeVal->get());
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-2].TypeVal))->getDescription());
+    const StructType *STy = dyn_cast((yyvsp[-2].TypeVal)->get());
     if (STy == 0)
       GEN_ERROR("Cannot make struct constant with type: '" + 
-                     (*yyvsp[-2].TypeVal)->getDescription() + "'!");
+                     (*(yyvsp[-2].TypeVal))->getDescription() + "'!");
 
     if (STy->getNumContainedTypes() != 0)
       GEN_ERROR("Illegal number of initializers for structure type!");
@@ -3616,26 +3823,26 @@
     if (STy->isPacked())
       GEN_ERROR("Unpacked Initializer to packed type '" + STy->getDescription() + "'");
 
-    yyval.ConstVal = ConstantStruct::get(STy, std::vector());
-    delete yyvsp[-2].TypeVal;
+    (yyval.ConstVal) = ConstantStruct::get(STy, std::vector());
+    delete (yyvsp[-2].TypeVal);
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 141:
-#line 1531 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 147:
+#line 1536 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    const StructType *STy = dyn_cast(yyvsp[-5].TypeVal->get());
+    const StructType *STy = dyn_cast((yyvsp[-5].TypeVal)->get());
     if (STy == 0)
       GEN_ERROR("Cannot make struct constant with type: '" + 
-                     (*yyvsp[-5].TypeVal)->getDescription() + "'!");
+                     (*(yyvsp[-5].TypeVal))->getDescription() + "'!");
 
-    if (yyvsp[-2].ConstVector->size() != STy->getNumContainedTypes())
+    if ((yyvsp[-2].ConstVector)->size() != STy->getNumContainedTypes())
       GEN_ERROR("Illegal number of initializers for structure type!");
 
     // Check to ensure that constants are compatible with the type initializer!
-    for (unsigned i = 0, e = yyvsp[-2].ConstVector->size(); i != e; ++i)
-      if ((*yyvsp[-2].ConstVector)[i]->getType() != STy->getElementType(i))
+    for (unsigned i = 0, e = (yyvsp[-2].ConstVector)->size(); i != e; ++i)
+      if ((*(yyvsp[-2].ConstVector))[i]->getType() != STy->getElementType(i))
         GEN_ERROR("Expected type '" +
                        STy->getElementType(i)->getDescription() +
                        "' for element #" + utostr(i) +
@@ -3645,21 +3852,21 @@
     if (!STy->isPacked())
       GEN_ERROR("Packed Initializer to unpacked type '" + STy->getDescription() + "'");
 
-    yyval.ConstVal = ConstantStruct::get(STy, *yyvsp[-2].ConstVector);
-    delete yyvsp[-5].TypeVal; delete yyvsp[-2].ConstVector;
+    (yyval.ConstVal) = ConstantStruct::get(STy, *(yyvsp[-2].ConstVector));
+    delete (yyvsp[-5].TypeVal); delete (yyvsp[-2].ConstVector);
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 142:
-#line 1556 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 148:
+#line 1561 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-4].TypeVal)->getDescription());
-    const StructType *STy = dyn_cast(yyvsp[-4].TypeVal->get());
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-4].TypeVal))->getDescription());
+    const StructType *STy = dyn_cast((yyvsp[-4].TypeVal)->get());
     if (STy == 0)
       GEN_ERROR("Cannot make struct constant with type: '" + 
-                     (*yyvsp[-4].TypeVal)->getDescription() + "'!");
+                     (*(yyvsp[-4].TypeVal))->getDescription() + "'!");
 
     if (STy->getNumContainedTypes() != 0)
       GEN_ERROR("Illegal number of initializers for structure type!");
@@ -3668,45 +3875,45 @@
     if (!STy->isPacked())
       GEN_ERROR("Packed Initializer to unpacked type '" + STy->getDescription() + "'");
 
-    yyval.ConstVal = ConstantStruct::get(STy, std::vector());
-    delete yyvsp[-4].TypeVal;
+    (yyval.ConstVal) = ConstantStruct::get(STy, std::vector());
+    delete (yyvsp[-4].TypeVal);
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 143:
-#line 1575 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 149:
+#line 1580 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
-    const PointerType *PTy = dyn_cast(yyvsp[-1].TypeVal->get());
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-1].TypeVal))->getDescription());
+    const PointerType *PTy = dyn_cast((yyvsp[-1].TypeVal)->get());
     if (PTy == 0)
       GEN_ERROR("Cannot make null pointer constant with type: '" + 
-                     (*yyvsp[-1].TypeVal)->getDescription() + "'!");
+                     (*(yyvsp[-1].TypeVal))->getDescription() + "'!");
 
-    yyval.ConstVal = ConstantPointerNull::get(PTy);
-    delete yyvsp[-1].TypeVal;
+    (yyval.ConstVal) = ConstantPointerNull::get(PTy);
+    delete (yyvsp[-1].TypeVal);
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 144:
-#line 1587 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 150:
+#line 1592 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
-    yyval.ConstVal = UndefValue::get(yyvsp[-1].TypeVal->get());
-    delete yyvsp[-1].TypeVal;
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-1].TypeVal))->getDescription());
+    (yyval.ConstVal) = UndefValue::get((yyvsp[-1].TypeVal)->get());
+    delete (yyvsp[-1].TypeVal);
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 145:
-#line 1594 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 151:
+#line 1599 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
-    const PointerType *Ty = dyn_cast(yyvsp[-1].TypeVal->get());
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-1].TypeVal))->getDescription());
+    const PointerType *Ty = dyn_cast((yyvsp[-1].TypeVal)->get());
     if (Ty == 0)
       GEN_ERROR("Global const reference must be a pointer type!");
 
@@ -3720,7 +3927,7 @@
     Function *SavedCurFn = CurFun.CurrentFunction;
     CurFun.CurrentFunction = 0;
 
-    Value *V = getValNonImprovising(Ty, yyvsp[0].ValIDVal);
+    Value *V = getValNonImprovising(Ty, (yyvsp[0].ValIDVal));
     CHECK_FOR_ERROR
 
     CurFun.CurrentFunction = SavedCurFn;
@@ -3735,14 +3942,17 @@
 
       // First check to see if the forward references value is already created!
       PerModuleInfo::GlobalRefsType::iterator I =
-        CurModule.GlobalRefs.find(std::make_pair(PT, yyvsp[0].ValIDVal));
+        CurModule.GlobalRefs.find(std::make_pair(PT, (yyvsp[0].ValIDVal)));
     
       if (I != CurModule.GlobalRefs.end()) {
         V = I->second;             // Placeholder already exists, use it...
-        yyvsp[0].ValIDVal.destroy();
+        (yyvsp[0].ValIDVal).destroy();
       } else {
         std::string Name;
-        if (yyvsp[0].ValIDVal.Type == ValID::NameVal) Name = yyvsp[0].ValIDVal.Name;
+        if ((yyvsp[0].ValIDVal).Type == ValID::GlobalName)
+          Name = (yyvsp[0].ValIDVal).Name;
+        else if ((yyvsp[0].ValIDVal).Type != ValID::GlobalID)
+          GEN_ERROR("Invalid reference to global");
 
         // Create the forward referenced global.
         GlobalValue *GV;
@@ -3757,330 +3967,330 @@
         }
 
         // Keep track of the fact that we have a forward ref to recycle it
-        CurModule.GlobalRefs.insert(std::make_pair(std::make_pair(PT, yyvsp[0].ValIDVal), GV));
+        CurModule.GlobalRefs.insert(std::make_pair(std::make_pair(PT, (yyvsp[0].ValIDVal)), GV));
         V = GV;
       }
     }
 
-    yyval.ConstVal = cast(V);
-    delete yyvsp[-1].TypeVal;            // Free the type handle
+    (yyval.ConstVal) = cast(V);
+    delete (yyvsp[-1].TypeVal);            // Free the type handle
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 146:
-#line 1657 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 152:
+#line 1665 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
-    if (yyvsp[-1].TypeVal->get() != yyvsp[0].ConstVal->getType())
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-1].TypeVal))->getDescription());
+    if ((yyvsp[-1].TypeVal)->get() != (yyvsp[0].ConstVal)->getType())
       GEN_ERROR("Mismatched types for constant expression: " + 
-        (*yyvsp[-1].TypeVal)->getDescription() + " and " + yyvsp[0].ConstVal->getType()->getDescription());
-    yyval.ConstVal = yyvsp[0].ConstVal;
-    delete yyvsp[-1].TypeVal;
+        (*(yyvsp[-1].TypeVal))->getDescription() + " and " + (yyvsp[0].ConstVal)->getType()->getDescription());
+    (yyval.ConstVal) = (yyvsp[0].ConstVal);
+    delete (yyvsp[-1].TypeVal);
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 147:
-#line 1667 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 153:
+#line 1675 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
-    const Type *Ty = yyvsp[-1].TypeVal->get();
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-1].TypeVal))->getDescription());
+    const Type *Ty = (yyvsp[-1].TypeVal)->get();
     if (isa(Ty) || Ty == Type::LabelTy || isa(Ty))
       GEN_ERROR("Cannot create a null initialized value of this type!");
-    yyval.ConstVal = Constant::getNullValue(Ty);
-    delete yyvsp[-1].TypeVal;
+    (yyval.ConstVal) = Constant::getNullValue(Ty);
+    delete (yyvsp[-1].TypeVal);
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 148:
-#line 1677 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 154:
+#line 1685 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {      // integral constants
-    if (!ConstantInt::isValueValidForType(yyvsp[-1].PrimType, yyvsp[0].SInt64Val))
+    if (!ConstantInt::isValueValidForType((yyvsp[-1].PrimType), (yyvsp[0].SInt64Val)))
       GEN_ERROR("Constant value doesn't fit in type!");
-    yyval.ConstVal = ConstantInt::get(yyvsp[-1].PrimType, yyvsp[0].SInt64Val);
+    (yyval.ConstVal) = ConstantInt::get((yyvsp[-1].PrimType), (yyvsp[0].SInt64Val));
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 149:
-#line 1683 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 155:
+#line 1691 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {      // integral constants
-    if (!ConstantInt::isValueValidForType(yyvsp[-1].PrimType, yyvsp[0].UInt64Val))
+    if (!ConstantInt::isValueValidForType((yyvsp[-1].PrimType), (yyvsp[0].UInt64Val)))
       GEN_ERROR("Constant value doesn't fit in type!");
-    yyval.ConstVal = ConstantInt::get(yyvsp[-1].PrimType, yyvsp[0].UInt64Val);
+    (yyval.ConstVal) = ConstantInt::get((yyvsp[-1].PrimType), (yyvsp[0].UInt64Val));
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 150:
-#line 1689 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 156:
+#line 1697 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {                      // Boolean constants
-    assert(cast(yyvsp[-1].PrimType)->getBitWidth() == 1 && "Not Bool?");
-    yyval.ConstVal = ConstantInt::getTrue();
+    assert(cast((yyvsp[-1].PrimType))->getBitWidth() == 1 && "Not Bool?");
+    (yyval.ConstVal) = ConstantInt::getTrue();
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 151:
-#line 1694 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 157:
+#line 1702 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {                     // Boolean constants
-    assert(cast(yyvsp[-1].PrimType)->getBitWidth() == 1 && "Not Bool?");
-    yyval.ConstVal = ConstantInt::getFalse();
+    assert(cast((yyvsp[-1].PrimType))->getBitWidth() == 1 && "Not Bool?");
+    (yyval.ConstVal) = ConstantInt::getFalse();
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 152:
-#line 1699 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 158:
+#line 1707 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {                   // Float & Double constants
-    if (!ConstantFP::isValueValidForType(yyvsp[-1].PrimType, yyvsp[0].FPVal))
+    if (!ConstantFP::isValueValidForType((yyvsp[-1].PrimType), (yyvsp[0].FPVal)))
       GEN_ERROR("Floating point constant invalid for type!!");
-    yyval.ConstVal = ConstantFP::get(yyvsp[-1].PrimType, yyvsp[0].FPVal);
+    (yyval.ConstVal) = ConstantFP::get((yyvsp[-1].PrimType), (yyvsp[0].FPVal));
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 153:
-#line 1707 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 159:
+#line 1715 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
-    Constant *Val = yyvsp[-3].ConstVal;
-    const Type *DestTy = yyvsp[-1].TypeVal->get();
-    if (!CastInst::castIsValid(yyvsp[-5].CastOpVal, yyvsp[-3].ConstVal, DestTy))
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-1].TypeVal))->getDescription());
+    Constant *Val = (yyvsp[-3].ConstVal);
+    const Type *DestTy = (yyvsp[-1].TypeVal)->get();
+    if (!CastInst::castIsValid((yyvsp[-5].CastOpVal), (yyvsp[-3].ConstVal), DestTy))
       GEN_ERROR("invalid cast opcode for cast from '" +
                 Val->getType()->getDescription() + "' to '" +
                 DestTy->getDescription() + "'!"); 
-    yyval.ConstVal = ConstantExpr::getCast(yyvsp[-5].CastOpVal, yyvsp[-3].ConstVal, DestTy);
-    delete yyvsp[-1].TypeVal;
-  }
+    (yyval.ConstVal) = ConstantExpr::getCast((yyvsp[-5].CastOpVal), (yyvsp[-3].ConstVal), DestTy);
+    delete (yyvsp[-1].TypeVal);
+  ;}
     break;
 
-  case 154:
-#line 1719 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 160:
+#line 1727 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    if (!isa(yyvsp[-2].ConstVal->getType()))
+    if (!isa((yyvsp[-2].ConstVal)->getType()))
       GEN_ERROR("GetElementPtr requires a pointer operand!");
 
     const Type *IdxTy =
-      GetElementPtrInst::getIndexedType(yyvsp[-2].ConstVal->getType(), *yyvsp[-1].ValueList, true);
+      GetElementPtrInst::getIndexedType((yyvsp[-2].ConstVal)->getType(), *(yyvsp[-1].ValueList), true);
     if (!IdxTy)
       GEN_ERROR("Index list invalid for constant getelementptr!");
 
     std::vector IdxVec;
-    for (unsigned i = 0, e = yyvsp[-1].ValueList->size(); i != e; ++i)
-      if (Constant *C = dyn_cast((*yyvsp[-1].ValueList)[i]))
+    for (unsigned i = 0, e = (yyvsp[-1].ValueList)->size(); i != e; ++i)
+      if (Constant *C = dyn_cast((*(yyvsp[-1].ValueList))[i]))
         IdxVec.push_back(C);
       else
         GEN_ERROR("Indices to constant getelementptr must be constants!");
 
-    delete yyvsp[-1].ValueList;
+    delete (yyvsp[-1].ValueList);
 
-    yyval.ConstVal = ConstantExpr::getGetElementPtr(yyvsp[-2].ConstVal, IdxVec);
+    (yyval.ConstVal) = ConstantExpr::getGetElementPtr((yyvsp[-2].ConstVal), IdxVec);
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 155:
-#line 1740 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 161:
+#line 1748 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    if (yyvsp[-5].ConstVal->getType() != Type::Int1Ty)
+    if ((yyvsp[-5].ConstVal)->getType() != Type::Int1Ty)
       GEN_ERROR("Select condition must be of boolean type!");
-    if (yyvsp[-3].ConstVal->getType() != yyvsp[-1].ConstVal->getType())
+    if ((yyvsp[-3].ConstVal)->getType() != (yyvsp[-1].ConstVal)->getType())
       GEN_ERROR("Select operand types must match!");
-    yyval.ConstVal = ConstantExpr::getSelect(yyvsp[-5].ConstVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
+    (yyval.ConstVal) = ConstantExpr::getSelect((yyvsp[-5].ConstVal), (yyvsp[-3].ConstVal), (yyvsp[-1].ConstVal));
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 156:
-#line 1748 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 162:
+#line 1756 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    if (yyvsp[-3].ConstVal->getType() != yyvsp[-1].ConstVal->getType())
+    if ((yyvsp[-3].ConstVal)->getType() != (yyvsp[-1].ConstVal)->getType())
       GEN_ERROR("Binary operator types must match!");
     CHECK_FOR_ERROR;
-    yyval.ConstVal = ConstantExpr::get(yyvsp[-5].BinaryOpVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
-  }
+    (yyval.ConstVal) = ConstantExpr::get((yyvsp[-5].BinaryOpVal), (yyvsp[-3].ConstVal), (yyvsp[-1].ConstVal));
+  ;}
     break;
 
-  case 157:
-#line 1754 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 163:
+#line 1762 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    if (yyvsp[-3].ConstVal->getType() != yyvsp[-1].ConstVal->getType())
+    if ((yyvsp[-3].ConstVal)->getType() != (yyvsp[-1].ConstVal)->getType())
       GEN_ERROR("Logical operator types must match!");
-    if (!yyvsp[-3].ConstVal->getType()->isInteger()) {
-      if (!isa(yyvsp[-3].ConstVal->getType()) || 
-          !cast(yyvsp[-3].ConstVal->getType())->getElementType()->isInteger())
+    if (!(yyvsp[-3].ConstVal)->getType()->isInteger()) {
+      if (!isa((yyvsp[-3].ConstVal)->getType()) || 
+          !cast((yyvsp[-3].ConstVal)->getType())->getElementType()->isInteger())
         GEN_ERROR("Logical operator requires integral operands!");
     }
-    yyval.ConstVal = ConstantExpr::get(yyvsp[-5].BinaryOpVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
+    (yyval.ConstVal) = ConstantExpr::get((yyvsp[-5].BinaryOpVal), (yyvsp[-3].ConstVal), (yyvsp[-1].ConstVal));
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 158:
-#line 1765 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 164:
+#line 1773 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    if (yyvsp[-3].ConstVal->getType() != yyvsp[-1].ConstVal->getType())
+    if ((yyvsp[-3].ConstVal)->getType() != (yyvsp[-1].ConstVal)->getType())
       GEN_ERROR("icmp operand types must match!");
-    yyval.ConstVal = ConstantExpr::getICmp(yyvsp[-5].IPredicate, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
-  }
+    (yyval.ConstVal) = ConstantExpr::getICmp((yyvsp[-5].IPredicate), (yyvsp[-3].ConstVal), (yyvsp[-1].ConstVal));
+  ;}
     break;
 
-  case 159:
-#line 1770 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 165:
+#line 1778 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    if (yyvsp[-3].ConstVal->getType() != yyvsp[-1].ConstVal->getType())
+    if ((yyvsp[-3].ConstVal)->getType() != (yyvsp[-1].ConstVal)->getType())
       GEN_ERROR("fcmp operand types must match!");
-    yyval.ConstVal = ConstantExpr::getFCmp(yyvsp[-5].FPredicate, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
-  }
+    (yyval.ConstVal) = ConstantExpr::getFCmp((yyvsp[-5].FPredicate), (yyvsp[-3].ConstVal), (yyvsp[-1].ConstVal));
+  ;}
     break;
 
-  case 160:
-#line 1775 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 166:
+#line 1783 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    if (yyvsp[-1].ConstVal->getType() != Type::Int8Ty)
+    if ((yyvsp[-1].ConstVal)->getType() != Type::Int8Ty)
       GEN_ERROR("Shift count for shift constant must be i8 type!");
-    if (!yyvsp[-3].ConstVal->getType()->isInteger())
+    if (!(yyvsp[-3].ConstVal)->getType()->isInteger())
       GEN_ERROR("Shift constant expression requires integer operand!");
     CHECK_FOR_ERROR;
-    yyval.ConstVal = ConstantExpr::get(yyvsp[-5].OtherOpVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
+    (yyval.ConstVal) = ConstantExpr::get((yyvsp[-5].OtherOpVal), (yyvsp[-3].ConstVal), (yyvsp[-1].ConstVal));
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 161:
-#line 1784 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 167:
+#line 1792 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    if (!ExtractElementInst::isValidOperands(yyvsp[-3].ConstVal, yyvsp[-1].ConstVal))
+    if (!ExtractElementInst::isValidOperands((yyvsp[-3].ConstVal), (yyvsp[-1].ConstVal)))
       GEN_ERROR("Invalid extractelement operands!");
-    yyval.ConstVal = ConstantExpr::getExtractElement(yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
+    (yyval.ConstVal) = ConstantExpr::getExtractElement((yyvsp[-3].ConstVal), (yyvsp[-1].ConstVal));
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 162:
-#line 1790 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 168:
+#line 1798 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    if (!InsertElementInst::isValidOperands(yyvsp[-5].ConstVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal))
+    if (!InsertElementInst::isValidOperands((yyvsp[-5].ConstVal), (yyvsp[-3].ConstVal), (yyvsp[-1].ConstVal)))
       GEN_ERROR("Invalid insertelement operands!");
-    yyval.ConstVal = ConstantExpr::getInsertElement(yyvsp[-5].ConstVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
+    (yyval.ConstVal) = ConstantExpr::getInsertElement((yyvsp[-5].ConstVal), (yyvsp[-3].ConstVal), (yyvsp[-1].ConstVal));
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 163:
-#line 1796 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 169:
+#line 1804 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    if (!ShuffleVectorInst::isValidOperands(yyvsp[-5].ConstVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal))
+    if (!ShuffleVectorInst::isValidOperands((yyvsp[-5].ConstVal), (yyvsp[-3].ConstVal), (yyvsp[-1].ConstVal)))
       GEN_ERROR("Invalid shufflevector operands!");
-    yyval.ConstVal = ConstantExpr::getShuffleVector(yyvsp[-5].ConstVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
+    (yyval.ConstVal) = ConstantExpr::getShuffleVector((yyvsp[-5].ConstVal), (yyvsp[-3].ConstVal), (yyvsp[-1].ConstVal));
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 164:
-#line 1805 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 170:
+#line 1813 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    (yyval.ConstVector = yyvsp[-2].ConstVector)->push_back(yyvsp[0].ConstVal);
+    ((yyval.ConstVector) = (yyvsp[-2].ConstVector))->push_back((yyvsp[0].ConstVal));
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 165:
-#line 1809 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 171:
+#line 1817 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    yyval.ConstVector = new std::vector();
-    yyval.ConstVector->push_back(yyvsp[0].ConstVal);
+    (yyval.ConstVector) = new std::vector();
+    (yyval.ConstVector)->push_back((yyvsp[0].ConstVal));
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 166:
-#line 1817 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.BoolVal = false; }
+  case 172:
+#line 1825 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.BoolVal) = false; ;}
     break;
 
-  case 167:
-#line 1817 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.BoolVal = true; }
+  case 173:
+#line 1825 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.BoolVal) = true; ;}
     break;
 
-  case 168:
-#line 1828 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 174:
+#line 1836 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    yyval.ModuleVal = ParserResult = CurModule.CurrentModule;
+    (yyval.ModuleVal) = ParserResult = CurModule.CurrentModule;
     CurModule.ModuleDone();
     CHECK_FOR_ERROR;
-  }
+  ;}
     break;
 
-  case 169:
-#line 1833 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 175:
+#line 1841 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    yyval.ModuleVal = ParserResult = CurModule.CurrentModule;
+    (yyval.ModuleVal) = ParserResult = CurModule.CurrentModule;
     CurModule.ModuleDone();
     CHECK_FOR_ERROR;
-  }
+  ;}
     break;
 
-  case 172:
-#line 1846 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { CurFun.isDeclare = false; }
+  case 178:
+#line 1854 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { CurFun.isDeclare = false; ;}
     break;
 
-  case 173:
-#line 1846 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 179:
+#line 1854 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
     CurFun.FunctionDone();
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 174:
-#line 1850 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { CurFun.isDeclare = true; }
+  case 180:
+#line 1858 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { CurFun.isDeclare = true; ;}
     break;
 
-  case 175:
-#line 1850 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 181:
+#line 1858 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 176:
-#line 1853 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 182:
+#line 1861 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 177:
-#line 1856 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 183:
+#line 1864 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
     // Emit an error if there are any unresolved types left.
     if (!CurModule.LateResolveTypes.empty()) {
       const ValID &DID = CurModule.LateResolveTypes.begin()->first;
-      if (DID.Type == ValID::NameVal) {
+      if (DID.Type == ValID::LocalName) {
         GEN_ERROR("Reference to an undefined type: '"+DID.getName() + "'");
       } else {
         GEN_ERROR("Reference to an undefined type: #" + itostr(DID.Num));
       }
     }
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 178:
-#line 1868 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 184:
+#line 1876 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[0].TypeVal)->getDescription());
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[0].TypeVal))->getDescription());
     // Eagerly resolve types.  This is not an optimization, this is a
     // requirement that is due to the fact that we could have this:
     //
@@ -4090,283 +4300,248 @@
     // If types are not resolved eagerly, then the two types will not be
     // determined to be the same type!
     //
-    ResolveTypeTo(yyvsp[-2].StrVal, *yyvsp[0].TypeVal);
+    ResolveTypeTo((yyvsp[-2].StrVal), *(yyvsp[0].TypeVal));
 
-    if (!setTypeName(*yyvsp[0].TypeVal, yyvsp[-2].StrVal) && !yyvsp[-2].StrVal) {
+    if (!setTypeName(*(yyvsp[0].TypeVal), (yyvsp[-2].StrVal)) && !(yyvsp[-2].StrVal)) {
       CHECK_FOR_ERROR
       // If this is a named type that is not a redefinition, add it to the slot
       // table.
-      CurModule.Types.push_back(*yyvsp[0].TypeVal);
+      CurModule.Types.push_back(*(yyvsp[0].TypeVal));
     }
 
-    delete yyvsp[0].TypeVal;
+    delete (yyvsp[0].TypeVal);
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 179:
-#line 1892 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 185:
+#line 1900 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    ResolveTypeTo(yyvsp[-2].StrVal, yyvsp[0].PrimType);
+    ResolveTypeTo((yyvsp[-2].StrVal), (yyvsp[0].PrimType));
 
-    if (!setTypeName(yyvsp[0].PrimType, yyvsp[-2].StrVal) && !yyvsp[-2].StrVal) {
+    if (!setTypeName((yyvsp[0].PrimType), (yyvsp[-2].StrVal)) && !(yyvsp[-2].StrVal)) {
       CHECK_FOR_ERROR
       // If this is a named type that is not a redefinition, add it to the slot
       // table.
-      CurModule.Types.push_back(yyvsp[0].PrimType);
+      CurModule.Types.push_back((yyvsp[0].PrimType));
     }
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 180:
-#line 1903 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { /* "Externally Visible" Linkage */
-    if (yyvsp[0].ConstVal == 0) 
+  case 186:
+#line 1911 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { 
+    /* "Externally Visible" Linkage */
+    if ((yyvsp[0].ConstVal) == 0) 
       GEN_ERROR("Global value initializer is not a constant!");
-    CurGV = ParseGlobalVariable(yyvsp[-3].StrVal, GlobalValue::ExternalLinkage,
-                                yyvsp[-2].Visibility, yyvsp[-1].BoolVal, yyvsp[0].ConstVal->getType(), yyvsp[0].ConstVal);
+    CurGV = ParseGlobalVariable((yyvsp[-3].StrVal), GlobalValue::ExternalLinkage,
+                                (yyvsp[-2].Visibility), (yyvsp[-1].BoolVal), (yyvsp[0].ConstVal)->getType(), (yyvsp[0].ConstVal));
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 181:
-#line 1909 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 187:
+#line 1918 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
     CurGV = 0;
-  }
+  ;}
     break;
 
-  case 182:
-#line 1912 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 188:
+#line 1921 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    if (yyvsp[0].ConstVal == 0) 
+    if ((yyvsp[0].ConstVal) == 0) 
       GEN_ERROR("Global value initializer is not a constant!");
-    CurGV = ParseGlobalVariable(yyvsp[-4].StrVal, yyvsp[-3].Linkage, yyvsp[-2].Visibility, yyvsp[-1].BoolVal, yyvsp[0].ConstVal->getType(), yyvsp[0].ConstVal);
+    CurGV = ParseGlobalVariable((yyvsp[-4].StrVal), (yyvsp[-3].Linkage), (yyvsp[-2].Visibility), (yyvsp[-1].BoolVal), (yyvsp[0].ConstVal)->getType(), (yyvsp[0].ConstVal));
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 183:
-#line 1917 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 189:
+#line 1926 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
     CurGV = 0;
-  }
+  ;}
     break;
 
-  case 184:
-#line 1920 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 190:
+#line 1929 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[0].TypeVal)->getDescription());
-    CurGV = ParseGlobalVariable(yyvsp[-4].StrVal, yyvsp[-3].Linkage, yyvsp[-2].Visibility, yyvsp[-1].BoolVal, *yyvsp[0].TypeVal, 0);
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[0].TypeVal))->getDescription());
+    CurGV = ParseGlobalVariable((yyvsp[-4].StrVal), (yyvsp[-3].Linkage), (yyvsp[-2].Visibility), (yyvsp[-1].BoolVal), *(yyvsp[0].TypeVal), 0);
     CHECK_FOR_ERROR
-    delete yyvsp[0].TypeVal;
-  }
+    delete (yyvsp[0].TypeVal);
+  ;}
     break;
 
-  case 185:
-#line 1926 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 191:
+#line 1935 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
     CurGV = 0;
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 186:
-#line 1930 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 192:
+#line 1939 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     { 
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 187:
-#line 1933 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 193:
+#line 1942 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 188:
-#line 1939 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 194:
+#line 1948 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
   const std::string &AsmSoFar = CurModule.CurrentModule->getModuleInlineAsm();
-  char *EndStr = UnEscapeLexed(yyvsp[0].StrVal, true);
-  std::string NewAsm(yyvsp[0].StrVal, EndStr);
-  free(yyvsp[0].StrVal);
+  char *EndStr = UnEscapeLexed((yyvsp[0].StrVal), true);
+  std::string NewAsm((yyvsp[0].StrVal), EndStr);
+  free((yyvsp[0].StrVal));
 
   if (AsmSoFar.empty())
     CurModule.CurrentModule->setModuleInlineAsm(NewAsm);
   else
     CurModule.CurrentModule->setModuleInlineAsm(AsmSoFar+"\n"+NewAsm);
   CHECK_FOR_ERROR
-}
-    break;
-
-  case 189:
-#line 1952 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.Endianness = Module::BigEndian; }
-    break;
-
-  case 190:
-#line 1953 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.Endianness = Module::LittleEndian; }
-    break;
-
-  case 191:
-#line 1955 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    {
-    CurModule.CurrentModule->setEndianness(yyvsp[0].Endianness);
-    CHECK_FOR_ERROR
-  }
+;}
     break;
 
-  case 192:
-#line 1959 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 195:
+#line 1961 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    if (yyvsp[0].UInt64Val == 32)
-      CurModule.CurrentModule->setPointerSize(Module::Pointer32);
-    else if (yyvsp[0].UInt64Val == 64)
-      CurModule.CurrentModule->setPointerSize(Module::Pointer64);
-    else
-      GEN_ERROR("Invalid pointer size: '" + utostr(yyvsp[0].UInt64Val) + "'!");
-    CHECK_FOR_ERROR
-  }
+    CurModule.CurrentModule->setTargetTriple((yyvsp[0].StrVal));
+    free((yyvsp[0].StrVal));
+  ;}
     break;
 
-  case 193:
-#line 1968 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 196:
+#line 1965 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    CurModule.CurrentModule->setTargetTriple(yyvsp[0].StrVal);
-    free(yyvsp[0].StrVal);
-  }
+    CurModule.CurrentModule->setDataLayout((yyvsp[0].StrVal));
+    free((yyvsp[0].StrVal));
+  ;}
     break;
 
-  case 194:
-#line 1972 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    {
-    CurModule.CurrentModule->setDataLayout(yyvsp[0].StrVal);
-    free(yyvsp[0].StrVal);
-  }
-    break;
-
-  case 196:
-#line 1979 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 198:
+#line 1972 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-          CurModule.CurrentModule->addLibrary(yyvsp[0].StrVal);
-          free(yyvsp[0].StrVal);
+          CurModule.CurrentModule->addLibrary((yyvsp[0].StrVal));
+          free((yyvsp[0].StrVal));
           CHECK_FOR_ERROR
-        }
+        ;}
     break;
 
-  case 197:
-#line 1984 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 199:
+#line 1977 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-          CurModule.CurrentModule->addLibrary(yyvsp[0].StrVal);
-          free(yyvsp[0].StrVal);
+          CurModule.CurrentModule->addLibrary((yyvsp[0].StrVal));
+          free((yyvsp[0].StrVal));
           CHECK_FOR_ERROR
-        }
+        ;}
     break;
 
-  case 198:
-#line 1989 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 200:
+#line 1982 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
           CHECK_FOR_ERROR
-        }
+        ;}
     break;
 
-  case 202:
-#line 1999 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.StrVal = 0; }
-    break;
-
-  case 203:
-#line 2001 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 201:
+#line 1991 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription());
-    if (*yyvsp[-2].TypeVal == Type::VoidTy)
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-2].TypeVal))->getDescription());
+    if (*(yyvsp[-2].TypeVal) == Type::VoidTy)
       GEN_ERROR("void typed arguments are invalid!");
-    ArgListEntry E; E.Attrs = yyvsp[-1].ParamAttrs; E.Ty = yyvsp[-2].TypeVal; E.Name = yyvsp[0].StrVal;
-    yyval.ArgList = yyvsp[-4].ArgList;
-    yyvsp[-4].ArgList->push_back(E);
+    ArgListEntry E; E.Attrs = (yyvsp[-1].ParamAttrs); E.Ty = (yyvsp[-2].TypeVal); E.Name = (yyvsp[0].StrVal);
+    (yyval.ArgList) = (yyvsp[-4].ArgList);
+    (yyvsp[-4].ArgList)->push_back(E);
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 204:
-#line 2011 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 202:
+#line 2001 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription());
-    if (*yyvsp[-2].TypeVal == Type::VoidTy)
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-2].TypeVal))->getDescription());
+    if (*(yyvsp[-2].TypeVal) == Type::VoidTy)
       GEN_ERROR("void typed arguments are invalid!");
-    ArgListEntry E; E.Attrs = yyvsp[-1].ParamAttrs; E.Ty = yyvsp[-2].TypeVal; E.Name = yyvsp[0].StrVal;
-    yyval.ArgList = new ArgListType;
-    yyval.ArgList->push_back(E);
+    ArgListEntry E; E.Attrs = (yyvsp[-1].ParamAttrs); E.Ty = (yyvsp[-2].TypeVal); E.Name = (yyvsp[0].StrVal);
+    (yyval.ArgList) = new ArgListType;
+    (yyval.ArgList)->push_back(E);
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 205:
-#line 2022 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 203:
+#line 2012 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    yyval.ArgList = yyvsp[0].ArgList;
+    (yyval.ArgList) = (yyvsp[0].ArgList);
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 206:
-#line 2026 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 204:
+#line 2016 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    yyval.ArgList = yyvsp[-2].ArgList;
+    (yyval.ArgList) = (yyvsp[-2].ArgList);
     struct ArgListEntry E;
     E.Ty = new PATypeHolder(Type::VoidTy);
     E.Name = 0;
     E.Attrs = FunctionType::NoAttributeSet;
-    yyval.ArgList->push_back(E);
+    (yyval.ArgList)->push_back(E);
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 207:
-#line 2035 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 205:
+#line 2025 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    yyval.ArgList = new ArgListType;
+    (yyval.ArgList) = new ArgListType;
     struct ArgListEntry E;
     E.Ty = new PATypeHolder(Type::VoidTy);
     E.Name = 0;
     E.Attrs = FunctionType::NoAttributeSet;
-    yyval.ArgList->push_back(E);
+    (yyval.ArgList)->push_back(E);
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 208:
-#line 2044 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 206:
+#line 2034 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    yyval.ArgList = 0;
+    (yyval.ArgList) = 0;
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 209:
-#line 2050 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 207:
+#line 2040 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-  UnEscapeLexed(yyvsp[-6].StrVal);
-  std::string FunctionName(yyvsp[-6].StrVal);
-  free(yyvsp[-6].StrVal);  // Free strdup'd memory!
+  UnEscapeLexed((yyvsp[-6].StrVal));
+  std::string FunctionName((yyvsp[-6].StrVal));
+  free((yyvsp[-6].StrVal));  // Free strdup'd memory!
   
   // Check the function result for abstractness if this is a define. We should
   // have no abstract types at this point
-  if (!CurFun.isDeclare && CurModule.TypeIsUnresolved(yyvsp[-7].TypeVal))
-    GEN_ERROR("Reference to abstract result: "+ yyvsp[-7].TypeVal->get()->getDescription());
+  if (!CurFun.isDeclare && CurModule.TypeIsUnresolved((yyvsp[-7].TypeVal)))
+    GEN_ERROR("Reference to abstract result: "+ (yyvsp[-7].TypeVal)->get()->getDescription());
 
   std::vector ParamTypeList;
   std::vector ParamAttrs;
-  ParamAttrs.push_back(yyvsp[-2].ParamAttrs);
-  if (yyvsp[-4].ArgList) {   // If there are arguments...
-    for (ArgListType::iterator I = yyvsp[-4].ArgList->begin(); I != yyvsp[-4].ArgList->end(); ++I) {
+  ParamAttrs.push_back((yyvsp[-2].ParamAttrs));
+  if ((yyvsp[-4].ArgList)) {   // If there are arguments...
+    for (ArgListType::iterator I = (yyvsp[-4].ArgList)->begin(); I != (yyvsp[-4].ArgList)->end(); ++I) {
       const Type* Ty = I->Ty->get();
       if (!CurFun.isDeclare && CurModule.TypeIsUnresolved(I->Ty))
         GEN_ERROR("Reference to abstract argument: " + Ty->getDescription());
@@ -4379,16 +4554,16 @@
   bool isVarArg = ParamTypeList.size() && ParamTypeList.back() == Type::VoidTy;
   if (isVarArg) ParamTypeList.pop_back();
 
-  FunctionType *FT = FunctionType::get(*yyvsp[-7].TypeVal, ParamTypeList, isVarArg,
+  FunctionType *FT = FunctionType::get(*(yyvsp[-7].TypeVal), ParamTypeList, isVarArg,
                                        ParamAttrs);
   const PointerType *PFT = PointerType::get(FT);
-  delete yyvsp[-7].TypeVal;
+  delete (yyvsp[-7].TypeVal);
 
   ValID ID;
   if (!FunctionName.empty()) {
-    ID = ValID::create((char*)FunctionName.c_str());
+    ID = ValID::createGlobalName((char*)FunctionName.c_str());
   } else {
-    ID = ValID::create((int)CurModule.Values[PFT].size());
+    ID = ValID::createGlobalID(CurModule.Values[PFT].size());
   }
 
   Function *Fn = 0;
@@ -4427,24 +4602,24 @@
     Fn->setLinkage(CurFun.Linkage);
     Fn->setVisibility(CurFun.Visibility);
   }
-  Fn->setCallingConv(yyvsp[-8].UIntVal);
-  Fn->setAlignment(yyvsp[0].UIntVal);
-  if (yyvsp[-1].StrVal) {
-    Fn->setSection(yyvsp[-1].StrVal);
-    free(yyvsp[-1].StrVal);
+  Fn->setCallingConv((yyvsp[-8].UIntVal));
+  Fn->setAlignment((yyvsp[0].UIntVal));
+  if ((yyvsp[-1].StrVal)) {
+    Fn->setSection((yyvsp[-1].StrVal));
+    free((yyvsp[-1].StrVal));
   }
 
   // Add all of the arguments we parsed to the function...
-  if (yyvsp[-4].ArgList) {                     // Is null if empty...
+  if ((yyvsp[-4].ArgList)) {                     // Is null if empty...
     if (isVarArg) {  // Nuke the last entry
-      assert(yyvsp[-4].ArgList->back().Ty->get() == Type::VoidTy && yyvsp[-4].ArgList->back().Name == 0&&
+      assert((yyvsp[-4].ArgList)->back().Ty->get() == Type::VoidTy && (yyvsp[-4].ArgList)->back().Name == 0&&
              "Not a varargs marker!");
-      delete yyvsp[-4].ArgList->back().Ty;
-      yyvsp[-4].ArgList->pop_back();  // Delete the last entry
+      delete (yyvsp[-4].ArgList)->back().Ty;
+      (yyvsp[-4].ArgList)->pop_back();  // Delete the last entry
     }
     Function::arg_iterator ArgIt = Fn->arg_begin();
     unsigned Idx = 1;
-    for (ArgListType::iterator I = yyvsp[-4].ArgList->begin(); I != yyvsp[-4].ArgList->end(); ++I, ++ArgIt) {
+    for (ArgListType::iterator I = (yyvsp[-4].ArgList)->begin(); I != (yyvsp[-4].ArgList)->end(); ++I, ++ArgIt) {
       delete I->Ty;                          // Delete the typeholder...
       setValueName(ArgIt, I->Name);           // Insert arg into symtab...
       CHECK_FOR_ERROR
@@ -4452,128 +4627,128 @@
       Idx++;
     }
 
-    delete yyvsp[-4].ArgList;                     // We're now done with the argument list
+    delete (yyvsp[-4].ArgList);                     // We're now done with the argument list
   }
   CHECK_FOR_ERROR
-}
+;}
     break;
 
-  case 212:
-#line 2157 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 210:
+#line 2147 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-  yyval.FunctionVal = CurFun.CurrentFunction;
+  (yyval.FunctionVal) = CurFun.CurrentFunction;
 
   // Make sure that we keep track of the linkage type even if there was a
   // previous "declare".
-  yyval.FunctionVal->setLinkage(yyvsp[-3].Linkage);
-  yyval.FunctionVal->setVisibility(yyvsp[-2].Visibility);
-}
+  (yyval.FunctionVal)->setLinkage((yyvsp[-3].Linkage));
+  (yyval.FunctionVal)->setVisibility((yyvsp[-2].Visibility));
+;}
     break;
 
-  case 215:
-#line 2168 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 213:
+#line 2158 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-  yyval.FunctionVal = yyvsp[-1].FunctionVal;
+  (yyval.FunctionVal) = (yyvsp[-1].FunctionVal);
   CHECK_FOR_ERROR
-}
+;}
     break;
 
-  case 216:
-#line 2173 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 214:
+#line 2163 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    CurFun.CurrentFunction->setLinkage(yyvsp[-2].Linkage);
-    CurFun.CurrentFunction->setVisibility(yyvsp[-1].Visibility);
-    yyval.FunctionVal = CurFun.CurrentFunction;
+    CurFun.CurrentFunction->setLinkage((yyvsp[-2].Linkage));
+    CurFun.CurrentFunction->setVisibility((yyvsp[-1].Visibility));
+    (yyval.FunctionVal) = CurFun.CurrentFunction;
     CurFun.FunctionDone();
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 217:
-#line 2185 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 215:
+#line 2175 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    yyval.BoolVal = false;
+    (yyval.BoolVal) = false;
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 218:
-#line 2189 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 216:
+#line 2179 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    yyval.BoolVal = true;
+    (yyval.BoolVal) = true;
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 219:
-#line 2194 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 217:
+#line 2184 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {    // A reference to a direct constant
-    yyval.ValIDVal = ValID::create(yyvsp[0].SInt64Val);
+    (yyval.ValIDVal) = ValID::create((yyvsp[0].SInt64Val));
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 220:
-#line 2198 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 218:
+#line 2188 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    yyval.ValIDVal = ValID::create(yyvsp[0].UInt64Val);
+    (yyval.ValIDVal) = ValID::create((yyvsp[0].UInt64Val));
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 221:
-#line 2202 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 219:
+#line 2192 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {                     // Perhaps it's an FP constant?
-    yyval.ValIDVal = ValID::create(yyvsp[0].FPVal);
+    (yyval.ValIDVal) = ValID::create((yyvsp[0].FPVal));
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 222:
-#line 2206 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 220:
+#line 2196 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    yyval.ValIDVal = ValID::create(ConstantInt::getTrue());
+    (yyval.ValIDVal) = ValID::create(ConstantInt::getTrue());
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 223:
-#line 2210 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 221:
+#line 2200 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    yyval.ValIDVal = ValID::create(ConstantInt::getFalse());
+    (yyval.ValIDVal) = ValID::create(ConstantInt::getFalse());
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 224:
-#line 2214 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 222:
+#line 2204 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    yyval.ValIDVal = ValID::createNull();
+    (yyval.ValIDVal) = ValID::createNull();
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 225:
-#line 2218 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 223:
+#line 2208 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    yyval.ValIDVal = ValID::createUndef();
+    (yyval.ValIDVal) = ValID::createUndef();
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 226:
-#line 2222 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 224:
+#line 2212 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {     // A vector zero constant.
-    yyval.ValIDVal = ValID::createZeroInit();
+    (yyval.ValIDVal) = ValID::createZeroInit();
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 227:
-#line 2226 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 225:
+#line 2216 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     { // Nonempty unsized packed vector
-    const Type *ETy = (*yyvsp[-1].ConstVector)[0]->getType();
-    int NumElements = yyvsp[-1].ConstVector->size(); 
+    const Type *ETy = (*(yyvsp[-1].ConstVector))[0]->getType();
+    int NumElements = (yyvsp[-1].ConstVector)->size(); 
     
     PackedType* pt = PackedType::get(ETy, NumElements);
     PATypeHolder* PTy = new PATypeHolder(
@@ -4585,115 +4760,131 @@
                                          );
     
     // Verify all elements are correct type!
-    for (unsigned i = 0; i < yyvsp[-1].ConstVector->size(); i++) {
-      if (ETy != (*yyvsp[-1].ConstVector)[i]->getType())
+    for (unsigned i = 0; i < (yyvsp[-1].ConstVector)->size(); i++) {
+      if (ETy != (*(yyvsp[-1].ConstVector))[i]->getType())
         GEN_ERROR("Element #" + utostr(i) + " is not of type '" + 
                      ETy->getDescription() +"' as required!\nIt is of type '" +
-                     (*yyvsp[-1].ConstVector)[i]->getType()->getDescription() + "'.");
+                     (*(yyvsp[-1].ConstVector))[i]->getType()->getDescription() + "'.");
     }
 
-    yyval.ValIDVal = ValID::create(ConstantPacked::get(pt, *yyvsp[-1].ConstVector));
-    delete PTy; delete yyvsp[-1].ConstVector;
+    (yyval.ValIDVal) = ValID::create(ConstantPacked::get(pt, *(yyvsp[-1].ConstVector)));
+    delete PTy; delete (yyvsp[-1].ConstVector);
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
-  case 228:
-#line 2251 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+  case 226:
+#line 2241 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    yyval.ValIDVal = ValID::create(yyvsp[0].ConstVal);
+    (yyval.ValIDVal) = ValID::create((yyvsp[0].ConstVal));
     CHECK_FOR_ERROR
-  }
+  ;}
+    break;
+
+  case 227:
+#line 2245 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    {
+    char *End = UnEscapeLexed((yyvsp[-2].StrVal), true);
+    std::string AsmStr = std::string((yyvsp[-2].StrVal), End);
+    End = UnEscapeLexed((yyvsp[0].StrVal), true);
+    std::string Constraints = std::string((yyvsp[0].StrVal), End);
+    (yyval.ValIDVal) = ValID::createInlineAsm(AsmStr, Constraints, (yyvsp[-3].BoolVal));
+    free((yyvsp[-2].StrVal));
+    free((yyvsp[0].StrVal));
+    CHECK_FOR_ERROR
+  ;}
+    break;
+
+  case 228:
+#line 2259 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    {  // Is it an integer reference...?
+    (yyval.ValIDVal) = ValID::createLocalID((yyvsp[0].UIntVal));
+    CHECK_FOR_ERROR
+  ;}
     break;
 
   case 229:
-#line 2255 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2263 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    char *End = UnEscapeLexed(yyvsp[-2].StrVal, true);
-    std::string AsmStr = std::string(yyvsp[-2].StrVal, End);
-    End = UnEscapeLexed(yyvsp[0].StrVal, true);
-    std::string Constraints = std::string(yyvsp[0].StrVal, End);
-    yyval.ValIDVal = ValID::createInlineAsm(AsmStr, Constraints, yyvsp[-3].BoolVal);
-    free(yyvsp[-2].StrVal);
-    free(yyvsp[0].StrVal);
+    (yyval.ValIDVal) = ValID::createGlobalID((yyvsp[0].UIntVal));
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
   case 230:
-#line 2269 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    {  // Is it an integer reference...?
-    yyval.ValIDVal = ValID::create(yyvsp[0].SIntVal);
+#line 2267 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    {                   // Is it a named reference...?
+    (yyval.ValIDVal) = ValID::createLocalName((yyvsp[0].StrVal));
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
   case 231:
-#line 2273 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2271 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {                   // Is it a named reference...?
-    yyval.ValIDVal = ValID::create(yyvsp[0].StrVal);
+    (yyval.ValIDVal) = ValID::createGlobalName((yyvsp[0].StrVal));
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
   case 234:
-#line 2285 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2283 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
-    yyval.ValueVal = getVal(*yyvsp[-1].TypeVal, yyvsp[0].ValIDVal); 
-    delete yyvsp[-1].TypeVal;
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-1].TypeVal))->getDescription());
+    (yyval.ValueVal) = getVal(*(yyvsp[-1].TypeVal), (yyvsp[0].ValIDVal)); 
+    delete (yyvsp[-1].TypeVal);
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
   case 235:
-#line 2294 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2292 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    yyval.FunctionVal = yyvsp[-1].FunctionVal;
+    (yyval.FunctionVal) = (yyvsp[-1].FunctionVal);
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
   case 236:
-#line 2298 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2296 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     { // Do not allow functions with 0 basic blocks   
-    yyval.FunctionVal = yyvsp[-1].FunctionVal;
+    (yyval.FunctionVal) = (yyvsp[-1].FunctionVal);
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
   case 237:
-#line 2307 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2305 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    setValueName(yyvsp[0].TermInstVal, yyvsp[-1].StrVal);
+    setValueName((yyvsp[0].TermInstVal), (yyvsp[-1].StrVal));
     CHECK_FOR_ERROR
-    InsertValue(yyvsp[0].TermInstVal);
+    InsertValue((yyvsp[0].TermInstVal));
 
-    yyvsp[-2].BasicBlockVal->getInstList().push_back(yyvsp[0].TermInstVal);
-    InsertValue(yyvsp[-2].BasicBlockVal);
-    yyval.BasicBlockVal = yyvsp[-2].BasicBlockVal;
+    (yyvsp[-2].BasicBlockVal)->getInstList().push_back((yyvsp[0].TermInstVal));
+    InsertValue((yyvsp[-2].BasicBlockVal));
+    (yyval.BasicBlockVal) = (yyvsp[-2].BasicBlockVal);
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
   case 238:
-#line 2318 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2316 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    if (CastInst *CI1 = dyn_cast(yyvsp[0].InstVal))
+    if (CastInst *CI1 = dyn_cast((yyvsp[0].InstVal)))
       if (CastInst *CI2 = dyn_cast(CI1->getOperand(0)))
         if (CI2->getParent() == 0)
-          yyvsp[-1].BasicBlockVal->getInstList().push_back(CI2);
-    yyvsp[-1].BasicBlockVal->getInstList().push_back(yyvsp[0].InstVal);
-    yyval.BasicBlockVal = yyvsp[-1].BasicBlockVal;
+          (yyvsp[-1].BasicBlockVal)->getInstList().push_back(CI2);
+    (yyvsp[-1].BasicBlockVal)->getInstList().push_back((yyvsp[0].InstVal));
+    (yyval.BasicBlockVal) = (yyvsp[-1].BasicBlockVal);
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
   case 239:
-#line 2327 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2325 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    yyval.BasicBlockVal = getBBVal(ValID::create((int)CurFun.NextBBNum++), true);
+    (yyval.BasicBlockVal) = getBBVal(ValID::createLocalID(CurFun.NextBBNum++), true);
     CHECK_FOR_ERROR
 
     // Make sure to move the basic block to the correct location in the
@@ -4701,15 +4892,15 @@
     // referenced.
     Function::BasicBlockListType &BBL = 
       CurFun.CurrentFunction->getBasicBlockList();
-    BBL.splice(BBL.end(), BBL, yyval.BasicBlockVal);
+    BBL.splice(BBL.end(), BBL, (yyval.BasicBlockVal));
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
   case 240:
-#line 2339 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2337 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    yyval.BasicBlockVal = getBBVal(ValID::create(yyvsp[0].StrVal), true);
+    (yyval.BasicBlockVal) = getBBVal(ValID::createLocalName((yyvsp[0].StrVal)), true);
     CHECK_FOR_ERROR
 
     // Make sure to move the basic block to the correct location in the
@@ -4717,100 +4908,100 @@
     // referenced.
     Function::BasicBlockListType &BBL = 
       CurFun.CurrentFunction->getBasicBlockList();
-    BBL.splice(BBL.end(), BBL, yyval.BasicBlockVal);
+    BBL.splice(BBL.end(), BBL, (yyval.BasicBlockVal));
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
   case 241:
-#line 2352 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2350 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {              // Return with a result...
-    yyval.TermInstVal = new ReturnInst(yyvsp[0].ValueVal);
+    (yyval.TermInstVal) = new ReturnInst((yyvsp[0].ValueVal));
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
   case 242:
-#line 2356 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2354 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {                                       // Return with no result...
-    yyval.TermInstVal = new ReturnInst();
+    (yyval.TermInstVal) = new ReturnInst();
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
   case 243:
-#line 2360 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2358 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {                         // Unconditional Branch...
-    BasicBlock* tmpBB = getBBVal(yyvsp[0].ValIDVal);
+    BasicBlock* tmpBB = getBBVal((yyvsp[0].ValIDVal));
     CHECK_FOR_ERROR
-    yyval.TermInstVal = new BranchInst(tmpBB);
-  }
+    (yyval.TermInstVal) = new BranchInst(tmpBB);
+  ;}
     break;
 
   case 244:
-#line 2365 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2363 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {  
-    assert(cast(yyvsp[-7].PrimType)->getBitWidth() == 1 && "Not Bool?");
-    BasicBlock* tmpBBA = getBBVal(yyvsp[-3].ValIDVal);
+    assert(cast((yyvsp[-7].PrimType))->getBitWidth() == 1 && "Not Bool?");
+    BasicBlock* tmpBBA = getBBVal((yyvsp[-3].ValIDVal));
     CHECK_FOR_ERROR
-    BasicBlock* tmpBBB = getBBVal(yyvsp[0].ValIDVal);
+    BasicBlock* tmpBBB = getBBVal((yyvsp[0].ValIDVal));
     CHECK_FOR_ERROR
-    Value* tmpVal = getVal(Type::Int1Ty, yyvsp[-6].ValIDVal);
+    Value* tmpVal = getVal(Type::Int1Ty, (yyvsp[-6].ValIDVal));
     CHECK_FOR_ERROR
-    yyval.TermInstVal = new BranchInst(tmpBBA, tmpBBB, tmpVal);
-  }
+    (yyval.TermInstVal) = new BranchInst(tmpBBA, tmpBBB, tmpVal);
+  ;}
     break;
 
   case 245:
-#line 2375 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2373 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    Value* tmpVal = getVal(yyvsp[-7].PrimType, yyvsp[-6].ValIDVal);
+    Value* tmpVal = getVal((yyvsp[-7].PrimType), (yyvsp[-6].ValIDVal));
     CHECK_FOR_ERROR
-    BasicBlock* tmpBB = getBBVal(yyvsp[-3].ValIDVal);
+    BasicBlock* tmpBB = getBBVal((yyvsp[-3].ValIDVal));
     CHECK_FOR_ERROR
-    SwitchInst *S = new SwitchInst(tmpVal, tmpBB, yyvsp[-1].JumpTable->size());
-    yyval.TermInstVal = S;
+    SwitchInst *S = new SwitchInst(tmpVal, tmpBB, (yyvsp[-1].JumpTable)->size());
+    (yyval.TermInstVal) = S;
 
-    std::vector >::iterator I = yyvsp[-1].JumpTable->begin(),
-      E = yyvsp[-1].JumpTable->end();
+    std::vector >::iterator I = (yyvsp[-1].JumpTable)->begin(),
+      E = (yyvsp[-1].JumpTable)->end();
     for (; I != E; ++I) {
       if (ConstantInt *CI = dyn_cast(I->first))
           S->addCase(CI, I->second);
       else
         GEN_ERROR("Switch case is constant, but not a simple integer!");
     }
-    delete yyvsp[-1].JumpTable;
+    delete (yyvsp[-1].JumpTable);
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
   case 246:
-#line 2394 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2392 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    Value* tmpVal = getVal(yyvsp[-6].PrimType, yyvsp[-5].ValIDVal);
+    Value* tmpVal = getVal((yyvsp[-6].PrimType), (yyvsp[-5].ValIDVal));
     CHECK_FOR_ERROR
-    BasicBlock* tmpBB = getBBVal(yyvsp[-2].ValIDVal);
+    BasicBlock* tmpBB = getBBVal((yyvsp[-2].ValIDVal));
     CHECK_FOR_ERROR
     SwitchInst *S = new SwitchInst(tmpVal, tmpBB, 0);
-    yyval.TermInstVal = S;
+    (yyval.TermInstVal) = S;
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
   case 247:
-#line 2404 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2402 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
 
     // Handle the short syntax
     const PointerType *PFTy = 0;
     const FunctionType *Ty = 0;
-    if (!(PFTy = dyn_cast(yyvsp[-11].TypeVal->get())) ||
+    if (!(PFTy = dyn_cast((yyvsp[-11].TypeVal)->get())) ||
         !(Ty = dyn_cast(PFTy->getElementType()))) {
       // Pull out the types of all of the arguments...
       std::vector ParamTypes;
       FunctionType::ParamAttrsList ParamAttrs;
-      ParamAttrs.push_back(yyvsp[-6].ParamAttrs);
-      for (ValueRefList::iterator I = yyvsp[-8].ValueRefList->begin(), E = yyvsp[-8].ValueRefList->end(); I != E; ++I) {
+      ParamAttrs.push_back((yyvsp[-6].ParamAttrs));
+      for (ValueRefList::iterator I = (yyvsp[-8].ValueRefList)->begin(), E = (yyvsp[-8].ValueRefList)->end(); I != E; ++I) {
         const Type *Ty = I->Val->getType();
         if (Ty == Type::VoidTy)
           GEN_ERROR("Short call syntax cannot be used with varargs");
@@ -4818,20 +5009,20 @@
         ParamAttrs.push_back(I->Attrs);
       }
 
-      Ty = FunctionType::get(yyvsp[-11].TypeVal->get(), ParamTypes, false, ParamAttrs);
+      Ty = FunctionType::get((yyvsp[-11].TypeVal)->get(), ParamTypes, false, ParamAttrs);
       PFTy = PointerType::get(Ty);
     }
 
-    Value *V = getVal(PFTy, yyvsp[-10].ValIDVal);   // Get the function we're calling...
+    Value *V = getVal(PFTy, (yyvsp[-10].ValIDVal));   // Get the function we're calling...
     CHECK_FOR_ERROR
-    BasicBlock *Normal = getBBVal(yyvsp[-3].ValIDVal);
+    BasicBlock *Normal = getBBVal((yyvsp[-3].ValIDVal));
     CHECK_FOR_ERROR
-    BasicBlock *Except = getBBVal(yyvsp[0].ValIDVal);
+    BasicBlock *Except = getBBVal((yyvsp[0].ValIDVal));
     CHECK_FOR_ERROR
 
     // Check the arguments
     ValueList Args;
-    if (yyvsp[-8].ValueRefList->empty()) {                                   // Has no arguments?
+    if ((yyvsp[-8].ValueRefList)->empty()) {                                   // Has no arguments?
       // Make sure no arguments is a good thing!
       if (Ty->getNumParams() != 0)
         GEN_ERROR("No arguments passed to a function that "
@@ -4841,7 +5032,7 @@
       // correctly!
       FunctionType::param_iterator I = Ty->param_begin();
       FunctionType::param_iterator E = Ty->param_end();
-      ValueRefList::iterator ArgI = yyvsp[-8].ValueRefList->begin(), ArgE = yyvsp[-8].ValueRefList->end();
+      ValueRefList::iterator ArgI = (yyvsp[-8].ValueRefList)->begin(), ArgE = (yyvsp[-8].ValueRefList)->end();
 
       for (; ArgI != ArgE && I != E; ++ArgI, ++I) {
         if (ArgI->Val->getType() != *I)
@@ -4860,353 +5051,353 @@
 
     // Create the InvokeInst
     InvokeInst *II = new InvokeInst(V, Normal, Except, Args);
-    II->setCallingConv(yyvsp[-12].UIntVal);
-    yyval.TermInstVal = II;
-    delete yyvsp[-8].ValueRefList;
+    II->setCallingConv((yyvsp[-12].UIntVal));
+    (yyval.TermInstVal) = II;
+    delete (yyvsp[-8].ValueRefList);
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
   case 248:
-#line 2470 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2468 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    yyval.TermInstVal = new UnwindInst();
+    (yyval.TermInstVal) = new UnwindInst();
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
   case 249:
-#line 2474 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2472 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    yyval.TermInstVal = new UnreachableInst();
+    (yyval.TermInstVal) = new UnreachableInst();
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
   case 250:
-#line 2481 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2479 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    yyval.JumpTable = yyvsp[-5].JumpTable;
-    Constant *V = cast(getValNonImprovising(yyvsp[-4].PrimType, yyvsp[-3].ValIDVal));
+    (yyval.JumpTable) = (yyvsp[-5].JumpTable);
+    Constant *V = cast(getValNonImprovising((yyvsp[-4].PrimType), (yyvsp[-3].ValIDVal)));
     CHECK_FOR_ERROR
     if (V == 0)
       GEN_ERROR("May only switch on a constant pool value!");
 
-    BasicBlock* tmpBB = getBBVal(yyvsp[0].ValIDVal);
+    BasicBlock* tmpBB = getBBVal((yyvsp[0].ValIDVal));
     CHECK_FOR_ERROR
-    yyval.JumpTable->push_back(std::make_pair(V, tmpBB));
-  }
+    (yyval.JumpTable)->push_back(std::make_pair(V, tmpBB));
+  ;}
     break;
 
   case 251:
-#line 2492 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2490 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    yyval.JumpTable = new std::vector >();
-    Constant *V = cast(getValNonImprovising(yyvsp[-4].PrimType, yyvsp[-3].ValIDVal));
+    (yyval.JumpTable) = new std::vector >();
+    Constant *V = cast(getValNonImprovising((yyvsp[-4].PrimType), (yyvsp[-3].ValIDVal)));
     CHECK_FOR_ERROR
 
     if (V == 0)
       GEN_ERROR("May only switch on a constant pool value!");
 
-    BasicBlock* tmpBB = getBBVal(yyvsp[0].ValIDVal);
+    BasicBlock* tmpBB = getBBVal((yyvsp[0].ValIDVal));
     CHECK_FOR_ERROR
-    yyval.JumpTable->push_back(std::make_pair(V, tmpBB)); 
-  }
+    (yyval.JumpTable)->push_back(std::make_pair(V, tmpBB)); 
+  ;}
     break;
 
   case 252:
-#line 2505 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2503 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
   // Is this definition named?? if so, assign the name...
-  setValueName(yyvsp[0].InstVal, yyvsp[-1].StrVal);
+  setValueName((yyvsp[0].InstVal), (yyvsp[-1].StrVal));
   CHECK_FOR_ERROR
-  InsertValue(yyvsp[0].InstVal);
-  yyval.InstVal = yyvsp[0].InstVal;
+  InsertValue((yyvsp[0].InstVal));
+  (yyval.InstVal) = (yyvsp[0].InstVal);
   CHECK_FOR_ERROR
-}
+;}
     break;
 
   case 253:
-#line 2514 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2512 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {    // Used for PHI nodes
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-5].TypeVal)->getDescription());
-    yyval.PHIList = new std::list >();
-    Value* tmpVal = getVal(*yyvsp[-5].TypeVal, yyvsp[-3].ValIDVal);
-    CHECK_FOR_ERROR
-    BasicBlock* tmpBB = getBBVal(yyvsp[-1].ValIDVal);
-    CHECK_FOR_ERROR
-    yyval.PHIList->push_back(std::make_pair(tmpVal, tmpBB));
-    delete yyvsp[-5].TypeVal;
-  }
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-5].TypeVal))->getDescription());
+    (yyval.PHIList) = new std::list >();
+    Value* tmpVal = getVal(*(yyvsp[-5].TypeVal), (yyvsp[-3].ValIDVal));
+    CHECK_FOR_ERROR
+    BasicBlock* tmpBB = getBBVal((yyvsp[-1].ValIDVal));
+    CHECK_FOR_ERROR
+    (yyval.PHIList)->push_back(std::make_pair(tmpVal, tmpBB));
+    delete (yyvsp[-5].TypeVal);
+  ;}
     break;
 
   case 254:
-#line 2525 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2523 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    yyval.PHIList = yyvsp[-6].PHIList;
-    Value* tmpVal = getVal(yyvsp[-6].PHIList->front().first->getType(), yyvsp[-3].ValIDVal);
+    (yyval.PHIList) = (yyvsp[-6].PHIList);
+    Value* tmpVal = getVal((yyvsp[-6].PHIList)->front().first->getType(), (yyvsp[-3].ValIDVal));
     CHECK_FOR_ERROR
-    BasicBlock* tmpBB = getBBVal(yyvsp[-1].ValIDVal);
+    BasicBlock* tmpBB = getBBVal((yyvsp[-1].ValIDVal));
     CHECK_FOR_ERROR
-    yyvsp[-6].PHIList->push_back(std::make_pair(tmpVal, tmpBB));
-  }
+    (yyvsp[-6].PHIList)->push_back(std::make_pair(tmpVal, tmpBB));
+  ;}
     break;
 
   case 255:
-#line 2535 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2533 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {    
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription());
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-2].TypeVal))->getDescription());
     // Used for call and invoke instructions
-    yyval.ValueRefList = new ValueRefList();
-    ValueRefListEntry E; E.Attrs = yyvsp[0].ParamAttrs; E.Val = getVal(yyvsp[-2].TypeVal->get(), yyvsp[-1].ValIDVal);
-    yyval.ValueRefList->push_back(E);
-  }
+    (yyval.ValueRefList) = new ValueRefList();
+    ValueRefListEntry E; E.Attrs = (yyvsp[0].ParamAttrs); E.Val = getVal((yyvsp[-2].TypeVal)->get(), (yyvsp[-1].ValIDVal));
+    (yyval.ValueRefList)->push_back(E);
+  ;}
     break;
 
   case 256:
-#line 2543 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2541 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription());
-    yyval.ValueRefList = yyvsp[-4].ValueRefList;
-    ValueRefListEntry E; E.Attrs = yyvsp[0].ParamAttrs; E.Val = getVal(yyvsp[-2].TypeVal->get(), yyvsp[-1].ValIDVal);
-    yyval.ValueRefList->push_back(E);
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-2].TypeVal))->getDescription());
+    (yyval.ValueRefList) = (yyvsp[-4].ValueRefList);
+    ValueRefListEntry E; E.Attrs = (yyvsp[0].ParamAttrs); E.Val = getVal((yyvsp[-2].TypeVal)->get(), (yyvsp[-1].ValIDVal));
+    (yyval.ValueRefList)->push_back(E);
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
   case 257:
-#line 2551 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.ValueRefList = new ValueRefList(); }
+#line 2549 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.ValueRefList) = new ValueRefList(); ;}
     break;
 
   case 258:
-#line 2554 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-    { yyval.ValueList = new std::vector(); }
+#line 2552 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+    { (yyval.ValueList) = new std::vector(); ;}
     break;
 
   case 259:
-#line 2555 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2553 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    yyval.ValueList = yyvsp[-2].ValueList;
-    yyval.ValueList->push_back(yyvsp[0].ValueVal);
+    (yyval.ValueList) = (yyvsp[-2].ValueList);
+    (yyval.ValueList)->push_back((yyvsp[0].ValueVal));
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
   case 260:
-#line 2562 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2560 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    yyval.BoolVal = true;
+    (yyval.BoolVal) = true;
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
   case 261:
-#line 2566 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2564 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    yyval.BoolVal = false;
+    (yyval.BoolVal) = false;
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
   case 262:
-#line 2571 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2569 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-3].TypeVal)->getDescription());
-    if (!(*yyvsp[-3].TypeVal)->isInteger() && !(*yyvsp[-3].TypeVal)->isFloatingPoint() && 
-        !isa((*yyvsp[-3].TypeVal).get()))
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-3].TypeVal))->getDescription());
+    if (!(*(yyvsp[-3].TypeVal))->isInteger() && !(*(yyvsp[-3].TypeVal))->isFloatingPoint() && 
+        !isa((*(yyvsp[-3].TypeVal)).get()))
       GEN_ERROR(
         "Arithmetic operator requires integer, FP, or packed operands!");
-    if (isa((*yyvsp[-3].TypeVal).get()) && 
-        (yyvsp[-4].BinaryOpVal == Instruction::URem || 
-         yyvsp[-4].BinaryOpVal == Instruction::SRem ||
-         yyvsp[-4].BinaryOpVal == Instruction::FRem))
+    if (isa((*(yyvsp[-3].TypeVal)).get()) && 
+        ((yyvsp[-4].BinaryOpVal) == Instruction::URem || 
+         (yyvsp[-4].BinaryOpVal) == Instruction::SRem ||
+         (yyvsp[-4].BinaryOpVal) == Instruction::FRem))
       GEN_ERROR("U/S/FRem not supported on packed types!");
-    Value* val1 = getVal(*yyvsp[-3].TypeVal, yyvsp[-2].ValIDVal); 
+    Value* val1 = getVal(*(yyvsp[-3].TypeVal), (yyvsp[-2].ValIDVal)); 
     CHECK_FOR_ERROR
-    Value* val2 = getVal(*yyvsp[-3].TypeVal, yyvsp[0].ValIDVal);
+    Value* val2 = getVal(*(yyvsp[-3].TypeVal), (yyvsp[0].ValIDVal));
     CHECK_FOR_ERROR
-    yyval.InstVal = BinaryOperator::create(yyvsp[-4].BinaryOpVal, val1, val2);
-    if (yyval.InstVal == 0)
+    (yyval.InstVal) = BinaryOperator::create((yyvsp[-4].BinaryOpVal), val1, val2);
+    if ((yyval.InstVal) == 0)
       GEN_ERROR("binary operator returned null!");
-    delete yyvsp[-3].TypeVal;
-  }
+    delete (yyvsp[-3].TypeVal);
+  ;}
     break;
 
   case 263:
-#line 2592 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2590 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-3].TypeVal)->getDescription());
-    if (!(*yyvsp[-3].TypeVal)->isInteger()) {
-      if (!isa(yyvsp[-3].TypeVal->get()) ||
-          !cast(yyvsp[-3].TypeVal->get())->getElementType()->isInteger())
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-3].TypeVal))->getDescription());
+    if (!(*(yyvsp[-3].TypeVal))->isInteger()) {
+      if (!isa((yyvsp[-3].TypeVal)->get()) ||
+          !cast((yyvsp[-3].TypeVal)->get())->getElementType()->isInteger())
         GEN_ERROR("Logical operator requires integral operands!");
     }
-    Value* tmpVal1 = getVal(*yyvsp[-3].TypeVal, yyvsp[-2].ValIDVal);
+    Value* tmpVal1 = getVal(*(yyvsp[-3].TypeVal), (yyvsp[-2].ValIDVal));
     CHECK_FOR_ERROR
-    Value* tmpVal2 = getVal(*yyvsp[-3].TypeVal, yyvsp[0].ValIDVal);
+    Value* tmpVal2 = getVal(*(yyvsp[-3].TypeVal), (yyvsp[0].ValIDVal));
     CHECK_FOR_ERROR
-    yyval.InstVal = BinaryOperator::create(yyvsp[-4].BinaryOpVal, tmpVal1, tmpVal2);
-    if (yyval.InstVal == 0)
+    (yyval.InstVal) = BinaryOperator::create((yyvsp[-4].BinaryOpVal), tmpVal1, tmpVal2);
+    if ((yyval.InstVal) == 0)
       GEN_ERROR("binary operator returned null!");
-    delete yyvsp[-3].TypeVal;
-  }
+    delete (yyvsp[-3].TypeVal);
+  ;}
     break;
 
   case 264:
-#line 2609 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2607 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-3].TypeVal)->getDescription());
-    if (isa((*yyvsp[-3].TypeVal).get()))
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-3].TypeVal))->getDescription());
+    if (isa((*(yyvsp[-3].TypeVal)).get()))
       GEN_ERROR("Packed types not supported by icmp instruction");
-    Value* tmpVal1 = getVal(*yyvsp[-3].TypeVal, yyvsp[-2].ValIDVal);
+    Value* tmpVal1 = getVal(*(yyvsp[-3].TypeVal), (yyvsp[-2].ValIDVal));
     CHECK_FOR_ERROR
-    Value* tmpVal2 = getVal(*yyvsp[-3].TypeVal, yyvsp[0].ValIDVal);
+    Value* tmpVal2 = getVal(*(yyvsp[-3].TypeVal), (yyvsp[0].ValIDVal));
     CHECK_FOR_ERROR
-    yyval.InstVal = CmpInst::create(yyvsp[-5].OtherOpVal, yyvsp[-4].IPredicate, tmpVal1, tmpVal2);
-    if (yyval.InstVal == 0)
+    (yyval.InstVal) = CmpInst::create((yyvsp[-5].OtherOpVal), (yyvsp[-4].IPredicate), tmpVal1, tmpVal2);
+    if ((yyval.InstVal) == 0)
       GEN_ERROR("icmp operator returned null!");
-  }
+  ;}
     break;
 
   case 265:
-#line 2622 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2620 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-3].TypeVal)->getDescription());
-    if (isa((*yyvsp[-3].TypeVal).get()))
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-3].TypeVal))->getDescription());
+    if (isa((*(yyvsp[-3].TypeVal)).get()))
       GEN_ERROR("Packed types not supported by fcmp instruction");
-    Value* tmpVal1 = getVal(*yyvsp[-3].TypeVal, yyvsp[-2].ValIDVal);
+    Value* tmpVal1 = getVal(*(yyvsp[-3].TypeVal), (yyvsp[-2].ValIDVal));
     CHECK_FOR_ERROR
-    Value* tmpVal2 = getVal(*yyvsp[-3].TypeVal, yyvsp[0].ValIDVal);
+    Value* tmpVal2 = getVal(*(yyvsp[-3].TypeVal), (yyvsp[0].ValIDVal));
     CHECK_FOR_ERROR
-    yyval.InstVal = CmpInst::create(yyvsp[-5].OtherOpVal, yyvsp[-4].FPredicate, tmpVal1, tmpVal2);
-    if (yyval.InstVal == 0)
+    (yyval.InstVal) = CmpInst::create((yyvsp[-5].OtherOpVal), (yyvsp[-4].FPredicate), tmpVal1, tmpVal2);
+    if ((yyval.InstVal) == 0)
       GEN_ERROR("fcmp operator returned null!");
-  }
+  ;}
     break;
 
   case 266:
-#line 2635 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2633 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    if (yyvsp[0].ValueVal->getType() != Type::Int8Ty)
+    if ((yyvsp[0].ValueVal)->getType() != Type::Int8Ty)
       GEN_ERROR("Shift amount must be i8 type!");
-    if (!yyvsp[-2].ValueVal->getType()->isInteger())
+    if (!(yyvsp[-2].ValueVal)->getType()->isInteger())
       GEN_ERROR("Shift constant expression requires integer operand!");
     CHECK_FOR_ERROR;
-    yyval.InstVal = new ShiftInst(yyvsp[-3].OtherOpVal, yyvsp[-2].ValueVal, yyvsp[0].ValueVal);
+    (yyval.InstVal) = new ShiftInst((yyvsp[-3].OtherOpVal), (yyvsp[-2].ValueVal), (yyvsp[0].ValueVal));
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
   case 267:
-#line 2644 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2642 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[0].TypeVal)->getDescription());
-    Value* Val = yyvsp[-2].ValueVal;
-    const Type* DestTy = yyvsp[0].TypeVal->get();
-    if (!CastInst::castIsValid(yyvsp[-3].CastOpVal, Val, DestTy))
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[0].TypeVal))->getDescription());
+    Value* Val = (yyvsp[-2].ValueVal);
+    const Type* DestTy = (yyvsp[0].TypeVal)->get();
+    if (!CastInst::castIsValid((yyvsp[-3].CastOpVal), Val, DestTy))
       GEN_ERROR("invalid cast opcode for cast from '" +
                 Val->getType()->getDescription() + "' to '" +
                 DestTy->getDescription() + "'!"); 
-    yyval.InstVal = CastInst::create(yyvsp[-3].CastOpVal, Val, DestTy);
-    delete yyvsp[0].TypeVal;
-  }
+    (yyval.InstVal) = CastInst::create((yyvsp[-3].CastOpVal), Val, DestTy);
+    delete (yyvsp[0].TypeVal);
+  ;}
     break;
 
   case 268:
-#line 2656 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2654 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    if (yyvsp[-4].ValueVal->getType() != Type::Int1Ty)
+    if ((yyvsp[-4].ValueVal)->getType() != Type::Int1Ty)
       GEN_ERROR("select condition must be boolean!");
-    if (yyvsp[-2].ValueVal->getType() != yyvsp[0].ValueVal->getType())
+    if ((yyvsp[-2].ValueVal)->getType() != (yyvsp[0].ValueVal)->getType())
       GEN_ERROR("select value types should match!");
-    yyval.InstVal = new SelectInst(yyvsp[-4].ValueVal, yyvsp[-2].ValueVal, yyvsp[0].ValueVal);
+    (yyval.InstVal) = new SelectInst((yyvsp[-4].ValueVal), (yyvsp[-2].ValueVal), (yyvsp[0].ValueVal));
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
   case 269:
-#line 2664 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2662 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[0].TypeVal)->getDescription());
-    yyval.InstVal = new VAArgInst(yyvsp[-2].ValueVal, *yyvsp[0].TypeVal);
-    delete yyvsp[0].TypeVal;
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[0].TypeVal))->getDescription());
+    (yyval.InstVal) = new VAArgInst((yyvsp[-2].ValueVal), *(yyvsp[0].TypeVal));
+    delete (yyvsp[0].TypeVal);
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
   case 270:
-#line 2671 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2669 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    if (!ExtractElementInst::isValidOperands(yyvsp[-2].ValueVal, yyvsp[0].ValueVal))
+    if (!ExtractElementInst::isValidOperands((yyvsp[-2].ValueVal), (yyvsp[0].ValueVal)))
       GEN_ERROR("Invalid extractelement operands!");
-    yyval.InstVal = new ExtractElementInst(yyvsp[-2].ValueVal, yyvsp[0].ValueVal);
+    (yyval.InstVal) = new ExtractElementInst((yyvsp[-2].ValueVal), (yyvsp[0].ValueVal));
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
   case 271:
-#line 2677 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2675 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    if (!InsertElementInst::isValidOperands(yyvsp[-4].ValueVal, yyvsp[-2].ValueVal, yyvsp[0].ValueVal))
+    if (!InsertElementInst::isValidOperands((yyvsp[-4].ValueVal), (yyvsp[-2].ValueVal), (yyvsp[0].ValueVal)))
       GEN_ERROR("Invalid insertelement operands!");
-    yyval.InstVal = new InsertElementInst(yyvsp[-4].ValueVal, yyvsp[-2].ValueVal, yyvsp[0].ValueVal);
+    (yyval.InstVal) = new InsertElementInst((yyvsp[-4].ValueVal), (yyvsp[-2].ValueVal), (yyvsp[0].ValueVal));
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
   case 272:
-#line 2683 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2681 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    if (!ShuffleVectorInst::isValidOperands(yyvsp[-4].ValueVal, yyvsp[-2].ValueVal, yyvsp[0].ValueVal))
+    if (!ShuffleVectorInst::isValidOperands((yyvsp[-4].ValueVal), (yyvsp[-2].ValueVal), (yyvsp[0].ValueVal)))
       GEN_ERROR("Invalid shufflevector operands!");
-    yyval.InstVal = new ShuffleVectorInst(yyvsp[-4].ValueVal, yyvsp[-2].ValueVal, yyvsp[0].ValueVal);
+    (yyval.InstVal) = new ShuffleVectorInst((yyvsp[-4].ValueVal), (yyvsp[-2].ValueVal), (yyvsp[0].ValueVal));
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
   case 273:
-#line 2689 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2687 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    const Type *Ty = yyvsp[0].PHIList->front().first->getType();
+    const Type *Ty = (yyvsp[0].PHIList)->front().first->getType();
     if (!Ty->isFirstClassType())
       GEN_ERROR("PHI node operands must be of first class type!");
-    yyval.InstVal = new PHINode(Ty);
-    ((PHINode*)yyval.InstVal)->reserveOperandSpace(yyvsp[0].PHIList->size());
-    while (yyvsp[0].PHIList->begin() != yyvsp[0].PHIList->end()) {
-      if (yyvsp[0].PHIList->front().first->getType() != Ty) 
+    (yyval.InstVal) = new PHINode(Ty);
+    ((PHINode*)(yyval.InstVal))->reserveOperandSpace((yyvsp[0].PHIList)->size());
+    while ((yyvsp[0].PHIList)->begin() != (yyvsp[0].PHIList)->end()) {
+      if ((yyvsp[0].PHIList)->front().first->getType() != Ty) 
         GEN_ERROR("All elements of a PHI node must be of the same type!");
-      cast(yyval.InstVal)->addIncoming(yyvsp[0].PHIList->front().first, yyvsp[0].PHIList->front().second);
-      yyvsp[0].PHIList->pop_front();
+      cast((yyval.InstVal))->addIncoming((yyvsp[0].PHIList)->front().first, (yyvsp[0].PHIList)->front().second);
+      (yyvsp[0].PHIList)->pop_front();
     }
-    delete yyvsp[0].PHIList;  // Free the list...
+    delete (yyvsp[0].PHIList);  // Free the list...
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
   case 274:
-#line 2705 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2703 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
 
     // Handle the short syntax
     const PointerType *PFTy = 0;
     const FunctionType *Ty = 0;
-    if (!(PFTy = dyn_cast(yyvsp[-5].TypeVal->get())) ||
+    if (!(PFTy = dyn_cast((yyvsp[-5].TypeVal)->get())) ||
         !(Ty = dyn_cast(PFTy->getElementType()))) {
       // Pull out the types of all of the arguments...
       std::vector ParamTypes;
       FunctionType::ParamAttrsList ParamAttrs;
-      ParamAttrs.push_back(yyvsp[0].ParamAttrs);
-      for (ValueRefList::iterator I = yyvsp[-2].ValueRefList->begin(), E = yyvsp[-2].ValueRefList->end(); I != E; ++I) {
+      ParamAttrs.push_back((yyvsp[0].ParamAttrs));
+      for (ValueRefList::iterator I = (yyvsp[-2].ValueRefList)->begin(), E = (yyvsp[-2].ValueRefList)->end(); I != E; ++I) {
         const Type *Ty = I->Val->getType();
         if (Ty == Type::VoidTy)
           GEN_ERROR("Short call syntax cannot be used with varargs");
@@ -5214,16 +5405,16 @@
         ParamAttrs.push_back(I->Attrs);
       }
 
-      Ty = FunctionType::get(yyvsp[-5].TypeVal->get(), ParamTypes, false, ParamAttrs);
+      Ty = FunctionType::get((yyvsp[-5].TypeVal)->get(), ParamTypes, false, ParamAttrs);
       PFTy = PointerType::get(Ty);
     }
 
-    Value *V = getVal(PFTy, yyvsp[-4].ValIDVal);   // Get the function we're calling...
+    Value *V = getVal(PFTy, (yyvsp[-4].ValIDVal));   // Get the function we're calling...
     CHECK_FOR_ERROR
 
     // Check the arguments 
     ValueList Args;
-    if (yyvsp[-2].ValueRefList->empty()) {                                   // Has no arguments?
+    if ((yyvsp[-2].ValueRefList)->empty()) {                                   // Has no arguments?
       // Make sure no arguments is a good thing!
       if (Ty->getNumParams() != 0)
         GEN_ERROR("No arguments passed to a function that "
@@ -5234,7 +5425,7 @@
       //
       FunctionType::param_iterator I = Ty->param_begin();
       FunctionType::param_iterator E = Ty->param_end();
-      ValueRefList::iterator ArgI = yyvsp[-2].ValueRefList->begin(), ArgE = yyvsp[-2].ValueRefList->end();
+      ValueRefList::iterator ArgI = (yyvsp[-2].ValueRefList)->begin(), ArgE = (yyvsp[-2].ValueRefList)->end();
 
       for (; ArgI != ArgE && I != E; ++ArgI, ++I) {
         if (ArgI->Val->getType() != *I)
@@ -5251,173 +5442,166 @@
     }
     // Create the call node
     CallInst *CI = new CallInst(V, Args);
-    CI->setTailCall(yyvsp[-7].BoolVal);
-    CI->setCallingConv(yyvsp[-6].UIntVal);
-    yyval.InstVal = CI;
-    delete yyvsp[-2].ValueRefList;
+    CI->setTailCall((yyvsp[-7].BoolVal));
+    CI->setCallingConv((yyvsp[-6].UIntVal));
+    (yyval.InstVal) = CI;
+    delete (yyvsp[-2].ValueRefList);
+    delete (yyvsp[-5].TypeVal);
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
   case 275:
-#line 2767 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2766 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    yyval.InstVal = yyvsp[0].InstVal;
+    (yyval.InstVal) = (yyvsp[0].InstVal);
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
   case 276:
-#line 2772 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2771 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    yyval.BoolVal = true;
+    (yyval.BoolVal) = true;
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
   case 277:
-#line 2776 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2775 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    yyval.BoolVal = false;
+    (yyval.BoolVal) = false;
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
   case 278:
-#line 2783 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2782 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
-    yyval.InstVal = new MallocInst(*yyvsp[-1].TypeVal, 0, yyvsp[0].UIntVal);
-    delete yyvsp[-1].TypeVal;
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-1].TypeVal))->getDescription());
+    (yyval.InstVal) = new MallocInst(*(yyvsp[-1].TypeVal), 0, (yyvsp[0].UIntVal));
+    delete (yyvsp[-1].TypeVal);
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
   case 279:
-#line 2790 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2789 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-4].TypeVal)->getDescription());
-    Value* tmpVal = getVal(yyvsp[-2].PrimType, yyvsp[-1].ValIDVal);
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-4].TypeVal))->getDescription());
+    Value* tmpVal = getVal((yyvsp[-2].PrimType), (yyvsp[-1].ValIDVal));
     CHECK_FOR_ERROR
-    yyval.InstVal = new MallocInst(*yyvsp[-4].TypeVal, tmpVal, yyvsp[0].UIntVal);
-    delete yyvsp[-4].TypeVal;
-  }
+    (yyval.InstVal) = new MallocInst(*(yyvsp[-4].TypeVal), tmpVal, (yyvsp[0].UIntVal));
+    delete (yyvsp[-4].TypeVal);
+  ;}
     break;
 
   case 280:
-#line 2798 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2797 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
-    yyval.InstVal = new AllocaInst(*yyvsp[-1].TypeVal, 0, yyvsp[0].UIntVal);
-    delete yyvsp[-1].TypeVal;
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-1].TypeVal))->getDescription());
+    (yyval.InstVal) = new AllocaInst(*(yyvsp[-1].TypeVal), 0, (yyvsp[0].UIntVal));
+    delete (yyvsp[-1].TypeVal);
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
   case 281:
-#line 2805 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2804 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-4].TypeVal)->getDescription());
-    Value* tmpVal = getVal(yyvsp[-2].PrimType, yyvsp[-1].ValIDVal);
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-4].TypeVal))->getDescription());
+    Value* tmpVal = getVal((yyvsp[-2].PrimType), (yyvsp[-1].ValIDVal));
     CHECK_FOR_ERROR
-    yyval.InstVal = new AllocaInst(*yyvsp[-4].TypeVal, tmpVal, yyvsp[0].UIntVal);
-    delete yyvsp[-4].TypeVal;
-  }
+    (yyval.InstVal) = new AllocaInst(*(yyvsp[-4].TypeVal), tmpVal, (yyvsp[0].UIntVal));
+    delete (yyvsp[-4].TypeVal);
+  ;}
     break;
 
   case 282:
-#line 2813 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2812 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
-    if (!isa(yyvsp[0].ValueVal->getType()))
+    if (!isa((yyvsp[0].ValueVal)->getType()))
       GEN_ERROR("Trying to free nonpointer type " + 
-                     yyvsp[0].ValueVal->getType()->getDescription() + "!");
-    yyval.InstVal = new FreeInst(yyvsp[0].ValueVal);
+                     (yyvsp[0].ValueVal)->getType()->getDescription() + "!");
+    (yyval.InstVal) = new FreeInst((yyvsp[0].ValueVal));
     CHECK_FOR_ERROR
-  }
+  ;}
     break;
 
   case 283:
-#line 2821 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2820 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
-    if (!isa(yyvsp[-1].TypeVal->get()))
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-1].TypeVal))->getDescription());
+    if (!isa((yyvsp[-1].TypeVal)->get()))
       GEN_ERROR("Can't load from nonpointer type: " +
-                     (*yyvsp[-1].TypeVal)->getDescription());
-    if (!cast(yyvsp[-1].TypeVal->get())->getElementType()->isFirstClassType())
+                     (*(yyvsp[-1].TypeVal))->getDescription());
+    if (!cast((yyvsp[-1].TypeVal)->get())->getElementType()->isFirstClassType())
       GEN_ERROR("Can't load from pointer of non-first-class type: " +
-                     (*yyvsp[-1].TypeVal)->getDescription());
-    Value* tmpVal = getVal(*yyvsp[-1].TypeVal, yyvsp[0].ValIDVal);
+                     (*(yyvsp[-1].TypeVal))->getDescription());
+    Value* tmpVal = getVal(*(yyvsp[-1].TypeVal), (yyvsp[0].ValIDVal));
     CHECK_FOR_ERROR
-    yyval.InstVal = new LoadInst(tmpVal, "", yyvsp[-3].BoolVal);
-    delete yyvsp[-1].TypeVal;
-  }
+    (yyval.InstVal) = new LoadInst(tmpVal, "", (yyvsp[-3].BoolVal));
+    delete (yyvsp[-1].TypeVal);
+  ;}
     break;
 
   case 284:
-#line 2835 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2834 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
-    const PointerType *PT = dyn_cast(yyvsp[-1].TypeVal->get());
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-1].TypeVal))->getDescription());
+    const PointerType *PT = dyn_cast((yyvsp[-1].TypeVal)->get());
     if (!PT)
       GEN_ERROR("Can't store to a nonpointer type: " +
-                     (*yyvsp[-1].TypeVal)->getDescription());
+                     (*(yyvsp[-1].TypeVal))->getDescription());
     const Type *ElTy = PT->getElementType();
-    if (ElTy != yyvsp[-3].ValueVal->getType())
-      GEN_ERROR("Can't store '" + yyvsp[-3].ValueVal->getType()->getDescription() +
+    if (ElTy != (yyvsp[-3].ValueVal)->getType())
+      GEN_ERROR("Can't store '" + (yyvsp[-3].ValueVal)->getType()->getDescription() +
                      "' into space of type '" + ElTy->getDescription() + "'!");
 
-    Value* tmpVal = getVal(*yyvsp[-1].TypeVal, yyvsp[0].ValIDVal);
+    Value* tmpVal = getVal(*(yyvsp[-1].TypeVal), (yyvsp[0].ValIDVal));
     CHECK_FOR_ERROR
-    yyval.InstVal = new StoreInst(yyvsp[-3].ValueVal, tmpVal, yyvsp[-5].BoolVal);
-    delete yyvsp[-1].TypeVal;
-  }
+    (yyval.InstVal) = new StoreInst((yyvsp[-3].ValueVal), tmpVal, (yyvsp[-5].BoolVal));
+    delete (yyvsp[-1].TypeVal);
+  ;}
     break;
 
   case 285:
-#line 2852 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2851 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
     {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription());
-    if (!isa(yyvsp[-2].TypeVal->get()))
+      GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-2].TypeVal))->getDescription());
+    if (!isa((yyvsp[-2].TypeVal)->get()))
       GEN_ERROR("getelementptr insn requires pointer operand!");
 
-    if (!GetElementPtrInst::getIndexedType(*yyvsp[-2].TypeVal, *yyvsp[0].ValueList, true))
+    if (!GetElementPtrInst::getIndexedType(*(yyvsp[-2].TypeVal), *(yyvsp[0].ValueList), true))
       GEN_ERROR("Invalid getelementptr indices for type '" +
-                     (*yyvsp[-2].TypeVal)->getDescription()+ "'!");
-    Value* tmpVal = getVal(*yyvsp[-2].TypeVal, yyvsp[-1].ValIDVal);
+                     (*(yyvsp[-2].TypeVal))->getDescription()+ "'!");
+    Value* tmpVal = getVal(*(yyvsp[-2].TypeVal), (yyvsp[-1].ValIDVal));
     CHECK_FOR_ERROR
-    yyval.InstVal = new GetElementPtrInst(tmpVal, *yyvsp[0].ValueList);
-    delete yyvsp[-2].TypeVal; 
-    delete yyvsp[0].ValueList;
-  }
+    (yyval.InstVal) = new GetElementPtrInst(tmpVal, *(yyvsp[0].ValueList));
+    delete (yyvsp[-2].TypeVal); 
+    delete (yyvsp[0].ValueList);
+  ;}
     break;
 
 
+      default: break;
     }
 
-/* Line 1016 of /usr/local/share/bison/yacc.c.  */
-#line 5406 "llvmAsmParser.tab.c"
+/* Line 1126 of yacc.c.  */
+#line 5599 "llvmAsmParser.tab.c"
 
   yyvsp -= yylen;
   yyssp -= yylen;
 
 
-#if YYDEBUG
-  if (yydebug)
-    {
-      short *yyssp1 = yyss - 1;
-      YYFPRINTF (stderr, "state stack now");
-      while (yyssp1 != yyssp)
-	YYFPRINTF (stderr, " %d", *++yyssp1);
-      YYFPRINTF (stderr, "\n");
-    }
-#endif
+  YY_STACK_PRINT (yyss, yyssp);
 
   *++yyvsp = yyval;
 
@@ -5450,90 +5634,153 @@
 
       if (YYPACT_NINF < yyn && yyn < YYLAST)
 	{
-	  YYSIZE_T yysize = 0;
 	  int yytype = YYTRANSLATE (yychar);
-	  char *yymsg;
-	  int yyx, yycount;
+	  YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
+	  YYSIZE_T yysize = yysize0;
+	  YYSIZE_T yysize1;
+	  int yysize_overflow = 0;
+	  char *yymsg = 0;
+#	  define YYERROR_VERBOSE_ARGS_MAXIMUM 5
+	  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
+	  int yyx;
+
+#if 0
+	  /* This is so xgettext sees the translatable formats that are
+	     constructed on the fly.  */
+	  YY_("syntax error, unexpected %s");
+	  YY_("syntax error, unexpected %s, expecting %s");
+	  YY_("syntax error, unexpected %s, expecting %s or %s");
+	  YY_("syntax error, unexpected %s, expecting %s or %s or %s");
+	  YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
+#endif
+	  char *yyfmt;
+	  char const *yyf;
+	  static char const yyunexpected[] = "syntax error, unexpected %s";
+	  static char const yyexpecting[] = ", expecting %s";
+	  static char const yyor[] = " or %s";
+	  char yyformat[sizeof yyunexpected
+			+ sizeof yyexpecting - 1
+			+ ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
+			   * (sizeof yyor - 1))];
+	  char const *yyprefix = yyexpecting;
 
-	  yycount = 0;
 	  /* Start YYX at -YYN if negative to avoid negative indexes in
 	     YYCHECK.  */
-	  for (yyx = yyn < 0 ? -yyn : 0;
-	       yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
+	  int yyxbegin = yyn < 0 ? -yyn : 0;
+
+	  /* Stay within bounds of both yycheck and yytname.  */
+	  int yychecklim = YYLAST - yyn;
+	  int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
+	  int yycount = 1;
+
+	  yyarg[0] = yytname[yytype];
+	  yyfmt = yystpcpy (yyformat, yyunexpected);
+
+	  for (yyx = yyxbegin; yyx < yyxend; ++yyx)
 	    if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
-	      yysize += yystrlen (yytname[yyx]) + 15, yycount++;
-	  yysize += yystrlen ("parse error, unexpected ") + 1;
-	  yysize += yystrlen (yytname[yytype]);
-	  yymsg = (char *) YYSTACK_ALLOC (yysize);
-	  if (yymsg != 0)
+	      {
+		if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
+		  {
+		    yycount = 1;
+		    yysize = yysize0;
+		    yyformat[sizeof yyunexpected - 1] = '\0';
+		    break;
+		  }
+		yyarg[yycount++] = yytname[yyx];
+		yysize1 = yysize + yytnamerr (0, yytname[yyx]);
+		yysize_overflow |= yysize1 < yysize;
+		yysize = yysize1;
+		yyfmt = yystpcpy (yyfmt, yyprefix);
+		yyprefix = yyor;
+	      }
+
+	  yyf = YY_(yyformat);
+	  yysize1 = yysize + yystrlen (yyf);
+	  yysize_overflow |= yysize1 < yysize;
+	  yysize = yysize1;
+
+	  if (!yysize_overflow && yysize <= YYSTACK_ALLOC_MAXIMUM)
+	    yymsg = (char *) YYSTACK_ALLOC (yysize);
+	  if (yymsg)
 	    {
-	      char *yyp = yystpcpy (yymsg, "parse error, unexpected ");
-	      yyp = yystpcpy (yyp, yytname[yytype]);
-
-	      if (yycount < 5)
+	      /* Avoid sprintf, as that infringes on the user's name space.
+		 Don't have undefined behavior even if the translation
+		 produced a string with the wrong number of "%s"s.  */
+	      char *yyp = yymsg;
+	      int yyi = 0;
+	      while ((*yyp = *yyf))
 		{
-		  yycount = 0;
-		  for (yyx = yyn < 0 ? -yyn : 0;
-		       yyx < (int) (sizeof (yytname) / sizeof (char *));
-		       yyx++)
-		    if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
-		      {
-			const char *yyq = ! yycount ? ", expecting " : " or ";
-			yyp = yystpcpy (yyp, yyq);
-			yyp = yystpcpy (yyp, yytname[yyx]);
-			yycount++;
-		      }
+		  if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
+		    {
+		      yyp += yytnamerr (yyp, yyarg[yyi++]);
+		      yyf += 2;
+		    }
+		  else
+		    {
+		      yyp++;
+		      yyf++;
+		    }
 		}
 	      yyerror (yymsg);
 	      YYSTACK_FREE (yymsg);
 	    }
 	  else
-	    yyerror ("parse error; also virtual memory exhausted");
+	    {
+	      yyerror (YY_("syntax error"));
+	      goto yyexhaustedlab;
+	    }
 	}
       else
 #endif /* YYERROR_VERBOSE */
-	yyerror ("parse error");
+	yyerror (YY_("syntax error"));
     }
-  goto yyerrlab1;
 
 
-/*----------------------------------------------------.
-| yyerrlab1 -- error raised explicitly by an action.  |
-`----------------------------------------------------*/
-yyerrlab1:
+
   if (yyerrstatus == 3)
     {
-      /* If just tried and failed to reuse lookahead token after an
+      /* If just tried and failed to reuse look-ahead token after an
 	 error, discard it.  */
 
-      /* Return failure if at end of input.  */
-      if (yychar == YYEOF)
+      if (yychar <= YYEOF)
         {
-	  /* Pop the error token.  */
-          YYPOPSTACK;
-	  /* Pop the rest of the stack.  */
-	  while (yyssp > yyss)
-	    {
-	      YYDPRINTF ((stderr, "Error: popping "));
-	      YYDSYMPRINT ((stderr,
-			    yystos[*yyssp],
-			    *yyvsp));
-	      YYDPRINTF ((stderr, "\n"));
-	      yydestruct (yystos[*yyssp], *yyvsp);
-	      YYPOPSTACK;
-	    }
-	  YYABORT;
+	  /* Return failure if at end of input.  */
+	  if (yychar == YYEOF)
+	    YYABORT;
         }
-
-      YYDPRINTF ((stderr, "Discarding token %d (%s).\n",
-		  yychar, yytname[yychar1]));
-      yydestruct (yychar1, yylval);
-      yychar = YYEMPTY;
+      else
+	{
+	  yydestruct ("Error: discarding", yytoken, &yylval);
+	  yychar = YYEMPTY;
+	}
     }
 
-  /* Else will try to reuse lookahead token after shifting the error
+  /* Else will try to reuse look-ahead token after shifting the error
      token.  */
+  goto yyerrlab1;
+
+
+/*---------------------------------------------------.
+| yyerrorlab -- error raised explicitly by YYERROR.  |
+`---------------------------------------------------*/
+yyerrorlab:
+
+  /* Pacify compilers like GCC when the user code never invokes
+     YYERROR and the label yyerrorlab therefore never appears in user
+     code.  */
+  if (0)
+     goto yyerrorlab;
 
+yyvsp -= yylen;
+  yyssp -= yylen;
+  yystate = *yyssp;
+  goto yyerrlab1;
+
+
+/*-------------------------------------------------------------.
+| yyerrlab1 -- common code for both syntax error and YYERROR.  |
+`-------------------------------------------------------------*/
+yyerrlab1:
   yyerrstatus = 3;	/* Each real token shifted decrements this.  */
 
   for (;;)
@@ -5554,36 +5801,22 @@
       if (yyssp == yyss)
 	YYABORT;
 
-      YYDPRINTF ((stderr, "Error: popping "));
-      YYDSYMPRINT ((stderr,
-		    yystos[*yyssp], *yyvsp));
-      YYDPRINTF ((stderr, "\n"));
-
-      yydestruct (yystos[yystate], *yyvsp);
-      yyvsp--;
-      yystate = *--yyssp;
-
 
-#if YYDEBUG
-      if (yydebug)
-	{
-	  short *yyssp1 = yyss - 1;
-	  YYFPRINTF (stderr, "Error: state stack now");
-	  while (yyssp1 != yyssp)
-	    YYFPRINTF (stderr, " %d", *++yyssp1);
-	  YYFPRINTF (stderr, "\n");
-	}
-#endif
+      yydestruct ("Error: popping", yystos[yystate], yyvsp);
+      YYPOPSTACK;
+      yystate = *yyssp;
+      YY_STACK_PRINT (yyss, yyssp);
     }
 
   if (yyn == YYFINAL)
     YYACCEPT;
 
-  YYDPRINTF ((stderr, "Shifting error token, "));
-
   *++yyvsp = yylval;
 
 
+  /* Shift the error token. */
+  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
+
   yystate = yyn;
   goto yynewstate;
 
@@ -5603,16 +5836,25 @@
   goto yyreturn;
 
 #ifndef yyoverflow
-/*----------------------------------------------.
-| yyoverflowlab -- parser overflow comes here.  |
-`----------------------------------------------*/
-yyoverflowlab:
-  yyerror ("parser stack overflow");
+/*-------------------------------------------------.
+| yyexhaustedlab -- memory exhaustion comes here.  |
+`-------------------------------------------------*/
+yyexhaustedlab:
+  yyerror (YY_("memory exhausted"));
   yyresult = 2;
   /* Fall through.  */
 #endif
 
 yyreturn:
+  if (yychar != YYEOF && yychar != YYEMPTY)
+     yydestruct ("Cleanup: discarding lookahead",
+		 yytoken, &yylval);
+  while (yyssp != yyss)
+    {
+      yydestruct ("Cleanup: popping",
+		  yystos[*yyssp], yyvsp);
+      YYPOPSTACK;
+    }
 #ifndef yyoverflow
   if (yyss != yyssa)
     YYSTACK_FREE (yyss);
@@ -5621,7 +5863,7 @@
 }
 
 
-#line 2869 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
+#line 2868 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
 
 
 // common code from the two 'RunVMAsmParser' functions


Index: llvm/lib/AsmParser/llvmAsmParser.h.cvs
diff -u llvm/lib/AsmParser/llvmAsmParser.h.cvs:1.45 llvm/lib/AsmParser/llvmAsmParser.h.cvs:1.46
--- llvm/lib/AsmParser/llvmAsmParser.h.cvs:1.45	Sun Jan 21 13:19:31 2007
+++ llvm/lib/AsmParser/llvmAsmParser.h.cvs	Fri Jan 26 02:05:27 2007
@@ -1,7 +1,7 @@
-/* A Bison parser, made from /usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y, by GNU bison 1.75.  */
+/* A Bison parser, made by GNU Bison 2.1.  */
 
 /* Skeleton parser for Yacc-like parsing with Bison,
-   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software Foundation, Inc.
+   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -15,17 +15,14 @@
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
+   Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.  */
 
 /* As a special exception, when this file is copied by Bison into a
    Bison output file, you may use that output file without restriction.
    This special exception was added by the Free Software Foundation
    in version 1.24 of Bison.  */
 
-#ifndef BISON_LLVMASMPARSER_TAB_H
-# define BISON_LLVMASMPARSER_TAB_H
-
 /* Tokens.  */
 #ifndef YYTOKENTYPE
 # define YYTOKENTYPE
@@ -34,8 +31,8 @@
    enum yytokentype {
      ESINT64VAL = 258,
      EUINT64VAL = 259,
-     SINTVAL = 260,
-     UINTVAL = 261,
+     LOCALVAL_ID = 260,
+     GLOBALVAL_ID = 261,
      FPVAL = 262,
      VOID = 263,
      INTTYPE = 264,
@@ -43,131 +40,130 @@
      DOUBLE = 266,
      LABEL = 267,
      TYPE = 268,
-     VAR_ID = 269,
-     LABELSTR = 270,
-     STRINGCONSTANT = 271,
-     IMPLEMENTATION = 272,
-     ZEROINITIALIZER = 273,
-     TRUETOK = 274,
-     FALSETOK = 275,
-     BEGINTOK = 276,
-     ENDTOK = 277,
-     DECLARE = 278,
-     DEFINE = 279,
-     GLOBAL = 280,
-     CONSTANT = 281,
-     SECTION = 282,
-     VOLATILE = 283,
-     TO = 284,
-     DOTDOTDOT = 285,
-     NULL_TOK = 286,
-     UNDEF = 287,
-     INTERNAL = 288,
-     LINKONCE = 289,
-     WEAK = 290,
-     APPENDING = 291,
-     DLLIMPORT = 292,
-     DLLEXPORT = 293,
-     EXTERN_WEAK = 294,
-     OPAQUE = 295,
-     EXTERNAL = 296,
-     TARGET = 297,
-     TRIPLE = 298,
-     ENDIAN = 299,
-     POINTERSIZE = 300,
-     LITTLE = 301,
-     BIG = 302,
-     ALIGN = 303,
-     DEPLIBS = 304,
-     CALL = 305,
-     TAIL = 306,
-     ASM_TOK = 307,
-     MODULE = 308,
-     SIDEEFFECT = 309,
-     CC_TOK = 310,
-     CCC_TOK = 311,
-     CSRETCC_TOK = 312,
-     FASTCC_TOK = 313,
-     COLDCC_TOK = 314,
-     X86_STDCALLCC_TOK = 315,
-     X86_FASTCALLCC_TOK = 316,
-     DATALAYOUT = 317,
-     RET = 318,
-     BR = 319,
-     SWITCH = 320,
-     INVOKE = 321,
-     UNWIND = 322,
-     UNREACHABLE = 323,
-     ADD = 324,
-     SUB = 325,
-     MUL = 326,
-     UDIV = 327,
-     SDIV = 328,
-     FDIV = 329,
-     UREM = 330,
-     SREM = 331,
-     FREM = 332,
-     AND = 333,
-     OR = 334,
-     XOR = 335,
-     ICMP = 336,
-     FCMP = 337,
-     EQ = 338,
-     NE = 339,
-     SLT = 340,
-     SGT = 341,
-     SLE = 342,
-     SGE = 343,
-     ULT = 344,
-     UGT = 345,
-     ULE = 346,
-     UGE = 347,
-     OEQ = 348,
-     ONE = 349,
-     OLT = 350,
-     OGT = 351,
-     OLE = 352,
-     OGE = 353,
-     ORD = 354,
-     UNO = 355,
-     UEQ = 356,
-     UNE = 357,
-     MALLOC = 358,
-     ALLOCA = 359,
-     FREE = 360,
-     LOAD = 361,
-     STORE = 362,
-     GETELEMENTPTR = 363,
-     TRUNC = 364,
-     ZEXT = 365,
-     SEXT = 366,
-     FPTRUNC = 367,
-     FPEXT = 368,
-     BITCAST = 369,
-     UITOFP = 370,
-     SITOFP = 371,
-     FPTOUI = 372,
-     FPTOSI = 373,
-     INTTOPTR = 374,
-     PTRTOINT = 375,
-     PHI_TOK = 376,
-     SELECT = 377,
-     SHL = 378,
-     LSHR = 379,
-     ASHR = 380,
-     VAARG = 381,
-     EXTRACTELEMENT = 382,
-     INSERTELEMENT = 383,
-     SHUFFLEVECTOR = 384,
-     NORETURN = 385,
-     DEFAULT = 386,
-     HIDDEN = 387
+     LOCALVAR = 269,
+     GLOBALVAR = 270,
+     LABELSTR = 271,
+     STRINGCONSTANT = 272,
+     ATSTRINGCONSTANT = 273,
+     IMPLEMENTATION = 274,
+     ZEROINITIALIZER = 275,
+     TRUETOK = 276,
+     FALSETOK = 277,
+     BEGINTOK = 278,
+     ENDTOK = 279,
+     DECLARE = 280,
+     DEFINE = 281,
+     GLOBAL = 282,
+     CONSTANT = 283,
+     SECTION = 284,
+     VOLATILE = 285,
+     TO = 286,
+     DOTDOTDOT = 287,
+     NULL_TOK = 288,
+     UNDEF = 289,
+     INTERNAL = 290,
+     LINKONCE = 291,
+     WEAK = 292,
+     APPENDING = 293,
+     DLLIMPORT = 294,
+     DLLEXPORT = 295,
+     EXTERN_WEAK = 296,
+     OPAQUE = 297,
+     EXTERNAL = 298,
+     TARGET = 299,
+     TRIPLE = 300,
+     ALIGN = 301,
+     DEPLIBS = 302,
+     CALL = 303,
+     TAIL = 304,
+     ASM_TOK = 305,
+     MODULE = 306,
+     SIDEEFFECT = 307,
+     CC_TOK = 308,
+     CCC_TOK = 309,
+     CSRETCC_TOK = 310,
+     FASTCC_TOK = 311,
+     COLDCC_TOK = 312,
+     X86_STDCALLCC_TOK = 313,
+     X86_FASTCALLCC_TOK = 314,
+     DATALAYOUT = 315,
+     RET = 316,
+     BR = 317,
+     SWITCH = 318,
+     INVOKE = 319,
+     UNWIND = 320,
+     UNREACHABLE = 321,
+     ADD = 322,
+     SUB = 323,
+     MUL = 324,
+     UDIV = 325,
+     SDIV = 326,
+     FDIV = 327,
+     UREM = 328,
+     SREM = 329,
+     FREM = 330,
+     AND = 331,
+     OR = 332,
+     XOR = 333,
+     ICMP = 334,
+     FCMP = 335,
+     EQ = 336,
+     NE = 337,
+     SLT = 338,
+     SGT = 339,
+     SLE = 340,
+     SGE = 341,
+     ULT = 342,
+     UGT = 343,
+     ULE = 344,
+     UGE = 345,
+     OEQ = 346,
+     ONE = 347,
+     OLT = 348,
+     OGT = 349,
+     OLE = 350,
+     OGE = 351,
+     ORD = 352,
+     UNO = 353,
+     UEQ = 354,
+     UNE = 355,
+     MALLOC = 356,
+     ALLOCA = 357,
+     FREE = 358,
+     LOAD = 359,
+     STORE = 360,
+     GETELEMENTPTR = 361,
+     TRUNC = 362,
+     ZEXT = 363,
+     SEXT = 364,
+     FPTRUNC = 365,
+     FPEXT = 366,
+     BITCAST = 367,
+     UITOFP = 368,
+     SITOFP = 369,
+     FPTOUI = 370,
+     FPTOSI = 371,
+     INTTOPTR = 372,
+     PTRTOINT = 373,
+     PHI_TOK = 374,
+     SELECT = 375,
+     SHL = 376,
+     LSHR = 377,
+     ASHR = 378,
+     VAARG = 379,
+     EXTRACTELEMENT = 380,
+     INSERTELEMENT = 381,
+     SHUFFLEVECTOR = 382,
+     NORETURN = 383,
+     DEFAULT = 384,
+     HIDDEN = 385
    };
 #endif
+/* Tokens.  */
 #define ESINT64VAL 258
 #define EUINT64VAL 259
-#define SINTVAL 260
-#define UINTVAL 261
+#define LOCALVAL_ID 260
+#define GLOBALVAL_ID 261
 #define FPVAL 262
 #define VOID 263
 #define INTTYPE 264
@@ -175,132 +171,130 @@
 #define DOUBLE 266
 #define LABEL 267
 #define TYPE 268
-#define VAR_ID 269
-#define LABELSTR 270
-#define STRINGCONSTANT 271
-#define IMPLEMENTATION 272
-#define ZEROINITIALIZER 273
-#define TRUETOK 274
-#define FALSETOK 275
-#define BEGINTOK 276
-#define ENDTOK 277
-#define DECLARE 278
-#define DEFINE 279
-#define GLOBAL 280
-#define CONSTANT 281
-#define SECTION 282
-#define VOLATILE 283
-#define TO 284
-#define DOTDOTDOT 285
-#define NULL_TOK 286
-#define UNDEF 287
-#define INTERNAL 288
-#define LINKONCE 289
-#define WEAK 290
-#define APPENDING 291
-#define DLLIMPORT 292
-#define DLLEXPORT 293
-#define EXTERN_WEAK 294
-#define OPAQUE 295
-#define EXTERNAL 296
-#define TARGET 297
-#define TRIPLE 298
-#define ENDIAN 299
-#define POINTERSIZE 300
-#define LITTLE 301
-#define BIG 302
-#define ALIGN 303
-#define DEPLIBS 304
-#define CALL 305
-#define TAIL 306
-#define ASM_TOK 307
-#define MODULE 308
-#define SIDEEFFECT 309
-#define CC_TOK 310
-#define CCC_TOK 311
-#define CSRETCC_TOK 312
-#define FASTCC_TOK 313
-#define COLDCC_TOK 314
-#define X86_STDCALLCC_TOK 315
-#define X86_FASTCALLCC_TOK 316
-#define DATALAYOUT 317
-#define RET 318
-#define BR 319
-#define SWITCH 320
-#define INVOKE 321
-#define UNWIND 322
-#define UNREACHABLE 323
-#define ADD 324
-#define SUB 325
-#define MUL 326
-#define UDIV 327
-#define SDIV 328
-#define FDIV 329
-#define UREM 330
-#define SREM 331
-#define FREM 332
-#define AND 333
-#define OR 334
-#define XOR 335
-#define ICMP 336
-#define FCMP 337
-#define EQ 338
-#define NE 339
-#define SLT 340
-#define SGT 341
-#define SLE 342
-#define SGE 343
-#define ULT 344
-#define UGT 345
-#define ULE 346
-#define UGE 347
-#define OEQ 348
-#define ONE 349
-#define OLT 350
-#define OGT 351
-#define OLE 352
-#define OGE 353
-#define ORD 354
-#define UNO 355
-#define UEQ 356
-#define UNE 357
-#define MALLOC 358
-#define ALLOCA 359
-#define FREE 360
-#define LOAD 361
-#define STORE 362
-#define GETELEMENTPTR 363
-#define TRUNC 364
-#define ZEXT 365
-#define SEXT 366
-#define FPTRUNC 367
-#define FPEXT 368
-#define BITCAST 369
-#define UITOFP 370
-#define SITOFP 371
-#define FPTOUI 372
-#define FPTOSI 373
-#define INTTOPTR 374
-#define PTRTOINT 375
-#define PHI_TOK 376
-#define SELECT 377
-#define SHL 378
-#define LSHR 379
-#define ASHR 380
-#define VAARG 381
-#define EXTRACTELEMENT 382
-#define INSERTELEMENT 383
-#define SHUFFLEVECTOR 384
-#define NORETURN 385
-#define DEFAULT 386
-#define HIDDEN 387
-
-
-
-
-#ifndef YYSTYPE
-#line 883 "/usr/home/jeffc/llvm/lib/AsmParser/llvmAsmParser.y"
-typedef union {
+#define LOCALVAR 269
+#define GLOBALVAR 270
+#define LABELSTR 271
+#define STRINGCONSTANT 272
+#define ATSTRINGCONSTANT 273
+#define IMPLEMENTATION 274
+#define ZEROINITIALIZER 275
+#define TRUETOK 276
+#define FALSETOK 277
+#define BEGINTOK 278
+#define ENDTOK 279
+#define DECLARE 280
+#define DEFINE 281
+#define GLOBAL 282
+#define CONSTANT 283
+#define SECTION 284
+#define VOLATILE 285
+#define TO 286
+#define DOTDOTDOT 287
+#define NULL_TOK 288
+#define UNDEF 289
+#define INTERNAL 290
+#define LINKONCE 291
+#define WEAK 292
+#define APPENDING 293
+#define DLLIMPORT 294
+#define DLLEXPORT 295
+#define EXTERN_WEAK 296
+#define OPAQUE 297
+#define EXTERNAL 298
+#define TARGET 299
+#define TRIPLE 300
+#define ALIGN 301
+#define DEPLIBS 302
+#define CALL 303
+#define TAIL 304
+#define ASM_TOK 305
+#define MODULE 306
+#define SIDEEFFECT 307
+#define CC_TOK 308
+#define CCC_TOK 309
+#define CSRETCC_TOK 310
+#define FASTCC_TOK 311
+#define COLDCC_TOK 312
+#define X86_STDCALLCC_TOK 313
+#define X86_FASTCALLCC_TOK 314
+#define DATALAYOUT 315
+#define RET 316
+#define BR 317
+#define SWITCH 318
+#define INVOKE 319
+#define UNWIND 320
+#define UNREACHABLE 321
+#define ADD 322
+#define SUB 323
+#define MUL 324
+#define UDIV 325
+#define SDIV 326
+#define FDIV 327
+#define UREM 328
+#define SREM 329
+#define FREM 330
+#define AND 331
+#define OR 332
+#define XOR 333
+#define ICMP 334
+#define FCMP 335
+#define EQ 336
+#define NE 337
+#define SLT 338
+#define SGT 339
+#define SLE 340
+#define SGE 341
+#define ULT 342
+#define UGT 343
+#define ULE 344
+#define UGE 345
+#define OEQ 346
+#define ONE 347
+#define OLT 348
+#define OGT 349
+#define OLE 350
+#define OGE 351
+#define ORD 352
+#define UNO 353
+#define UEQ 354
+#define UNE 355
+#define MALLOC 356
+#define ALLOCA 357
+#define FREE 358
+#define LOAD 359
+#define STORE 360
+#define GETELEMENTPTR 361
+#define TRUNC 362
+#define ZEXT 363
+#define SEXT 364
+#define FPTRUNC 365
+#define FPEXT 366
+#define BITCAST 367
+#define UITOFP 368
+#define SITOFP 369
+#define FPTOUI 370
+#define FPTOSI 371
+#define INTTOPTR 372
+#define PTRTOINT 373
+#define PHI_TOK 374
+#define SELECT 375
+#define SHL 376
+#define LSHR 377
+#define ASHR 378
+#define VAARG 379
+#define EXTRACTELEMENT 380
+#define INSERTELEMENT 381
+#define SHUFFLEVECTOR 382
+#define NORETURN 383
+#define DEFAULT 384
+#define HIDDEN 385
+
+
+
+
+#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
+#line 885 "/proj/llvm/llvm-1/lib/AsmParser/llvmAsmParser.y"
+typedef union YYSTYPE {
   llvm::Module                           *ModuleVal;
   llvm::Function                         *FunctionVal;
   llvm::BasicBlock                       *BasicBlockVal;
@@ -342,17 +336,17 @@
   llvm::Instruction::MemoryOps      MemOpVal;
   llvm::Instruction::CastOps        CastOpVal;
   llvm::Instruction::OtherOps       OtherOpVal;
-  llvm::Module::Endianness          Endianness;
   llvm::ICmpInst::Predicate         IPredicate;
   llvm::FCmpInst::Predicate         FPredicate;
-} yystype;
-/* Line 1237 of /usr/local/share/bison/yacc.c.  */
-#line 351 "llvmAsmParser.tab.h"
-# define YYSTYPE yystype
+} YYSTYPE;
+/* Line 1447 of yacc.c.  */
+#line 344 "llvmAsmParser.tab.h"
+# define yystype YYSTYPE /* obsolescent; will be withdrawn */
+# define YYSTYPE_IS_DECLARED 1
+# define YYSTYPE_IS_TRIVIAL 1
 #endif
 
 extern YYSTYPE llvmAsmlval;
 
 
-#endif /* not BISON_LLVMASMPARSER_TAB_H */
 


Index: llvm/lib/AsmParser/llvmAsmParser.y.cvs
diff -u llvm/lib/AsmParser/llvmAsmParser.y.cvs:1.58 llvm/lib/AsmParser/llvmAsmParser.y.cvs:1.59
--- llvm/lib/AsmParser/llvmAsmParser.y.cvs:1.58	Sun Jan 21 13:19:31 2007
+++ llvm/lib/AsmParser/llvmAsmParser.y.cvs	Fri Jan 26 02:05:27 2007
@@ -270,12 +270,12 @@
 
 static const Type *getTypeVal(const ValID &D, bool DoNotImprovise = false) {
   switch (D.Type) {
-  case ValID::NumberVal:               // Is it a numbered definition?
+  case ValID::LocalID:               // Is it a numbered definition?
     // Module constants occupy the lowest numbered slots...
-    if ((unsigned)D.Num < CurModule.Types.size())
-      return CurModule.Types[(unsigned)D.Num];
+    if (D.Num < CurModule.Types.size())
+      return CurModule.Types[D.Num];
     break;
-  case ValID::NameVal:                 // Is it a named definition?
+  case ValID::LocalName:                 // Is it a named definition?
     if (const Type *N = CurModule.CurrentModule->getTypeByName(D.Name)) {
       D.destroy();  // Free old strdup'd memory...
       return N;
@@ -294,11 +294,11 @@
 
 
   if (inFunctionScope()) {
-    if (D.Type == ValID::NameVal) {
+    if (D.Type == ValID::LocalName) {
       GenerateError("Reference to an undefined type: '" + D.getName() + "'");
       return 0;
     } else {
-      GenerateError("Reference to an undefined type: #" + itostr(D.Num));
+      GenerateError("Reference to an undefined type: #" + utostr(D.Num));
       return 0;
     }
   }
@@ -312,13 +312,6 @@
   return Typ;
  }
 
-static Value *lookupInSymbolTable(const Type *Ty, const std::string &Name) {
-  SymbolTable &SymTab =
-    inFunctionScope() ? CurFun.CurrentFunction->getValueSymbolTable() :
-                        CurModule.CurrentModule->getValueSymbolTable();
-  return SymTab.lookup(Ty, Name);
-}
-
 // getValNonImprovising - Look up the value specified by the provided type and
 // the provided ValID.  If the value exists and has already been defined, return
 // it.  Otherwise return null.
@@ -331,29 +324,39 @@
   }
 
   switch (D.Type) {
-  case ValID::NumberVal: {                 // Is it a numbered definition?
-    unsigned Num = (unsigned)D.Num;
-
-    // Module constants occupy the lowest numbered slots...
-    std::map::iterator VI = CurModule.Values.find(Ty);
-    if (VI != CurModule.Values.end()) {
-      if (Num < VI->second.size())
-        return VI->second[Num];
-      Num -= VI->second.size();
-    }
-
-    // Make sure that our type is within bounds
-    VI = CurFun.Values.find(Ty);
+  case ValID::LocalID: {                 // Is it a numbered definition?
+    // Module constants occupy the lowest numbered slots.
+    std::map::iterator VI = CurFun.Values.find(Ty);
+    // Make sure that our type is within bounds.
     if (VI == CurFun.Values.end()) return 0;
 
-    // Check that the number is within bounds...
-    if (VI->second.size() <= Num) return 0;
+    // Check that the number is within bounds.
+    if (D.Num >= VI->second.size()) return 0;
 
+    return VI->second[D.Num];
+  }
+  case ValID::GlobalID: {                 // Is it a numbered definition?
+    unsigned Num = D.Num;
+    
+    // Module constants occupy the lowest numbered slots...
+    std::map::iterator VI = CurModule.Values.find(Ty);
+    if (VI == CurModule.Values.end()) return 0;
+    if (D.Num >= VI->second.size()) return 0;
     return VI->second[Num];
   }
-
-  case ValID::NameVal: {                // Is it a named definition?
-    Value *N = lookupInSymbolTable(Ty, std::string(D.Name));
+    
+  case ValID::LocalName: {                // Is it a named definition?
+    if (!inFunctionScope()) return 0;
+    SymbolTable &SymTab = CurFun.CurrentFunction->getValueSymbolTable();
+    Value *N = SymTab.lookup(Ty, D.Name);
+    if (N == 0) return 0;
+    
+    D.destroy();  // Free old strdup'd memory...
+    return N;
+  }
+  case ValID::GlobalName: {                // Is it a named definition?
+    SymbolTable &SymTab = CurModule.CurrentModule->getValueSymbolTable();
+    Value *N = SymTab.lookup(Ty, D.Name);
     if (N == 0) return 0;
 
     D.destroy();  // Free old strdup'd memory...
@@ -488,12 +491,12 @@
   default: 
     GenerateError("Illegal label reference " + ID.getName());
     return 0;
-  case ValID::NumberVal:                // Is it a numbered definition?
-    if (unsigned(ID.Num) >= CurFun.NumberedBlocks.size())
+  case ValID::LocalID:                // Is it a numbered definition?
+    if (ID.Num >= CurFun.NumberedBlocks.size())
       CurFun.NumberedBlocks.resize(ID.Num+1);
     BB = CurFun.NumberedBlocks[ID.Num];
     break;
-  case ValID::NameVal:                  // Is it a named definition?
+  case ValID::LocalName:                  // Is it a named definition?
     Name = ID.Name;
     if (Value *N = CurFun.CurrentFunction->
                    getValueSymbolTable().lookup(Type::LabelTy, Name))
@@ -518,7 +521,7 @@
 
   // Otherwise this block has not been seen before.
   BB = new BasicBlock("", CurFun.CurrentFunction);
-  if (ID.Type == ValID::NameVal) {
+  if (ID.Type == ValID::LocalName) {
     BB->setName(ID.Name);
   } else {
     CurFun.NumberedBlocks[ID.Num] = BB;
@@ -585,7 +588,7 @@
         // resolver table
         InsertValue(V, *FutureLateResolvers);
       } else {
-        if (DID.Type == ValID::NameVal) {
+        if (DID.Type == ValID::LocalName || DID.Type == ValID::GlobalName) {
           GenerateError("Reference to an invalid definition: '" +DID.getName()+
                          "' of type '" + V->getType()->getDescription() + "'",
                          PHI->second.second);
@@ -610,8 +613,8 @@
 //
 static void ResolveTypeTo(char *Name, const Type *ToTy) {
   ValID D;
-  if (Name) D = ValID::create(Name);
-  else      D = ValID::create((int)CurModule.Types.size());
+  if (Name) D = ValID::createLocalName(Name);
+  else      D = ValID::createLocalID(CurModule.Types.size());
 
   std::map::iterator I =
     CurModule.LateResolveTypes.find(D);
@@ -626,26 +629,25 @@
 // assumed to be a malloc'd string buffer, and is free'd by this function.
 //
 static void setValueName(Value *V, char *NameStr) {
-  if (NameStr) {
-    std::string Name(NameStr);      // Copy string
-    free(NameStr);                  // Free old string
-
-    if (V->getType() == Type::VoidTy) {
-      GenerateError("Can't assign name '" + Name+"' to value with void type!");
-      return;
-    }
+  if (!NameStr) return;
+  std::string Name(NameStr);      // Copy string
+  free(NameStr);                  // Free old string
 
-    assert(inFunctionScope() && "Must be in function scope!");
-    SymbolTable &ST = CurFun.CurrentFunction->getValueSymbolTable();
-    if (ST.lookup(V->getType(), Name)) {
-      GenerateError("Redefinition of value '" + Name + "' of type '" +
-                     V->getType()->getDescription() + "'!");
-      return;
-    }
+  if (V->getType() == Type::VoidTy) {
+    GenerateError("Can't assign name '" + Name+"' to value with void type!");
+    return;
+  }
 
-    // Set the name.
-    V->setName(Name);
+  assert(inFunctionScope() && "Must be in function scope!");
+  SymbolTable &ST = CurFun.CurrentFunction->getValueSymbolTable();
+  if (ST.lookup(V->getType(), Name)) {
+    GenerateError("Redefinition of value '" + Name + "' of type '" +
+                   V->getType()->getDescription() + "'!");
+    return;
   }
+
+  // Set the name.
+  V->setName(Name);
 }
 
 /// ParseGlobalVariable - Handle parsing of a global.  If Initializer is null,
@@ -673,9 +675,9 @@
   // object.
   ValID ID;
   if (!Name.empty()) {
-    ID = ValID::create((char*)Name.c_str());
+    ID = ValID::createGlobalName((char*)Name.c_str());
   } else {
-    ID = ValID::create((int)CurModule.Values[PTy].size());
+    ID = ValID::createGlobalID(CurModule.Values[PTy].size());
   }
 
   if (GlobalValue *FWGV = CurModule.GetForwardRefForGlobal(PTy, ID)) {
@@ -922,7 +924,6 @@
   llvm::Instruction::MemoryOps      MemOpVal;
   llvm::Instruction::CastOps        CastOpVal;
   llvm::Instruction::OtherOps       OtherOpVal;
-  llvm::Module::Endianness          Endianness;
   llvm::ICmpInst::Predicate         IPredicate;
   llvm::FCmpInst::Predicate         FPredicate;
 }
@@ -949,7 +950,6 @@
 %type        GVInternalLinkage GVExternalLinkage
 %type        FunctionDefineLinkage FunctionDeclareLinkage
 %type     GVVisibilityStyle
-%type     BigOrLittle
 
 // ValueRef - Unresolved reference to a definition or BB
 %type       ValueRef ConstValueRef SymbolicValueRef
@@ -962,9 +962,7 @@
 // EUINT64VAL - A positive number within uns. long long range
 %token  EUINT64VAL
 
-%token     SINTVAL   // Signed 32 bit ints...
-%token     UINTVAL   // Unsigned 32 bit ints...
-%type      INTVAL
+%token     LOCALVAL_ID GLOBALVAL_ID  // %123 @123
 %token       FPVAL     // Float or Double constant
 
 // Built in types...
@@ -974,16 +972,17 @@
 %token  FLOAT DOUBLE LABEL
 %token TYPE
 
-%token  VAR_ID LABELSTR STRINGCONSTANT
-%type   Name OptName OptAssign
-%type   OptAlign OptCAlign
+%token LOCALVAR GLOBALVAR LABELSTR STRINGCONSTANT ATSTRINGCONSTANT
+%type  LocalName OptLocalName OptLocalAssign
+%type  GlobalName OptGlobalAssign
+%type  OptAlign OptCAlign
 %type  OptSection SectionString
 
 %token IMPLEMENTATION ZEROINITIALIZER TRUETOK FALSETOK BEGINTOK ENDTOK
 %token DECLARE DEFINE GLOBAL CONSTANT SECTION VOLATILE
 %token TO DOTDOTDOT NULL_TOK UNDEF INTERNAL LINKONCE WEAK APPENDING
 %token DLLIMPORT DLLEXPORT EXTERN_WEAK
-%token OPAQUE EXTERNAL TARGET TRIPLE ENDIAN POINTERSIZE LITTLE BIG ALIGN
+%token OPAQUE EXTERNAL TARGET TRIPLE ALIGN
 %token DEPLIBS CALL TAIL ASM_TOK MODULE SIDEEFFECT
 %token CC_TOK CCC_TOK CSRETCC_TOK FASTCC_TOK COLDCC_TOK
 %token X86_STDCALLCC_TOK X86_FASTCALLCC_TOK
@@ -1026,15 +1025,6 @@
 %start Module
 %%
 
-// Handle constant integer size restriction and conversion...
-//
-INTVAL : SINTVAL;
-INTVAL : UINTVAL {
-  if ($1 > (uint32_t)INT32_MAX)     // Outside of my range!
-    GEN_ERROR("Value too large for type!");
-  $$ = (int32_t)$1;
-  CHECK_FOR_ERROR
-};
 
 // Operations that are notably excluded from this list include:
 // RET, BR, & SWITCH because they end basic blocks and are treated specially.
@@ -1069,8 +1059,23 @@
 IntType :  INTTYPE;
 FPType   : FLOAT | DOUBLE;
 
-// OptAssign - Value producing statements have an optional assignment component
-OptAssign : Name '=' {
+LocalName : LOCALVAR | STRINGCONSTANT;
+OptLocalName : LocalName | /*empty*/ { $$ = 0; };
+
+/// OptLocalAssign - Value producing statements have an optional assignment
+/// component.
+OptLocalAssign : LocalName '=' {
+    $$ = $1;
+    CHECK_FOR_ERROR
+  }
+  | /*empty*/ {
+    $$ = 0;
+    CHECK_FOR_ERROR
+  };
+
+GlobalName : GLOBALVAR | ATSTRINGCONSTANT;
+
+OptGlobalAssign : GlobalName '=' {
     $$ = $1;
     CHECK_FOR_ERROR
   }
@@ -1630,7 +1635,10 @@
         $2.destroy();
       } else {
         std::string Name;
-        if ($2.Type == ValID::NameVal) Name = $2.Name;
+        if ($2.Type == ValID::GlobalName)
+          Name = $2.Name;
+        else if ($2.Type != ValID::GlobalID)
+          GEN_ERROR("Invalid reference to global");
 
         // Create the forward referenced global.
         GlobalValue *GV;
@@ -1857,7 +1865,7 @@
     // Emit an error if there are any unresolved types left.
     if (!CurModule.LateResolveTypes.empty()) {
       const ValID &DID = CurModule.LateResolveTypes.begin()->first;
-      if (DID.Type == ValID::NameVal) {
+      if (DID.Type == ValID::LocalName) {
         GEN_ERROR("Reference to an undefined type: '"+DID.getName() + "'");
       } else {
         GEN_ERROR("Reference to an undefined type: #" + itostr(DID.Num));
@@ -1865,7 +1873,7 @@
     }
     CHECK_FOR_ERROR
   }
-  | OptAssign TYPE Types {
+  | OptLocalAssign TYPE Types {
     if (!UpRefs.empty())
       GEN_ERROR("Invalid upreference in type: " + (*$3)->getDescription());
     // Eagerly resolve types.  This is not an optimization, this is a
@@ -1889,7 +1897,7 @@
     delete $3;
     CHECK_FOR_ERROR
   }
-  | OptAssign TYPE VOID {
+  | OptLocalAssign TYPE VOID {
     ResolveTypeTo($1, $3);
 
     if (!setTypeName($3, $1) && !$1) {
@@ -1900,7 +1908,8 @@
     }
     CHECK_FOR_ERROR
   }
-  | OptAssign GVVisibilityStyle GlobalType ConstVal { /* "Externally Visible" Linkage */
+  | OptGlobalAssign GVVisibilityStyle GlobalType ConstVal { 
+    /* "Externally Visible" Linkage */
     if ($4 == 0) 
       GEN_ERROR("Global value initializer is not a constant!");
     CurGV = ParseGlobalVariable($1, GlobalValue::ExternalLinkage,
@@ -1909,7 +1918,7 @@
   } GlobalVarAttributes {
     CurGV = 0;
   }
-  | OptAssign GVInternalLinkage GVVisibilityStyle GlobalType ConstVal {
+  | OptGlobalAssign GVInternalLinkage GVVisibilityStyle GlobalType ConstVal {
     if ($5 == 0) 
       GEN_ERROR("Global value initializer is not a constant!");
     CurGV = ParseGlobalVariable($1, $2, $3, $4, $5->getType(), $5);
@@ -1917,7 +1926,7 @@
   } GlobalVarAttributes {
     CurGV = 0;
   }
-  | OptAssign GVExternalLinkage GVVisibilityStyle GlobalType Types {
+  | OptGlobalAssign GVExternalLinkage GVVisibilityStyle GlobalType Types {
     if (!UpRefs.empty())
       GEN_ERROR("Invalid upreference in type: " + (*$5)->getDescription());
     CurGV = ParseGlobalVariable($1, $2, $3, $4, *$5, 0);
@@ -1949,23 +1958,7 @@
   CHECK_FOR_ERROR
 };
 
-BigOrLittle : BIG    { $$ = Module::BigEndian; };
-BigOrLittle : LITTLE { $$ = Module::LittleEndian; };
-
-TargetDefinition : ENDIAN '=' BigOrLittle {
-    CurModule.CurrentModule->setEndianness($3);
-    CHECK_FOR_ERROR
-  }
-  | POINTERSIZE '=' EUINT64VAL {
-    if ($3 == 32)
-      CurModule.CurrentModule->setPointerSize(Module::Pointer32);
-    else if ($3 == 64)
-      CurModule.CurrentModule->setPointerSize(Module::Pointer64);
-    else
-      GEN_ERROR("Invalid pointer size: '" + utostr($3) + "'!");
-    CHECK_FOR_ERROR
-  }
-  | TRIPLE '=' STRINGCONSTANT {
+TargetDefinition : TRIPLE '=' STRINGCONSTANT {
     CurModule.CurrentModule->setTargetTriple($3);
     free($3);
   }
@@ -1995,10 +1988,7 @@
 //                       Rules to match Function Headers
 //===----------------------------------------------------------------------===//
 
-Name : VAR_ID | STRINGCONSTANT;
-OptName : Name | /*empty*/ { $$ = 0; };
-
-ArgListH : ArgListH ',' Types OptParamAttrs OptName {
+ArgListH : ArgListH ',' Types OptParamAttrs OptLocalName {
     if (!UpRefs.empty())
       GEN_ERROR("Invalid upreference in type: " + (*$3)->getDescription());
     if (*$3 == Type::VoidTy)
@@ -2008,7 +1998,7 @@
     $1->push_back(E);
     CHECK_FOR_ERROR
   }
-  | Types OptParamAttrs OptName {
+  | Types OptParamAttrs OptLocalName {
     if (!UpRefs.empty())
       GEN_ERROR("Invalid upreference in type: " + (*$1)->getDescription());
     if (*$1 == Type::VoidTy)
@@ -2046,7 +2036,7 @@
     CHECK_FOR_ERROR
   };
 
-FunctionHeaderH : OptCallingConv ResultTypes Name '(' ArgList ')' 
+FunctionHeaderH : OptCallingConv ResultTypes GlobalName '(' ArgList ')' 
                   OptFuncAttrs OptSection OptAlign {
   UnEscapeLexed($3);
   std::string FunctionName($3);
@@ -2081,9 +2071,9 @@
 
   ValID ID;
   if (!FunctionName.empty()) {
-    ID = ValID::create((char*)FunctionName.c_str());
+    ID = ValID::createGlobalName((char*)FunctionName.c_str());
   } else {
-    ID = ValID::create((int)CurModule.Values[PFT].size());
+    ID = ValID::createGlobalID(CurModule.Values[PFT].size());
   }
 
   Function *Fn = 0;
@@ -2266,12 +2256,20 @@
 // SymbolicValueRef - Reference to one of two ways of symbolically refering to
 // another value.
 //
-SymbolicValueRef : INTVAL {  // Is it an integer reference...?
-    $$ = ValID::create($1);
+SymbolicValueRef : LOCALVAL_ID {  // Is it an integer reference...?
+    $$ = ValID::createLocalID($1);
     CHECK_FOR_ERROR
   }
-  | Name {                   // Is it a named reference...?
-    $$ = ValID::create($1);
+  | GLOBALVAL_ID {
+    $$ = ValID::createGlobalID($1);
+    CHECK_FOR_ERROR
+  }
+  | LocalName {                   // Is it a named reference...?
+    $$ = ValID::createLocalName($1);
+    CHECK_FOR_ERROR
+  }
+  | GlobalName {                   // Is it a named reference...?
+    $$ = ValID::createGlobalName($1);
     CHECK_FOR_ERROR
   };
 
@@ -2304,7 +2302,7 @@
 // Basic blocks are terminated by branching instructions: 
 // br, br/cc, switch, ret
 //
-BasicBlock : InstructionList OptAssign BBTerminatorInst  {
+BasicBlock : InstructionList OptLocalAssign BBTerminatorInst  {
     setValueName($3, $2);
     CHECK_FOR_ERROR
     InsertValue($3);
@@ -2325,7 +2323,7 @@
     CHECK_FOR_ERROR
   }
   | /* empty */ {
-    $$ = getBBVal(ValID::create((int)CurFun.NextBBNum++), true);
+    $$ = getBBVal(ValID::createLocalID(CurFun.NextBBNum++), true);
     CHECK_FOR_ERROR
 
     // Make sure to move the basic block to the correct location in the
@@ -2337,7 +2335,7 @@
     CHECK_FOR_ERROR
   }
   | LABELSTR {
-    $$ = getBBVal(ValID::create($1), true);
+    $$ = getBBVal(ValID::createLocalName($1), true);
     CHECK_FOR_ERROR
 
     // Make sure to move the basic block to the correct location in the
@@ -2502,7 +2500,7 @@
     $$->push_back(std::make_pair(V, tmpBB)); 
   };
 
-Inst : OptAssign InstVal {
+Inst : OptLocalAssign InstVal {
   // Is this definition named?? if so, assign the name...
   setValueName($2, $1);
   CHECK_FOR_ERROR
@@ -2762,6 +2760,7 @@
     CI->setCallingConv($2);
     $$ = CI;
     delete $6;
+    delete $3;
     CHECK_FOR_ERROR
   }
   | MemoryInst {





From reid at x10sys.com  Fri Jan 26 02:07:19 2007
From: reid at x10sys.com (Reid Spencer)
Date: Fri, 26 Jan 2007 02:07:19 -0600
Subject: [llvm-commits] CVS: llvm/include/llvm/Module.h
Message-ID: <200701260807.l0Q87JXB022927@zion.cs.uiuc.edu>



Changes in directory llvm/include/llvm:

Module.h updated: 1.79 -> 1.80
---
Log message:

For PR761: http://llvm.org/PR761 :
Remove the setEndiannes and setPointerSize methods. These are now set
through the setDataLayout method.


---
Diffs of the changes:  (+2 -8)

 Module.h |   10 ++--------
 1 files changed, 2 insertions(+), 8 deletions(-)


Index: llvm/include/llvm/Module.h
diff -u llvm/include/llvm/Module.h:1.79 llvm/include/llvm/Module.h:1.80
--- llvm/include/llvm/Module.h:1.79	Sun Jan  7 02:09:25 2007
+++ llvm/include/llvm/Module.h	Fri Jan 26 02:07:01 2007
@@ -121,7 +121,7 @@
   /// Get the data layout string for the module's target platform.  This encodes
   /// the type sizes and alignments expected by this module.
   /// @returns the data layout as a string
-  std::string getDataLayout() const { return DataLayout; }
+  const std::string& getDataLayout() const { return DataLayout; }
 
   /// Get the target triple which is a string describing the target host.
   /// @returns a string containing the target triple.
@@ -147,17 +147,11 @@
   void setModuleIdentifier(const std::string &ID) { ModuleID = ID; }
 
   /// Set the data layout
-  void setDataLayout(std::string DL) { DataLayout = DL; }
+  void setDataLayout(const std::string& DL) { DataLayout = DL; }
 
   /// Set the target triple.
   void setTargetTriple(const std::string &T) { TargetTriple = T; }
 
-  /// Set the target endian information.
-  void setEndianness(Endianness E);
-
-  /// Set the target pointer size.
-  void setPointerSize(PointerSize PS);
-
   /// Set the module-scope inline assembly blocks.
   void setModuleInlineAsm(const std::string &Asm) { GlobalScopeAsm = Asm; }
   





From reid at x10sys.com  Fri Jan 26 02:08:14 2007
From: reid at x10sys.com (Reid Spencer)
Date: Fri, 26 Jan 2007 02:08:14 -0600
Subject: [llvm-commits] CVS: llvm/lib/VMCore/Module.cpp
Message-ID: <200701260808.l0Q88EWT023307@zion.cs.uiuc.edu>



Changes in directory llvm/lib/VMCore:

Module.cpp updated: 1.72 -> 1.73
---
Log message:

For PR761: http://llvm.org/PR761 :
Remove the setEndianess and setPointerSize methods. These are now 
handled via the setDataLayout method.


---
Diffs of the changes:  (+0 -20)

 Module.cpp |   20 --------------------
 1 files changed, 20 deletions(-)


Index: llvm/lib/VMCore/Module.cpp
diff -u llvm/lib/VMCore/Module.cpp:1.72 llvm/lib/VMCore/Module.cpp:1.73
--- llvm/lib/VMCore/Module.cpp:1.72	Sun Jan  7 02:09:25 2007
+++ llvm/lib/VMCore/Module.cpp	Fri Jan 26 02:07:57 2007
@@ -107,16 +107,6 @@
   return ret;
 }
 
-void Module::setEndianness(Endianness E) {
-  if (!DataLayout.empty() && E != AnyEndianness)
-    DataLayout += "-";
-  
-  if (E == LittleEndian)
-    DataLayout += "e";
-  else if (E == BigEndian)
-    DataLayout += "E";
-}
-
 /// Target Pointer Size information...
 Module::PointerSize Module::getPointerSize() const {
   std::string temp = DataLayout;
@@ -138,16 +128,6 @@
   return ret;
 }
 
-void Module::setPointerSize(PointerSize PS) {
-  if (!DataLayout.empty() && PS != AnyPointerSize)
-    DataLayout += "-";
-  
-  if (PS == Pointer32)
-    DataLayout += "p:32:32";
-  else if (PS == Pointer64)
-    DataLayout += "p:64:64";
-}
-
 //===----------------------------------------------------------------------===//
 // Methods for easy access to the functions in the module.
 //





From reid at x10sys.com  Fri Jan 26 02:09:18 2007
From: reid at x10sys.com (Reid Spencer)
Date: Fri, 26 Jan 2007 02:09:18 -0600
Subject: [llvm-commits] CVS: llvm/include/llvm/Bytecode/BytecodeHandler.h
Message-ID: <200701260809.l0Q89IOr023892@zion.cs.uiuc.edu>



Changes in directory llvm/include/llvm/Bytecode:

BytecodeHandler.h updated: 1.10 -> 1.11
---
Log message:

For PR761: http://llvm.org/PR761 :
BCReader no longer has a header that contains the endinanness and 
pointer size. It's been replaced by datalayout field.


---
Diffs of the changes:  (+1 -3)

 BytecodeHandler.h |    4 +---
 1 files changed, 1 insertion(+), 3 deletions(-)


Index: llvm/include/llvm/Bytecode/BytecodeHandler.h
diff -u llvm/include/llvm/Bytecode/BytecodeHandler.h:1.10 llvm/include/llvm/Bytecode/BytecodeHandler.h:1.11
--- llvm/include/llvm/Bytecode/BytecodeHandler.h:1.10	Fri Jan 12 13:20:46 2007
+++ llvm/include/llvm/Bytecode/BytecodeHandler.h	Fri Jan 26 02:09:01 2007
@@ -96,9 +96,7 @@
   /// read.
   /// @brief Handle the bytecode prolog
   virtual void handleVersionInfo(
-    unsigned char RevisionNum,        ///< Byte code revision number
-    Module::Endianness Endianness,    ///< Endianness indicator
-    Module::PointerSize PointerSize   ///< PointerSize indicator
+    unsigned char RevisionNum        ///< Byte code revision number
   ) {}
 
   /// This method is called at the start of a module globals block which





From reid at x10sys.com  Fri Jan 26 02:10:42 2007
From: reid at x10sys.com (Reid Spencer)
Date: Fri, 26 Jan 2007 02:10:42 -0600
Subject: [llvm-commits] CVS: llvm/lib/Bytecode/Writer/Writer.cpp
Message-ID: <200701260810.l0Q8Agmh024687@zion.cs.uiuc.edu>



Changes in directory llvm/lib/Bytecode/Writer:

Writer.cpp updated: 1.152 -> 1.153
---
Log message:

For PR761: http://llvm.org/PR761 :
Remove the Endianness and PointerSize fields from the ModuleHeader and
replace it with the DataLayout field.


---
Diffs of the changes:  (+5 -11)

 Writer.cpp |   16 +++++-----------
 1 files changed, 5 insertions(+), 11 deletions(-)


Index: llvm/lib/Bytecode/Writer/Writer.cpp
diff -u llvm/lib/Bytecode/Writer/Writer.cpp:1.152 llvm/lib/Bytecode/Writer/Writer.cpp:1.153
--- llvm/lib/Bytecode/Writer/Writer.cpp:1.152	Thu Jan 18 18:07:16 2007
+++ llvm/lib/Bytecode/Writer/Writer.cpp	Fri Jan 26 02:10:24 2007
@@ -813,17 +813,8 @@
   // Emit the top level CLASS block.
   BytecodeBlock ModuleBlock(BytecodeFormat::ModuleBlockID, *this, false, true);
 
-  bool isBigEndian      = M->getEndianness() == Module::BigEndian;
-  bool hasLongPointers  = M->getPointerSize() == Module::Pointer64;
-  bool hasNoEndianness  = M->getEndianness() == Module::AnyEndianness;
-  bool hasNoPointerSize = M->getPointerSize() == Module::AnyPointerSize;
-
-  // Output the version identifier and other information.
-  unsigned Version = (BCVersionNum << 4) |
-                     (unsigned)isBigEndian | (hasLongPointers << 1) |
-                     (hasNoEndianness << 2) |
-                     (hasNoPointerSize << 3);
-  output_vbr(Version);
+  // Output the version identifier
+  output_vbr(BCVersionNum);
 
   // The Global type plane comes first
   {
@@ -1090,6 +1081,9 @@
 
   // Output the target triple from the module
   output(M->getTargetTriple());
+
+  // Output the data layout from the module
+  output(M->getDataLayout());
   
   // Emit the table of section names.
   output_vbr((unsigned)SectionNames.size());





From reid at x10sys.com  Fri Jan 26 02:10:42 2007
From: reid at x10sys.com (Reid Spencer)
Date: Fri, 26 Jan 2007 02:10:42 -0600
Subject: [llvm-commits] CVS: llvm/lib/Bytecode/Reader/Analyzer.cpp Reader.cpp
Message-ID: <200701260810.l0Q8AgTW024689@zion.cs.uiuc.edu>



Changes in directory llvm/lib/Bytecode/Reader:

Analyzer.cpp updated: 1.28 -> 1.29
Reader.cpp updated: 1.224 -> 1.225
---
Log message:

For PR761: http://llvm.org/PR761 :
Remove the Endianness and PointerSize fields from the ModuleHeader and
replace it with the DataLayout field.


---
Diffs of the changes:  (+11 -25)

 Analyzer.cpp |    8 ++------
 Reader.cpp   |   28 +++++++++-------------------
 2 files changed, 11 insertions(+), 25 deletions(-)


Index: llvm/lib/Bytecode/Reader/Analyzer.cpp
diff -u llvm/lib/Bytecode/Reader/Analyzer.cpp:1.28 llvm/lib/Bytecode/Reader/Analyzer.cpp:1.29
--- llvm/lib/Bytecode/Reader/Analyzer.cpp:1.28	Fri Jan 12 13:20:46 2007
+++ llvm/lib/Bytecode/Reader/Analyzer.cpp	Fri Jan 26 02:10:24 2007
@@ -142,14 +142,10 @@
   }
 
   virtual void handleVersionInfo(
-    unsigned char RevisionNum,        ///< Byte code revision number
-    Module::Endianness Endianness,    ///< Endianness indicator
-    Module::PointerSize PointerSize   ///< PointerSize indicator
+    unsigned char RevisionNum        ///< Byte code revision number
   ) {
     if (os)
-      *os << "    RevisionNum: " << int(RevisionNum)
-         << " Endianness: " << Endianness
-         << " PointerSize: " << PointerSize << "\n";
+      *os << "    RevisionNum: " << int(RevisionNum) << "\n";
     bca.version = RevisionNum;
   }
 


Index: llvm/lib/Bytecode/Reader/Reader.cpp
diff -u llvm/lib/Bytecode/Reader/Reader.cpp:1.224 llvm/lib/Bytecode/Reader/Reader.cpp:1.225
--- llvm/lib/Bytecode/Reader/Reader.cpp:1.224	Thu Jan 18 18:07:16 2007
+++ llvm/lib/Bytecode/Reader/Reader.cpp	Fri Jan 26 02:10:24 2007
@@ -2014,6 +2014,13 @@
   if (Handler)
     Handler->handleTargetTriple(triple);
   
+  // Read the data layout string and place into the module.
+  std::string datalayout = read_str();
+  TheModule->setDataLayout(datalayout);
+  // FIXME: Implement
+  // if (Handler)
+    // Handler->handleDataLayout(datalayout);
+
   if (At != BlockEnd) {
     // If the file has section info in it, read the section names now.
     unsigned NumSections = read_vbr_uint();
@@ -2045,31 +2052,14 @@
 /// Parse the version information and decode it by setting flags on the
 /// Reader that enable backward compatibility of the reader.
 void BytecodeReader::ParseVersionInfo() {
-  unsigned Version = read_vbr_uint();
-
-  // Unpack version number: low four bits are for flags, top bits = version
-  Module::Endianness  Endianness;
-  Module::PointerSize PointerSize;
-  Endianness  = (Version & 1) ? Module::BigEndian : Module::LittleEndian;
-  PointerSize = (Version & 2) ? Module::Pointer64 : Module::Pointer32;
-
-  bool hasNoEndianness = Version & 4;
-  bool hasNoPointerSize = Version & 8;
-
-  RevisionNum = Version >> 4;
+  unsigned RevisionNum = read_vbr_uint();
 
   // We don't provide backwards compatibility in the Reader any more. To
   // upgrade, the user should use llvm-upgrade.
   if (RevisionNum < 7)
     error("Bytecode formats < 7 are no longer supported. Use llvm-upgrade.");
 
-  if (hasNoEndianness) Endianness  = Module::AnyEndianness;
-  if (hasNoPointerSize) PointerSize = Module::AnyPointerSize;
-
-  TheModule->setEndianness(Endianness);
-  TheModule->setPointerSize(PointerSize);
-
-  if (Handler) Handler->handleVersionInfo(RevisionNum, Endianness, PointerSize);
+  if (Handler) Handler->handleVersionInfo(RevisionNum);
 }
 
 /// Parse a whole module.





From reid at x10sys.com  Fri Jan 26 02:11:59 2007
From: reid at x10sys.com (Reid Spencer)
Date: Fri, 26 Jan 2007 02:11:59 -0600
Subject: [llvm-commits] CVS: llvm/lib/Transforms/Utils/CloneModule.cpp
Message-ID: <200701260811.l0Q8BxV9025541@zion.cs.uiuc.edu>



Changes in directory llvm/lib/Transforms/Utils:

CloneModule.cpp updated: 1.19 -> 1.20
---
Log message:

For PR761: http://llvm.org/PR761 :
The Module::setEndianness and Module::setPointerSize methods have been
removed. Instead you can get/set the DataLayout. Adjust thise accordingly.


---
Diffs of the changes:  (+1 -2)

 CloneModule.cpp |    3 +--
 1 files changed, 1 insertion(+), 2 deletions(-)


Index: llvm/lib/Transforms/Utils/CloneModule.cpp
diff -u llvm/lib/Transforms/Utils/CloneModule.cpp:1.19 llvm/lib/Transforms/Utils/CloneModule.cpp:1.20
--- llvm/lib/Transforms/Utils/CloneModule.cpp:1.19	Sat Jan  6 01:24:44 2007
+++ llvm/lib/Transforms/Utils/CloneModule.cpp	Fri Jan 26 02:11:39 2007
@@ -37,8 +37,7 @@
 Module *llvm::CloneModule(const Module *M, std::map &ValueMap) {
   // First off, we need to create the new module...
   Module *New = new Module(M->getModuleIdentifier());
-  New->setEndianness(M->getEndianness());
-  New->setPointerSize(M->getPointerSize());
+  New->setDataLayout(M->getDataLayout());
   New->setTargetTriple(M->getTargetTriple());
   New->setModuleInlineAsm(M->getModuleInlineAsm());
 





From reid at x10sys.com  Fri Jan 26 02:12:04 2007
From: reid at x10sys.com (Reid Spencer)
Date: Fri, 26 Jan 2007 02:12:04 -0600
Subject: [llvm-commits] CVS: llvm/lib/Linker/LinkModules.cpp
Message-ID: <200701260812.l0Q8C4lM025585@zion.cs.uiuc.edu>



Changes in directory llvm/lib/Linker:

LinkModules.cpp updated: 1.126 -> 1.127
---
Log message:

For PR761: http://llvm.org/PR761 :
The Module::setEndianness and Module::setPointerSize methods have been
removed. Instead you can get/set the DataLayout. Adjust thise accordingly.


---
Diffs of the changes:  (+14 -8)

 LinkModules.cpp |   22 ++++++++++++++--------
 1 files changed, 14 insertions(+), 8 deletions(-)


Index: llvm/lib/Linker/LinkModules.cpp
diff -u llvm/lib/Linker/LinkModules.cpp:1.126 llvm/lib/Linker/LinkModules.cpp:1.127
--- llvm/lib/Linker/LinkModules.cpp:1.126	Fri Jan 12 01:05:13 2007
+++ llvm/lib/Linker/LinkModules.cpp	Fri Jan 26 02:11:39 2007
@@ -849,19 +849,25 @@
   assert(Dest != 0 && "Invalid Destination module");
   assert(Src  != 0 && "Invalid Source Module");
 
+  std::string DataLayout;
+
   if (Dest->getEndianness() == Module::AnyEndianness)
-    Dest->setEndianness(Src->getEndianness());
+    if (Src->getEndianness() == Module::BigEndian)
+      DataLayout.append("E");
+    else if (Src->getEndianness() == Module::LittleEndian)
+      DataLayout.append("e");
   if (Dest->getPointerSize() == Module::AnyPointerSize)
-    Dest->setPointerSize(Src->getPointerSize());
+    if (Src->getPointerSize() == Module::Pointer64)
+      DataLayout.append(DataLayout.length() == 0 ? "p:64:64" : "-p:64:64");
+    else if (Src->getPointerSize() == Module::Pointer32)
+      DataLayout.append(DataLayout.length() == 0 ? "p:32:32" : "-p:32:32");
   if (Dest->getTargetTriple().empty())
     Dest->setTargetTriple(Src->getTargetTriple());
+  Dest->setDataLayout(DataLayout);
 
-  if (Src->getEndianness() != Module::AnyEndianness &&
-      Dest->getEndianness() != Src->getEndianness())
-    cerr << "WARNING: Linking two modules of different endianness!\n";
-  if (Src->getPointerSize() != Module::AnyPointerSize &&
-      Dest->getPointerSize() != Src->getPointerSize())
-    cerr << "WARNING: Linking two modules of different pointer size!\n";
+  if (Src->getDataLayout().length() > 0 && Dest->getDataLayout().length() > 0 &&
+      Src->getDataLayout().compare(Dest->getDataLayout()) != 0)
+    cerr << "WARNING: Linking two modules of different data layouts!\n";
   if (!Src->getTargetTriple().empty() &&
       Dest->getTargetTriple() != Src->getTargetTriple())
     cerr << "WARNING: Linking two modules of different target triples!\n";





From reid at x10sys.com  Fri Jan 26 02:12:04 2007
From: reid at x10sys.com (Reid Spencer)
Date: Fri, 26 Jan 2007 02:12:04 -0600
Subject: [llvm-commits] CVS:
	llvm/lib/ExecutionEngine/Interpreter/Interpreter.cpp
Message-ID: <200701260812.l0Q8C4A8025589@zion.cs.uiuc.edu>



Changes in directory llvm/lib/ExecutionEngine/Interpreter:

Interpreter.cpp updated: 1.33 -> 1.34
---
Log message:

For PR761: http://llvm.org/PR761 :
The Module::setEndianness and Module::setPointerSize methods have been
removed. Instead you can get/set the DataLayout. Adjust thise accordingly.


---
Diffs of the changes:  (+11 -12)

 Interpreter.cpp |   23 +++++++++++------------
 1 files changed, 11 insertions(+), 12 deletions(-)


Index: llvm/lib/ExecutionEngine/Interpreter/Interpreter.cpp
diff -u llvm/lib/ExecutionEngine/Interpreter/Interpreter.cpp:1.33 llvm/lib/ExecutionEngine/Interpreter/Interpreter.cpp:1.34
--- llvm/lib/ExecutionEngine/Interpreter/Interpreter.cpp:1.33	Wed Nov 15 12:00:10 2006
+++ llvm/lib/ExecutionEngine/Interpreter/Interpreter.cpp	Fri Jan 26 02:11:39 2007
@@ -39,18 +39,17 @@
     return 0;  // error materializing the module.
   }
   
-  if (M->getEndianness() == Module::AnyEndianness) {
-    int Test = 0;
-    *(char*)&Test = 1;    // Return true if the host is little endian
-    bool isLittleEndian = (Test == 1);
-    M->setEndianness(isLittleEndian ? Module::LittleEndian : Module::BigEndian);
-  }
-
-  if (M->getPointerSize() == Module::AnyPointerSize) {
-    // Follow host.
-    bool Ptr64 = sizeof(void*) == 8;
-    M->setPointerSize(Ptr64 ? Module::Pointer64 : Module::Pointer32);
-  }
+  // FIXME: This should probably compute the entire data layout
+  std::string DataLayout;
+  int Test = 0;
+  *(char*)&Test = 1;    // Return true if the host is little endian
+  bool isLittleEndian = (Test == 1);
+  DataLayout.append(isLittleEndian ? "e" : "E");
+
+	bool Ptr64 = sizeof(void*) == 8;
+	DataLayout.append(Ptr64 ? "-p:64:64" : "-p:32:32");
+	
+  M->setDataLayout(DataLayout);
 
   return new Interpreter(M);
 }





From reid at x10sys.com  Fri Jan 26 02:12:04 2007
From: reid at x10sys.com (Reid Spencer)
Date: Fri, 26 Jan 2007 02:12:04 -0600
Subject: [llvm-commits] CVS: llvm/lib/Target/TargetData.cpp
Message-ID: <200701260812.l0Q8C4l8025601@zion.cs.uiuc.edu>



Changes in directory llvm/lib/Target:

TargetData.cpp updated: 1.82 -> 1.83
---
Log message:

For PR761: http://llvm.org/PR761 :
The Module::setEndianness and Module::setPointerSize methods have been
removed. Instead you can get/set the DataLayout. Adjust thise accordingly.


---
Diffs of the changes:  (+3 -21)

 TargetData.cpp |   24 +++---------------------
 1 files changed, 3 insertions(+), 21 deletions(-)


Index: llvm/lib/Target/TargetData.cpp
diff -u llvm/lib/Target/TargetData.cpp:1.82 llvm/lib/Target/TargetData.cpp:1.83
--- llvm/lib/Target/TargetData.cpp:1.82	Wed Jan 24 01:03:39 2007
+++ llvm/lib/Target/TargetData.cpp	Fri Jan 26 02:11:39 2007
@@ -189,8 +189,8 @@
     }
   }
 
-  // Unless explicitly specified, the alignments for longs and doubles is capped by 
-  // pointer size.
+  // Unless explicitly specified, the alignments for longs and doubles is 
+  // capped by pointer size.
   if (LongABIAlignment == 0)
 	  LongABIAlignment = LongPrefAlignment = PointerMemSize;
   if (DoubleABIAlignment == 0)
@@ -198,25 +198,7 @@
 }
 
 TargetData::TargetData(const Module *M) {
-  LittleEndian       = M->getEndianness() != Module::BigEndian;
-  PointerMemSize     = M->getPointerSize() != Module::Pointer64 ? 4 : 8;
-  PointerABIAlignment = PointerMemSize;
-  DoubleABIAlignment  = PointerMemSize;
-  FloatABIAlignment   = 4;
-  LongABIAlignment    = PointerMemSize;
-  IntABIAlignment     = 4;
-  ShortABIAlignment   = 2;
-  ByteABIAlignment    = 1;
-  BoolABIAlignment    = 1;
-  BoolPrefAlignment = BoolABIAlignment;
-  BytePrefAlignment = ByteABIAlignment;
-  ShortPrefAlignment = ShortABIAlignment;
-  IntPrefAlignment = IntABIAlignment;
-  LongPrefAlignment = LongABIAlignment;
-  FloatPrefAlignment = FloatABIAlignment;
-  DoublePrefAlignment = DoubleABIAlignment;
-  PointerPrefAlignment = PointerABIAlignment;
-  AggMinPrefAlignment = 0;
+  init(M->getDataLayout());
 }
 
 /// Layouts - The lazy cache of structure layout information maintained by





From reid at x10sys.com  Fri Jan 26 02:18:51 2007
From: reid at x10sys.com (Reid Spencer)
Date: Fri, 26 Jan 2007 02:18:51 -0600
Subject: [llvm-commits] CVS: llvm/tools/llvm-upgrade/UpgradeLexer.l
	UpgradeParser.y UpgradeInternals.h
Message-ID: <200701260818.l0Q8Ip3T030750@zion.cs.uiuc.edu>



Changes in directory llvm/tools/llvm-upgrade:

UpgradeLexer.l updated: 1.16 -> 1.17
UpgradeParser.y updated: 1.43 -> 1.44
UpgradeInternals.h updated: 1.4 -> 1.5
---
Log message:

For All These Bugs:
PR645: http://llvm.org/PR645 
PR761: http://llvm.org/PR761 
PR1082: http://llvm.org/PR1082 
PR1122: http://llvm.org/PR1122 

Completely rewrite llvm-upgrade. This should be its final design. Any future
changes will use this same design.  The changes involve the following:

1. Make this work very much like the 1.9 AsmParser
2. Retain old upgrades dating back to release 1.2 time frame.
3. Merge in some of the upgrades between 1.9 and 2.0 (e.g. icmp/fcmp).
4. Attach a Signedness value (Signless, Unsigned, Signed) to every type,
   Value, Constant, Instruction, and list of those things in the Parser.
   Use these to make signedness decisions for instruction upgrades.
5. Implement unique name upgrade for function values and global values.
6. Identify rename cases that might cause problems and warn about them.
   For example: renaming a global variable with external linkage.
7. Generate a 2.0 IR using VMCore. This is necessary for numerous 
   reasons and has the advantage that it never goes out of date.
8. Use the AsmPrinter to make the output nice.
9. Clean up error and warning messages from 1.9 form.




---
Diffs of the changes:  (+3485 -1974)

 UpgradeInternals.h |  302 ++-
 UpgradeLexer.l     |  479 +++--
 UpgradeParser.y    | 4678 +++++++++++++++++++++++++++++++++--------------------
 3 files changed, 3485 insertions(+), 1974 deletions(-)


Index: llvm/tools/llvm-upgrade/UpgradeLexer.l
diff -u llvm/tools/llvm-upgrade/UpgradeLexer.l:1.16 llvm/tools/llvm-upgrade/UpgradeLexer.l:1.17
--- llvm/tools/llvm-upgrade/UpgradeLexer.l:1.16	Sun Jan 14 20:40:33 2007
+++ llvm/tools/llvm-upgrade/UpgradeLexer.l	Fri Jan 26 02:18:33 2007
@@ -25,8 +25,9 @@
 %option noyymore
 
 %{
-
 #include "UpgradeInternals.h"
+#include "llvm/Module.h"
+#include 
 #include "UpgradeParser.h"
 #include 
 #include 
@@ -41,17 +42,108 @@
   } \
 }
 
+#define YY_NEVER_INTERACTIVE 1
 
 // Construct a token value for a non-obsolete token
-#define RET_TOK(sym) \
-  Upgradelval.String = new std::string(yytext); \
+#define RET_TOK(type, Enum, sym) \
+  Upgradelval.type = Enum; \
   return sym
 
-#define RET_TY(sym,OldTY,NewTY,sign) \
-  Upgradelval.Ty = getType(NewTY, OldTY); \
+#define RET_TY(sym,NewTY,sign) \
+  Upgradelval.PrimType.T = NewTY; \
+  Upgradelval.PrimType.S = sign; \
   return sym
 
-#define YY_NEVER_INTERACTIVE 1
+namespace llvm {
+
+// TODO: All of the static identifiers are figured out by the lexer,
+// these should be hashed to reduce the lexer size
+
+// UnEscapeLexed - Run through the specified buffer and change \xx codes to the
+// appropriate character.  If AllowNull is set to false, a \00 value will cause
+// an exception to be thrown.
+//
+// If AllowNull is set to true, the return value of the function points to the
+// last character of the string in memory.
+//
+char *UnEscapeLexed(char *Buffer, bool AllowNull) {
+  char *BOut = Buffer;
+  for (char *BIn = Buffer; *BIn; ) {
+    if (BIn[0] == '\\' && isxdigit(BIn[1]) && isxdigit(BIn[2])) {
+      char Tmp = BIn[3]; BIn[3] = 0;     // Terminate string
+      *BOut = (char)strtol(BIn+1, 0, 16);  // Convert to number
+      if (!AllowNull && !*BOut)
+        error("String literal cannot accept \\00 escape!");
+
+      BIn[3] = Tmp;                  // Restore character
+      BIn += 3;                      // Skip over handled chars
+      ++BOut;
+    } else {
+      *BOut++ = *BIn++;
+    }
+  }
+
+  return BOut;
+}
+
+// atoull - Convert an ascii string of decimal digits into the unsigned long
+// long representation... this does not have to do input error checking,
+// because we know that the input will be matched by a suitable regex...
+//
+static uint64_t atoull(const char *Buffer) {
+  uint64_t Result = 0;
+  for (; *Buffer; Buffer++) {
+    uint64_t OldRes = Result;
+    Result *= 10;
+    Result += *Buffer-'0';
+    if (Result < OldRes)   // Uh, oh, overflow detected!!!
+      error("constant bigger than 64 bits detected!");
+  }
+  return Result;
+}
+
+static uint64_t HexIntToVal(const char *Buffer) {
+  uint64_t Result = 0;
+  for (; *Buffer; ++Buffer) {
+    uint64_t OldRes = Result;
+    Result *= 16;
+    char C = *Buffer;
+    if (C >= '0' && C <= '9')
+      Result += C-'0';
+    else if (C >= 'A' && C <= 'F')
+      Result += C-'A'+10;
+    else if (C >= 'a' && C <= 'f')
+      Result += C-'a'+10;
+
+    if (Result < OldRes)   // Uh, oh, overflow detected!!!
+      error("constant bigger than 64 bits detected!");
+  }
+  return Result;
+}
+
+
+// HexToFP - Convert the ascii string in hexidecimal format to the floating
+// point representation of it.
+//
+static double HexToFP(const char *Buffer) {
+  // Behave nicely in the face of C TBAA rules... see:
+  // http://www.nullstone.com/htmls/category/aliastyp.htm
+  union {
+    uint64_t UI;
+    double FP;
+  } UIntToFP;
+  UIntToFP.UI = HexIntToVal(Buffer);
+
+  assert(sizeof(double) == sizeof(uint64_t) &&
+         "Data sizes incompatible on this target!");
+  return UIntToFP.FP;   // Cast Hex constant to double
+}
+
+
+} // End llvm namespace
+
+using namespace llvm;
+
 %}
 
 
@@ -98,168 +190,219 @@
 
 {Comment}       { /* Ignore comments for now */ }
 
-begin           { RET_TOK( BEGINTOK); }
-end             { RET_TOK( ENDTOK); }
-true            { RET_TOK( TRUETOK);  }
-false           { RET_TOK( FALSETOK); }
-declare         { RET_TOK( DECLARE); }
-global          { RET_TOK( GLOBAL); }
-constant        { RET_TOK( CONSTANT); }
-internal        { RET_TOK( INTERNAL); }
-linkonce        { RET_TOK( LINKONCE); }
-weak            { RET_TOK( WEAK); }
-appending       { RET_TOK( APPENDING); }
-dllimport       { RET_TOK( DLLIMPORT); }
-dllexport       { RET_TOK( DLLEXPORT); }
-extern_weak     { RET_TOK( EXTERN_WEAK); }
-external        { RET_TOK( EXTERNAL); }
-uninitialized   { RET_TOK( UNINITIALIZED); }  // alias for external
-implementation  { RET_TOK( IMPLEMENTATION); }
-zeroinitializer { RET_TOK( ZEROINITIALIZER); }
-\.\.\.          { RET_TOK( DOTDOTDOT); }
-undef           { RET_TOK( UNDEF); }
-null            { RET_TOK( NULL_TOK); }
-to              { RET_TOK( TO); }
-tail            { RET_TOK( TAIL); }
-target          { RET_TOK( TARGET); }
-triple          { RET_TOK( TRIPLE); }
-deplibs         { RET_TOK( DEPLIBS); }
-endian          { RET_TOK( ENDIAN); }
-pointersize     { RET_TOK( POINTERSIZE); }
-datalayout      { RET_TOK( DATALAYOUT); }
-little          { RET_TOK( LITTLE); }
-big             { RET_TOK( BIG); }
-volatile        { RET_TOK( VOLATILE); }
-align           { RET_TOK( ALIGN);  }
-section         { RET_TOK( SECTION); }
-module          { RET_TOK( MODULE); }
-asm             { RET_TOK( ASM_TOK); }
-sideeffect      { RET_TOK( SIDEEFFECT); }
-
-cc              { RET_TOK( CC_TOK); }
-ccc             { RET_TOK( CCC_TOK); }
-csretcc         { RET_TOK( CSRETCC_TOK); }
-fastcc          { RET_TOK( FASTCC_TOK); }
-coldcc          { RET_TOK( COLDCC_TOK); }
-x86_stdcallcc   { RET_TOK( X86_STDCALLCC_TOK); }
-x86_fastcallcc  { RET_TOK( X86_FASTCALLCC_TOK); }
-
-void            { RET_TY(VOID,VoidTy,"void",false); }
-bool            { RET_TY(BOOL,BoolTy,"i1",false); }
-sbyte           { RET_TY(SBYTE,SByteTy,"i8",true); }
-ubyte           { RET_TY(UBYTE,UByteTy,"i8",false); }
-short           { RET_TY(SHORT,ShortTy,"i16",true); }
-ushort          { RET_TY(USHORT,UShortTy,"i16",false); }
-int             { RET_TY(INT,IntTy,"i32",true);   }
-uint            { RET_TY(UINT,UIntTy,"i32",false);  }
-long            { RET_TY(LONG,LongTy,"i64",true);  }
-ulong           { RET_TY(ULONG,ULongTy,"i64",false); }
-i8              { RET_TY(UBYTE,UByteTy,"i8",false); }
-i16             { RET_TY(USHORT,UShortTy,"i16",false); }
-i32             { RET_TY(UINT,UIntTy,"i32",false); }
-i64             { RET_TY(ULONG,ULongTy,"i64",false); }
-float           { RET_TY(FLOAT,FloatTy,"float",false); }
-double          { RET_TY(DOUBLE,DoubleTy,"double",false); }
-label           { RET_TY(LABEL,LabelTy,"label",false); }
-opaque          { RET_TOK(OPAQUE); }
-type            { RET_TOK(TYPE);   }
-
-add             { RET_TOK( ADD); }
-sub             { RET_TOK( SUB); }
-mul             { RET_TOK( MUL); }
-div             { RET_TOK( DIV); }
-udiv            { RET_TOK( UDIV); }
-sdiv            { RET_TOK( SDIV); }
-fdiv            { RET_TOK( FDIV); }
-rem             { RET_TOK( REM);  }
-urem            { RET_TOK( UREM); }
-srem            { RET_TOK( SREM); }
-frem            { RET_TOK( FREM); }
-and             { RET_TOK( AND); }
-or              { RET_TOK( OR); }
-xor             { RET_TOK( XOR); }
-setne           { RET_TOK( SETNE); }
-seteq           { RET_TOK( SETEQ); }
-setlt           { RET_TOK( SETLT); }
-setgt           { RET_TOK( SETGT); }
-setle           { RET_TOK( SETLE); }
-setge           { RET_TOK( SETGE); }
-icmp            { RET_TOK(ICMP); }
-fcmp            { RET_TOK(FCMP); }
-eq              { RET_TOK(EQ); }
-ne              { RET_TOK(NE); }
-slt             { RET_TOK(SLT); }
-sgt             { RET_TOK(SGT); }
-sle             { RET_TOK(SLE); }
-sge             { RET_TOK(SGE); }
-oeq             { RET_TOK(OEQ); }
-one             { RET_TOK(ONE); }
-olt             { RET_TOK(OLT); }
-ogt             { RET_TOK(OGT); }
-ole             { RET_TOK(OLE); }
-oge             { RET_TOK(OGE); }
-ord             { RET_TOK(ORD); }
-uno             { RET_TOK(UNO); }
-ueq             { RET_TOK(UEQ); }
-une             { RET_TOK(UNE); }
-ult             { RET_TOK(ULT); }
-ugt             { RET_TOK(UGT); }
-ule             { RET_TOK(ULE); }
-uge             { RET_TOK(UGE); }
-
-phi             { RET_TOK( PHI_TOK); }
-call            { RET_TOK( CALL); }
-cast            { RET_TOK( CAST); }
-trunc           { RET_TOK( TRUNC); }
-zext            { RET_TOK( ZEXT); }
-sext            { RET_TOK( SEXT); }
-fptrunc         { RET_TOK( FPTRUNC); }
-fpext           { RET_TOK( FPEXT); }
-fptoui          { RET_TOK( FPTOUI); }
-fptosi          { RET_TOK( FPTOSI); }
-uitofp          { RET_TOK( UITOFP); }
-sitofp          { RET_TOK( SITOFP); }
-ptrtoint        { RET_TOK( PTRTOINT); }
-inttoptr        { RET_TOK( INTTOPTR); }
-bitcast         { RET_TOK( BITCAST); }
-select          { RET_TOK( SELECT); }
-shl             { RET_TOK( SHL); }
-shr             { RET_TOK( SHR); }
-ashr            { RET_TOK( ASHR); }
-lshr            { RET_TOK( LSHR); }
-va_arg          { RET_TOK( VAARG); }
-ret             { RET_TOK( RET); }
-br              { RET_TOK( BR); }
-switch          { RET_TOK( SWITCH); }
-invoke          { RET_TOK( INVOKE); }
-unwind          { RET_TOK( UNWIND); }
-except          { RET_TOK( EXCEPT); } // alias for unwind
-unreachable     { RET_TOK( UNREACHABLE); }
-
-malloc          { RET_TOK( MALLOC); }
-alloca          { RET_TOK( ALLOCA); }
-free            { RET_TOK( FREE); }
-load            { RET_TOK( LOAD); }
-store           { RET_TOK( STORE); }
-getelementptr   { RET_TOK( GETELEMENTPTR); }
-
-extractelement  { RET_TOK( EXTRACTELEMENT); }
-insertelement   { RET_TOK( INSERTELEMENT); }
-shufflevector   { RET_TOK( SHUFFLEVECTOR); }
-
-
-{VarID}          { RET_TOK( VAR_ID); }
-{Label}          { RET_TOK( LABELSTR); }
-{QuoteLabel}     { RET_TOK( LABELSTR); }
-{StringConstant} { RET_TOK( STRINGCONSTANT ); }
-{PInteger}       { RET_TOK( EUINT64VAL ); }
-{NInteger}       { RET_TOK( ESINT64VAL ); }
-{HexIntConstant} { RET_TOK( yytext[0] == 's' ? ESINT64VAL : EUINT64VAL ); }
-{EPInteger}      { RET_TOK( UINTVAL); }
-{ENInteger}      { RET_TOK( SINTVAL); }
-{FPConstant}     { RET_TOK( FPVAL); }
-{HexFPConstant}  { RET_TOK( FPVAL); }
-<>          {
+begin           { return BEGINTOK; }
+end             { return ENDTOK; }
+true            { return TRUETOK;  }
+false           { return FALSETOK; }
+declare         { return DECLARE; }
+global          { return GLOBAL; }
+constant        { return CONSTANT; }
+internal        { return INTERNAL; }
+linkonce        { return LINKONCE; }
+weak            { return WEAK; }
+appending       { return APPENDING; }
+dllimport       { return DLLIMPORT; }
+dllexport       { return DLLEXPORT; }
+extern_weak     { return EXTERN_WEAK; }
+uninitialized   { return EXTERNAL; }    /* Deprecated, turn into external */
+external        { return EXTERNAL; }
+implementation  { return IMPLEMENTATION; }
+zeroinitializer { return ZEROINITIALIZER; }
+\.\.\.          { return DOTDOTDOT; }
+undef           { return UNDEF; }
+null            { return NULL_TOK; }
+to              { return TO; }
+except          { return EXCEPT; }
+not             { return NOT; }  /* Deprecated, turned into XOR */
+tail            { return TAIL; }
+target          { return TARGET; }
+triple          { return TRIPLE; }
+deplibs         { return DEPLIBS; }
+endian          { return ENDIAN; }
+pointersize     { return POINTERSIZE; }
+datalayout      { return DATALAYOUT; }
+little          { return LITTLE; }
+big             { return BIG; }
+volatile        { return VOLATILE; }
+align           { return ALIGN;  }
+section         { return SECTION; }
+module          { return MODULE; }
+asm             { return ASM_TOK; }
+sideeffect      { return SIDEEFFECT; }
+
+cc              { return CC_TOK; }
+ccc             { return CCC_TOK; }
+csretcc         { return CSRETCC_TOK; }
+fastcc          { return FASTCC_TOK; }
+coldcc          { return COLDCC_TOK; }
+x86_stdcallcc   { return X86_STDCALLCC_TOK; }
+x86_fastcallcc  { return X86_FASTCALLCC_TOK; }
+
+sbyte           { RET_TY(SBYTE,  Type::Int8Ty,  Signed);  }
+ubyte           { RET_TY(UBYTE,  Type::Int8Ty,  Unsigned); }
+short           { RET_TY(SHORT,  Type::Int16Ty, Signed);  }
+ushort          { RET_TY(USHORT, Type::Int16Ty, Unsigned); }
+int             { RET_TY(INT,    Type::Int32Ty, Signed);  }
+uint            { RET_TY(UINT,   Type::Int32Ty, Unsigned); }
+long            { RET_TY(LONG,   Type::Int64Ty, Signed);  }
+ulong           { RET_TY(ULONG,  Type::Int64Ty, Unsigned); }
+void            { RET_TY(VOID,   Type::VoidTy,  Signless  ); }
+bool            { RET_TY(BOOL,   Type::Int1Ty,  Unsigned  ); }
+float           { RET_TY(FLOAT,  Type::FloatTy, Signless ); }
+double          { RET_TY(DOUBLE, Type::DoubleTy,Signless); }
+label           { RET_TY(LABEL,  Type::LabelTy, Signless ); }
+type            { return TYPE;   }
+opaque          { return OPAQUE; }
+
+add             { RET_TOK(BinaryOpVal, AddOp, ADD); }
+sub             { RET_TOK(BinaryOpVal, SubOp, SUB); }
+mul             { RET_TOK(BinaryOpVal, MulOp, MUL); }
+div             { RET_TOK(BinaryOpVal, DivOp,  DIV); }
+udiv            { RET_TOK(BinaryOpVal, UDivOp, UDIV); }
+sdiv            { RET_TOK(BinaryOpVal, SDivOp, SDIV); }
+fdiv            { RET_TOK(BinaryOpVal, FDivOp, FDIV); }
+rem             { RET_TOK(BinaryOpVal, RemOp,  REM); }
+urem            { RET_TOK(BinaryOpVal, URemOp, UREM); }
+srem            { RET_TOK(BinaryOpVal, SRemOp, SREM); }
+frem            { RET_TOK(BinaryOpVal, FRemOp, FREM); }
+and             { RET_TOK(BinaryOpVal, AndOp, AND); }
+or              { RET_TOK(BinaryOpVal, OrOp , OR ); }
+xor             { RET_TOK(BinaryOpVal, XorOp, XOR); }
+setne           { RET_TOK(BinaryOpVal, SetNE, SETNE); }
+seteq           { RET_TOK(BinaryOpVal, SetEQ, SETEQ); }
+setlt           { RET_TOK(BinaryOpVal, SetLT, SETLT); }
+setgt           { RET_TOK(BinaryOpVal, SetGT, SETGT); }
+setle           { RET_TOK(BinaryOpVal, SetLE, SETLE); }
+setge           { RET_TOK(BinaryOpVal, SetGE, SETGE); }
+icmp            { RET_TOK(OtherOpVal, ICmpOp, ICMP); }
+fcmp            { RET_TOK(OtherOpVal, FCmpOp, FCMP); }
+
+eq              { return EQ; }
+ne              { return NE; }
+slt             { return SLT; }
+sgt             { return SGT; }
+sle             { return SLE; }
+sge             { return SGE; }
+ult             { return ULT; }
+ugt             { return UGT; }
+ule             { return ULE; }
+uge             { return UGE; }
+oeq             { return OEQ; }
+one             { return ONE; }
+olt             { return OLT; }
+ogt             { return OGT; }
+ole             { return OLE; }
+oge             { return OGE; }
+ord             { return ORD; }
+uno             { return UNO; }
+ueq             { return UEQ; }
+une             { return UNE; }
+
+phi             { RET_TOK(OtherOpVal, PHIOp, PHI_TOK); }
+call            { RET_TOK(OtherOpVal, CallOp, CALL); }
+cast            { RET_TOK(CastOpVal, CastOp, CAST);  }
+trunc           { RET_TOK(CastOpVal, TruncOp, TRUNC); }
+zext            { RET_TOK(CastOpVal, ZExtOp , ZEXT); }
+sext            { RET_TOK(CastOpVal, SExtOp, SEXT); }
+fptrunc         { RET_TOK(CastOpVal, FPTruncOp, FPTRUNC); }
+fpext           { RET_TOK(CastOpVal, FPExtOp, FPEXT); }
+fptoui          { RET_TOK(CastOpVal, FPToUIOp, FPTOUI); }
+fptosi          { RET_TOK(CastOpVal, FPToSIOp, FPTOSI); }
+uitofp          { RET_TOK(CastOpVal, UIToFPOp, UITOFP); }
+sitofp          { RET_TOK(CastOpVal, SIToFPOp, SITOFP); }
+ptrtoint        { RET_TOK(CastOpVal, PtrToIntOp, PTRTOINT); }
+inttoptr        { RET_TOK(CastOpVal, IntToPtrOp, INTTOPTR); }
+bitcast         { RET_TOK(CastOpVal, BitCastOp, BITCAST); }
+select          { RET_TOK(OtherOpVal, SelectOp, SELECT); }
+shl             { RET_TOK(OtherOpVal, ShlOp, SHL); }
+shr             { RET_TOK(OtherOpVal, ShrOp, SHR); }
+lshr            { RET_TOK(OtherOpVal, LShrOp, LSHR); }
+ashr            { RET_TOK(OtherOpVal, AShrOp, ASHR); }
+vanext          { return VANEXT_old; }
+vaarg           { return VAARG_old; }
+va_arg          { RET_TOK(OtherOpVal, VAArg , VAARG); }
+ret             { RET_TOK(TermOpVal, RetOp, RET); }
+br              { RET_TOK(TermOpVal, BrOp, BR); }
+switch          { RET_TOK(TermOpVal, SwitchOp, SWITCH); }
+invoke          { RET_TOK(TermOpVal, InvokeOp, INVOKE); }
+unwind          { return UNWIND; }
+unreachable     { RET_TOK(TermOpVal, UnreachableOp, UNREACHABLE); }
+
+malloc          { RET_TOK(MemOpVal, MallocOp, MALLOC); }
+alloca          { RET_TOK(MemOpVal, AllocaOp, ALLOCA); }
+free            { RET_TOK(MemOpVal, FreeOp, FREE); }
+load            { RET_TOK(MemOpVal, LoadOp, LOAD); }
+store           { RET_TOK(MemOpVal, StoreOp, STORE); }
+getelementptr   { RET_TOK(MemOpVal, GetElementPtrOp, GETELEMENTPTR); }
+
+extractelement  { RET_TOK(OtherOpVal, ExtractElementOp, EXTRACTELEMENT); }
+insertelement   { RET_TOK(OtherOpVal, InsertElementOp, INSERTELEMENT); }
+shufflevector   { RET_TOK(OtherOpVal, ShuffleVectorOp, SHUFFLEVECTOR); }
+
+
+{VarID}         {
+                  UnEscapeLexed(yytext+1);
+                  Upgradelval.StrVal = strdup(yytext+1);             // Skip %
+                  return VAR_ID;
+                }
+{Label}         {
+                  yytext[strlen(yytext)-1] = 0;  // nuke colon
+                  UnEscapeLexed(yytext);
+                  Upgradelval.StrVal = strdup(yytext);
+                  return LABELSTR;
+                }
+{QuoteLabel}    {
+                  yytext[strlen(yytext)-2] = 0;  // nuke colon, end quote
+                  UnEscapeLexed(yytext+1);
+                  Upgradelval.StrVal = strdup(yytext+1);
+                  return LABELSTR;
+                }
+
+{StringConstant} { // Note that we cannot unescape a string constant here!  The
+                   // string constant might contain a \00 which would not be
+                   // understood by the string stuff.  It is valid to make a
+                   // [sbyte] c"Hello World\00" constant, for example.
+                   //
+                   yytext[strlen(yytext)-1] = 0;           // nuke end quote
+                   Upgradelval.StrVal = strdup(yytext+1);  // Nuke start quote
+                   return STRINGCONSTANT;
+                 }
+
+
+{PInteger}      { Upgradelval.UInt64Val = atoull(yytext); return EUINT64VAL; }
+{NInteger}      {
+                  uint64_t Val = atoull(yytext+1);
+                  // +1:  we have bigger negative range
+                  if (Val > (uint64_t)INT64_MAX+1)
+                    error("Constant too large for signed 64 bits!");
+                  Upgradelval.SInt64Val = -Val;
+                  return ESINT64VAL;
+                }
+{HexIntConstant} {
+                   Upgradelval.UInt64Val = HexIntToVal(yytext+3);
+                   return yytext[0] == 's' ? ESINT64VAL : EUINT64VAL;
+                 }
+
+{EPInteger}     {
+                  uint64_t Val = atoull(yytext+1);
+                  if ((unsigned)Val != Val)
+                    error("Invalid value number (too large)!");
+                  Upgradelval.UIntVal = unsigned(Val);
+                  return UINTVAL;
+                }
+{ENInteger}     {
+                  uint64_t Val = atoull(yytext+2);
+                  // +1:  we have bigger negative range
+                  if (Val > (uint64_t)INT32_MAX+1)
+                    error("Constant too large for signed 32 bits!");
+                  Upgradelval.SIntVal = (int)-Val;
+                  return SINTVAL;
+                }
+
+{FPConstant}    { Upgradelval.FPVal = atof(yytext); return FPVAL; }
+{HexFPConstant} { Upgradelval.FPVal = HexToFP(yytext); return FPVAL; }
+
+<>         {
                   /* Make sure to free the internal buffers for flex when we are
                    * done reading our input!
                    */


Index: llvm/tools/llvm-upgrade/UpgradeParser.y
diff -u llvm/tools/llvm-upgrade/UpgradeParser.y:1.43 llvm/tools/llvm-upgrade/UpgradeParser.y:1.44
--- llvm/tools/llvm-upgrade/UpgradeParser.y:1.43	Sun Jan 21 13:30:52 2007
+++ llvm/tools/llvm-upgrade/UpgradeParser.y	Fri Jan 26 02:18:34 2007
@@ -1,1127 +1,1775 @@
-//===-- UpgradeParser.y - Upgrade parser for llvm assmbly -------*- C++ -*-===//
+//===-- llvmAsmParser.y - Parser for llvm assembly files --------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file was developed by Reid Spencer and is distributed under the
-// University of Illinois Open Source License. See LICENSE.TXT for details.
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
-//  This file implements the bison parser for LLVM 1.9 assembly language.
+//  This file implements the bison parser for LLVM assembly languages files.
 //
 //===----------------------------------------------------------------------===//
 
 %{
 #include "UpgradeInternals.h"
+#include "llvm/CallingConv.h"
+#include "llvm/InlineAsm.h"
+#include "llvm/Instructions.h"
+#include "llvm/Module.h"
+#include "llvm/SymbolTable.h"
+#include "llvm/Support/GetElementPtrTypeIterator.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/Support/MathExtras.h"
 #include 
-#include 
-#include 
 #include 
+#include 
+#include 
+
+// DEBUG_UPREFS - Define this symbol if you want to enable debugging output
+// relating to upreferences in the input stream.
+//
+//#define DEBUG_UPREFS 1
+#ifdef DEBUG_UPREFS
+#define UR_OUT(X) std::cerr << X
+#else
+#define UR_OUT(X)
+#endif
 
 #define YYERROR_VERBOSE 1
 #define YYINCLUDED_STDLIB_H
 #define YYDEBUG 1
 
-int yylex();                       // declaration" of xxx warnings.
+int yylex();
 int yyparse();
-extern int yydebug;
 
-static std::string CurFilename;
-static std::ostream *O = 0;
-std::istream* LexInput = 0;
-unsigned SizeOfPointer = 32;
+int yyerror(const char*);
+static void warning(const std::string& WarningMsg);
 
+namespace llvm {
 
-// This bool controls whether attributes are ever added to function declarations
-// definitions and calls.
-static bool AddAttributes = false;
 
-static void warning(const std::string& msg);
+SignedType *SignedType::SByteTy = 0;
+SignedType *SignedType::SShortTy = 0;
+SignedType *SignedType::SIntTy = 0;
+SignedType *SignedType::SLongTy = 0;
+
+inline bool SignedType::classof(const Type *T) {
+  if (T->getTypeID() != IntegerTyID)
+    return false;
+  return (T == SByteTy || T == SShortTy || T == SIntTy || T == SLongTy );
+}
 
-void UpgradeAssembly(const std::string &infile, std::istream& in, 
-                     std::ostream &out, bool debug, bool addAttrs)
+SignedType::SignedType(const IntegerType* ITy) 
+  : IntegerType(ITy->getBitWidth()), base_type(ITy)
 {
-  Upgradelineno = 1; 
-  CurFilename = infile;
-  LexInput = ∈
-  yydebug = debug;
-  AddAttributes = addAttrs;
-  O = &out;
+}
 
-  if (yyparse()) {
-    std::cerr << "llvm-upgrade: parse failed.\n";
-    out << "llvm-upgrade: parse failed.\n";
-    exit(1);
+const SignedType *SignedType::get(const IntegerType* ITy) {
+  if (ITy == Type::Int8Ty) {
+    if (!SByteTy)
+      SByteTy = new SignedType(IntegerType::get(8));
+    return SByteTy;
+  } else if (ITy == Type::Int16Ty) {
+    if (!SShortTy)
+      SShortTy = new SignedType(IntegerType::get(16));
+    return SShortTy;
+  } else if (ITy == Type::Int32Ty) {
+    if (!SIntTy)
+      SIntTy = new SignedType(IntegerType::get(32));
+    return SIntTy;
+  } else if (ITy == Type::Int64Ty) {
+    if (!SLongTy)
+      SLongTy = new SignedType(IntegerType::get(64));
+    return SLongTy;
+  } else
+    assert(0 && "Invalid integer type for SignedType::get");
+}
+
+static inline Signedness getSign(const Type *&Ty) {
+  if (const SignedType *STy = dyn_cast(Ty)) {
+    Ty = STy->getBaseType();
+    return Signed;
+  } else if (isa(Ty))
+    return Unsigned;
+  return Signless;
+}
+
+static const Type*
+resolveTypeImpl(const Type* Ty, std::vector& TyStack)
+{
+  // Nothing to resolve if it isn't a derived type
+  if (!Ty->isDerivedType())
+    return Ty;
+
+  // Prevent infinite recursion for recursive types
+  for (std::vector::const_iterator I = TyStack.begin(), 
+       E = TyStack.end(); I != E; ++I)
+    if (Ty == *I)
+      return Ty;
+
+  // Okay, haven't seen this derived type yet, push it on the stack.
+  const Type* Result = Ty;
+  TyStack.push_back(Ty);
+
+  // Process the type
+  switch (Ty->getTypeID()) {
+    default: assert(0 && "Invalid derived type");
+    case Type::IntegerTyID:
+      break;
+    case Type::FunctionTyID: {
+      const FunctionType* FTy = cast(Ty);
+      const Type* RetTy = resolveTypeImpl(FTy->getReturnType(), TyStack);
+      std::vector Types;
+      FunctionType::ParamAttrsList Attrs;
+      Attrs.push_back(FTy->getParamAttrs(0));
+      for (unsigned i = 0; i < FTy->getNumParams(); ++i) {
+        Types.push_back(resolveTypeImpl(FTy->getParamType(i), TyStack));
+        Attrs.push_back(FTy->getParamAttrs(i+1));
+      }
+      Result = FunctionType::get(RetTy, Types, FTy->isVarArg(), Attrs);
+      break;
+    }
+    case Type::StructTyID:
+    case Type::PackedStructTyID: {
+      const StructType *STy = cast(Ty);
+      std::vector FieldTypes;
+      for (unsigned i = 0; i < STy->getNumElements(); ++i)
+        FieldTypes.push_back(resolveTypeImpl(STy->getElementType(i), TyStack));
+      Result = StructType::get(FieldTypes, STy->isPacked());
+      break;
+    }
+    case Type::ArrayTyID: {
+      const ArrayType *ATy = cast(Ty);
+      uint64_t NElems = ATy->getNumElements();
+      const Type *ElemTy = resolveTypeImpl(ATy->getElementType(), TyStack);
+      Result = ArrayType::get(ElemTy, NElems);
+      break;
+    }
+    case Type::PointerTyID: {
+      const PointerType *PTy = cast(Ty);
+      const Type *ElemTy = resolveTypeImpl(PTy->getElementType(), TyStack);
+      Result = PointerType::get(ElemTy);
+      break;
+    }
+    case Type::PackedTyID: {
+      const PackedType *PTy = cast(Ty);
+      unsigned NElems = PTy->getNumElements();
+      const Type *ElemTy = resolveTypeImpl(PTy->getElementType(), TyStack);
+      Result = PackedType::get(ElemTy, NElems);
+      break;
+    }
   }
+  // Done with it, pop it off.
+  TyStack.pop_back();
+  return Result;
 }
 
-namespace { // Anonymous namespace to keep our implementation local
+static inline const Type* resolveType(const Type* Ty) {
+  if (!Ty)
+    return 0;
+  if (const SignedType* STy = dyn_cast(Ty))
+    return STy->getBaseType();
+  std::vector TyStack;
+  return resolveTypeImpl(Ty, TyStack);
+}
 
+std::istream* LexInput;
+static std::string CurFilename;
 
-/// This type is used to keep track of the signedness of values. Instead
-/// of creating llvm::Value directly, the parser will create Value which
-/// associates a Value* with a Signedness indication.
-struct Value {
-  std::string* val;
-  const Type* type;
-  bool constant;
-  bool isConstant() const { return constant; }
-  ~Value() { delete val; }
-};
+// This bool controls whether attributes are ever added to function declarations
+// definitions and calls.
+static bool AddAttributes = false;
 
+static Module *ParserResult;
+static bool ObsoleteVarArgs;
+static bool NewVarArgs;
+static BasicBlock *CurBB;
+static GlobalVariable *CurGV;
 
-/// This type is used to keep track of the signedness of the obsolete
-/// integer types. Instead of creating an llvm::Type directly, the Lexer will
-/// create instances of Type which retains the signedness indication so
-/// it can be used by the parser for upgrade decisions.
-/// For example if "uint" is encountered then the "first" field will be set 
-/// to "int32" and the "second" field will be set to "isUnsigned".  If the 
-/// type is not obsolete then "second" will be set to "isSignless".
-class Type {
-public:
-  static const Type* get(const std::string &newType, TypeIDs oldType);
-  static const Type* get(const std::string& newType, TypeIDs oldType, 
-                             const Type* eTy, const Type* rTy);
 
-  static const Type* get(const std::string& newType, TypeIDs oldType, 
-                             const Type *eTy, uint64_t elems);
 
-  static const Type* get(const std::string& newType, TypeIDs oldType, 
-                             TypeList* TL);
+// This contains info used when building the body of a function.  It is
+// destroyed when the function is completed.
+//
+typedef std::vector ValueList;           // Numbered defs
 
-  static const Type* get(const std::string& newType, const Type* resTy, 
-                             TypeList* TL);
+typedef std::pair RenameMapKey;
+typedef std::map RenameMapType;
 
-  const Type* resolve() const;
-  bool operator<(const Type& that) const;
+static void 
+ResolveDefinitions(std::map &LateResolvers,
+                   std::map *FutureLateResolvers = 0);
+
+static struct PerModuleInfo {
+  Module *CurrentModule;
+  std::map Values; // Module level numbered definitions
+  std::map LateResolveValues;
+  std::vector    Types;
+  std::map LateResolveTypes;
+  static Module::Endianness Endian;
+  static Module::PointerSize PointerSize;
+  RenameMapType RenameMap;
+
+  /// PlaceHolderInfo - When temporary placeholder objects are created, remember
+  /// how they were referenced and on which line of the input they came from so
+  /// that we can resolve them later and print error messages as appropriate.
+  std::map > PlaceHolderInfo;
+
+  // GlobalRefs - This maintains a mapping between 's and forward
+  // references to global values.  Global values may be referenced before they
+  // are defined, and if so, the temporary object that they represent is held
+  // here.  This is used for forward references of GlobalValues.
+  //
+  typedef std::map, GlobalValue*> 
+    GlobalRefsType;
+  GlobalRefsType GlobalRefs;
+
+  void ModuleDone() {
+    // If we could not resolve some functions at function compilation time
+    // (calls to functions before they are defined), resolve them now...  Types
+    // are resolved when the constant pool has been completely parsed.
+    //
+    ResolveDefinitions(LateResolveValues);
+
+    // Check to make sure that all global value forward references have been
+    // resolved!
+    //
+    if (!GlobalRefs.empty()) {
+      std::string UndefinedReferences = "Unresolved global references exist:\n";
+
+      for (GlobalRefsType::iterator I = GlobalRefs.begin(), E =GlobalRefs.end();
+           I != E; ++I) {
+        UndefinedReferences += "  " + I->first.first->getDescription() + " " +
+                               I->first.second.getName() + "\n";
+      }
+      error(UndefinedReferences);
+      return;
+    }
 
-  bool sameNewTyAs(const Type* that) const {
-    return this->newTy == that->newTy;
-  }
+    if (CurrentModule->getDataLayout().empty()) {
+      std::string dataLayout;
+      if (Endian != Module::AnyEndianness)
+        dataLayout.append(Endian == Module::BigEndian ? "E" : "e");
+      if (PointerSize != Module::AnyPointerSize) {
+        if (!dataLayout.empty())
+          dataLayout += "-";
+        dataLayout.append(PointerSize == Module::Pointer64 ? 
+                          "p:64:64" : "p:32:32");
+      }
+      CurrentModule->setDataLayout(dataLayout);
+    }
 
-  bool sameOldTyAs(const Type* that) const;
+    Values.clear();         // Clear out function local definitions
+    Types.clear();
+    CurrentModule = 0;
+  }
+
+  // GetForwardRefForGlobal - Check to see if there is a forward reference
+  // for this global.  If so, remove it from the GlobalRefs map and return it.
+  // If not, just return null.
+  GlobalValue *GetForwardRefForGlobal(const PointerType *PTy, ValID ID) {
+    // Check to see if there is a forward reference to this global variable...
+    // if there is, eliminate it and patch the reference to use the new def'n.
+    GlobalRefsType::iterator I = GlobalRefs.find(std::make_pair(PTy, ID));
+    GlobalValue *Ret = 0;
+    if (I != GlobalRefs.end()) {
+      Ret = I->second;
+      GlobalRefs.erase(I);
+    }
+    return Ret;
+  }
+  void setEndianness(Module::Endianness E) { Endian = E; }
+  void setPointerSize(Module::PointerSize sz) { PointerSize = sz; }
+} CurModule;
+
+Module::Endianness  PerModuleInfo::Endian = Module::AnyEndianness;
+Module::PointerSize PerModuleInfo::PointerSize = Module::AnyPointerSize;
+
+static struct PerFunctionInfo {
+  Function *CurrentFunction;     // Pointer to current function being created
+
+  std::map Values; // Keep track of #'d definitions
+  std::map LateResolveValues;
+  bool isDeclare;                   // Is this function a forward declararation?
+  GlobalValue::LinkageTypes Linkage;// Linkage for forward declaration.
+
+  /// BBForwardRefs - When we see forward references to basic blocks, keep
+  /// track of them here.
+  std::map > BBForwardRefs;
+  std::vector NumberedBlocks;
+  RenameMapType RenameMap;
+  std::set SignedValues;
+  unsigned NextBBNum;
 
-  TypeIDs getElementTy() const {
-    if (elemTy) {
-      return elemTy->oldTy;
-    }
-    return UnresolvedTy;
+  inline PerFunctionInfo() {
+    CurrentFunction = 0;
+    isDeclare = false;
+    Linkage = GlobalValue::ExternalLinkage;    
   }
 
-  unsigned getUpRefNum() const {
-    assert(oldTy == UpRefTy && "Can't getUpRefNum on non upreference");
-    return atoi(&((getNewTy().c_str())[1])); // skip the slash
+  inline void FunctionStart(Function *M) {
+    CurrentFunction = M;
+    NextBBNum = 0;
   }
 
-  typedef std::vector UpRefStack;
-  void getSignedness(unsigned &sNum, unsigned &uNum, UpRefStack& stk) const;
-  std::string makeUniqueName(const std::string& BaseName) const;
+  void FunctionDone() {
+    NumberedBlocks.clear();
 
-  const std::string& getNewTy() const { return newTy; }
-  const Type* getResultType() const { return resultTy; }
-  const Type* getElementType() const { return elemTy; }
+    // Any forward referenced blocks left?
+    if (!BBForwardRefs.empty()) {
+      error("Undefined reference to label " + 
+            BBForwardRefs.begin()->first->getName());
+      return;
+    }
 
-  const Type* getPointerType() const {
-    return get(newTy + "*", PointerTy, this, (Type*)0);
-  }
+    // Resolve all forward references now.
+    ResolveDefinitions(LateResolveValues, &CurModule.LateResolveValues);
 
-  bool isUnresolved() const { return oldTy == UnresolvedTy; }
-  bool isUpReference() const { return oldTy == UpRefTy; }
-  bool isVoid() const { return oldTy == VoidTy; }
-  bool isBool() const { return oldTy == BoolTy; }
-  bool isSigned() const {
-    return oldTy == SByteTy || oldTy == ShortTy || 
-           oldTy == IntTy || oldTy == LongTy;
+    Values.clear();         // Clear out function local definitions
+    RenameMap.clear();
+    SignedValues.clear();
+    CurrentFunction = 0;
+    isDeclare = false;
+    Linkage = GlobalValue::ExternalLinkage;
   }
+} CurFun;  // Info for the current function...
 
-  bool isUnsigned() const {
-    return oldTy == UByteTy || oldTy == UShortTy || 
-           oldTy == UIntTy || oldTy == ULongTy;
-  }
-  bool isSignless() const { return !isSigned() && !isUnsigned(); }
-  bool isInteger() const { return isSigned() || isUnsigned(); }
-  bool isIntegral() const { return oldTy == BoolTy || isInteger(); }
-  bool isFloatingPoint() const { return oldTy == DoubleTy || oldTy == FloatTy; }
-  bool isPacked() const { return oldTy == PackedTy; }
-  bool isPointer() const { return oldTy == PointerTy; }
-  bool isStruct() const { return oldTy == StructTy || oldTy == PackedStructTy; }
-  bool isArray() const { return oldTy == ArrayTy; }
-  bool isOther() const { 
-    return !isPacked() && !isPointer() && !isFloatingPoint() && !isIntegral(); }
-  bool isFunction() const { return oldTy == FunctionTy; }
-  bool isComposite() const {
-    return isStruct() || isPointer() || isArray() || isPacked();
-  }
+static bool inFunctionScope() { return CurFun.CurrentFunction != 0; }
 
-  bool isAttributeCandidate() const {
-    return isIntegral() && getBitWidth() < 32;
-  }
 
-  bool isUnresolvedDeep() const;
+//===----------------------------------------------------------------------===//
+//               Code to handle definitions of all the types
+//===----------------------------------------------------------------------===//
 
-  unsigned getBitWidth() const;
+static int InsertValue(Value *V,
+                  std::map &ValueTab = CurFun.Values) {
+  if (V->hasName()) return -1;           // Is this a numbered definition?
+
+  // Yes, insert the value into the value table...
+  ValueList &List = ValueTab[V->getType()];
+  List.push_back(V);
+  return List.size()-1;
+}
+
+static const Type *getTypeVal(const ValID &D, bool DoNotImprovise = false) {
+  switch (D.Type) {
+  case ValID::NumberVal:               // Is it a numbered definition?
+    // Module constants occupy the lowest numbered slots...
+    if ((unsigned)D.Num < CurModule.Types.size()) {
+      return CurModule.Types[(unsigned)D.Num];
+    }
+    break;
+  case ValID::NameVal:                 // Is it a named definition?
+    if (const Type *N = CurModule.CurrentModule->getTypeByName(D.Name)) {
+      D.destroy();  // Free old strdup'd memory...
+      return N;
+    }
+    break;
+  default:
+    error("Internal parser error: Invalid symbol type reference");
+    return 0;
+  }
 
-  const Type* getIndexedType(const Value*  V) const;
+  // If we reached here, we referenced either a symbol that we don't know about
+  // or an id number that hasn't been read yet.  We may be referencing something
+  // forward, so just create an entry to be resolved later and get to it...
+  //
+  if (DoNotImprovise) return 0;  // Do we just want a null to be returned?
 
-  unsigned getNumStructElements() const { 
-    return (elements ? elements->size() : 0);
-  }
 
-  const Type* getElement(unsigned idx) const {
-    if (elements)
-      if (idx < elements->size())
-        return (*elements)[idx];
-    return 0;
+  if (inFunctionScope()) {
+    if (D.Type == ValID::NameVal) {
+      error("Reference to an undefined type: '" + D.getName() + "'");
+      return 0;
+    } else {
+      error("Reference to an undefined type: #" + itostr(D.Num));
+      return 0;
+    }
   }
 
-private:
-  Type() 
-    : newTy(), oldTy(UnresolvedTy), elemTy(0), resultTy(0), elements(0),
-      nelems(0) {
+  std::map::iterator I =CurModule.LateResolveTypes.find(D);
+  if (I != CurModule.LateResolveTypes.end())
+    return I->second;
+
+  Type *Typ = OpaqueType::get();
+  CurModule.LateResolveTypes.insert(std::make_pair(D, Typ));
+  return Typ;
+ }
+
+// getExistingValue - Look up the value specified by the provided type and
+// the provided ValID.  If the value exists and has already been defined, return
+// it.  Otherwise return null.
+//
+static Value *getExistingValue(const Type *Ty, const ValID &D) {
+  if (isa(Ty)) {
+    error("Functions are not values and must be referenced as pointers");
+  }
+
+  switch (D.Type) {
+  case ValID::NumberVal: {                 // Is it a numbered definition?
+    unsigned Num = (unsigned)D.Num;
+
+    // Module constants occupy the lowest numbered slots...
+    std::map::iterator VI = CurModule.Values.find(Ty);
+    if (VI != CurModule.Values.end()) {
+      if (Num < VI->second.size())
+        return VI->second[Num];
+      Num -= VI->second.size();
+    }
+
+    // Make sure that our type is within bounds
+    VI = CurFun.Values.find(Ty);
+    if (VI == CurFun.Values.end()) return 0;
+
+    // Check that the number is within bounds...
+    if (VI->second.size() <= Num) return 0;
+
+    return VI->second[Num];
+  }
+
+  case ValID::NameVal: {                // Is it a named definition?
+    // Get the name out of the ID
+    std::string Name(D.Name);
+    Value* V = 0;
+    RenameMapKey Key = std::make_pair(Name, Ty);
+    if (inFunctionScope()) {
+      // See if the name was renamed
+      RenameMapType::const_iterator I = CurFun.RenameMap.find(Key);
+      std::string LookupName;
+      if (I != CurFun.RenameMap.end())
+        LookupName = I->second;
+      else
+        LookupName = Name;
+      SymbolTable &SymTab = CurFun.CurrentFunction->getValueSymbolTable();
+      V = SymTab.lookup(Ty, LookupName);
+    }
+    if (!V) {
+      RenameMapType::const_iterator I = CurModule.RenameMap.find(Key);
+      std::string LookupName;
+      if (I != CurModule.RenameMap.end())
+        LookupName = I->second;
+      else
+        LookupName = Name;
+      V = CurModule.CurrentModule->getValueSymbolTable().lookup(Ty, LookupName);
+    }
+    if (V == 0) 
+      return 0;
+
+    D.destroy();  // Free old strdup'd memory...
+    return V;
   }
 
-  Type(const Type& that); // do not implement
-  Type& operator=(const Type& that); // do not implement
+  // Check to make sure that "Ty" is an integral type, and that our
+  // value will fit into the specified type...
+  case ValID::ConstSIntVal:    // Is it a constant pool reference??
+    if (!ConstantInt::isValueValidForType(Ty, D.ConstPool64)) {
+      error("Signed integral constant '" + itostr(D.ConstPool64) + 
+            "' is invalid for type '" + Ty->getDescription() + "'");
+    }
+    return ConstantInt::get(Ty, D.ConstPool64);
+
+  case ValID::ConstUIntVal:     // Is it an unsigned const pool reference?
+    if (!ConstantInt::isValueValidForType(Ty, D.UConstPool64)) {
+      if (!ConstantInt::isValueValidForType(Ty, D.ConstPool64))
+        error("Integral constant '" + utostr(D.UConstPool64) + 
+              "' is invalid or out of range");
+      else     // This is really a signed reference.  Transmogrify.
+        return ConstantInt::get(Ty, D.ConstPool64);
+    } else
+      return ConstantInt::get(Ty, D.UConstPool64);
 
-  ~Type() { delete elements; }
+  case ValID::ConstFPVal:        // Is it a floating point const pool reference?
+    if (!ConstantFP::isValueValidForType(Ty, D.ConstPoolFP))
+      error("FP constant invalid for type");
+    return ConstantFP::get(Ty, D.ConstPoolFP);
+
+  case ValID::ConstNullVal:      // Is it a null value?
+    if (!isa(Ty))
+      error("Cannot create a a non pointer null");
+    return ConstantPointerNull::get(cast(Ty));
+
+  case ValID::ConstUndefVal:      // Is it an undef value?
+    return UndefValue::get(Ty);
+
+  case ValID::ConstZeroVal:      // Is it a zero value?
+    return Constant::getNullValue(Ty);
+    
+  case ValID::ConstantVal:       // Fully resolved constant?
+    if (D.ConstantValue->getType() != Ty) 
+      error("Constant expression type different from required type");
+    return D.ConstantValue;
+
+  case ValID::InlineAsmVal: {    // Inline asm expression
+    const PointerType *PTy = dyn_cast(Ty);
+    const FunctionType *FTy =
+      PTy ? dyn_cast(PTy->getElementType()) : 0;
+    if (!FTy || !InlineAsm::Verify(FTy, D.IAD->Constraints))
+      error("Invalid type for asm constraint string");
+    InlineAsm *IA = InlineAsm::get(FTy, D.IAD->AsmString, D.IAD->Constraints,
+                                   D.IAD->HasSideEffects);
+    D.destroy();   // Free InlineAsmDescriptor.
+    return IA;
+  }
+  default:
+    assert(0 && "Unhandled case");
+    return 0;
+  }   // End of switch
 
-  struct ltfunctor
-  {
-    bool operator()(const Type* X, const Type* Y) const {
-      assert(X && "Can't compare null pointer");
-      assert(Y && "Can't compare null pointer");
-      return *X < *Y;
-    }
-  };
+  assert(0 && "Unhandled case");
+  return 0;
+}
 
-  typedef std::set TypeRegMap;
+// getVal - This function is identical to getExistingValue, except that if a
+// value is not already defined, it "improvises" by creating a placeholder var
+// that looks and acts just like the requested variable.  When the value is
+// defined later, all uses of the placeholder variable are replaced with the
+// real thing.
+//
+static Value *getVal(const Type *Ty, const ValID &ID) {
+  if (Ty == Type::LabelTy)
+    error("Cannot use a basic block here");
+
+  // See if the value has already been defined.
+  Value *V = getExistingValue(Ty, ID);
+  if (V) return V;
+
+  if (!Ty->isFirstClassType() && !isa(Ty))
+    error("Invalid use of a composite type");
+
+  // If we reached here, we referenced either a symbol that we don't know about
+  // or an id number that hasn't been read yet.  We may be referencing something
+  // forward, so just create an entry to be resolved later and get to it...
+  assert(!isa(Ty) && "Can't create value with SignedType");
+  V = new Argument(Ty);
+
+  // Remember where this forward reference came from.  FIXME, shouldn't we try
+  // to recycle these things??
+  CurModule.PlaceHolderInfo.insert(
+    std::make_pair(V, std::make_pair(ID, Upgradelineno-1)));
 
-  static const Type* add_new_type(Type* existing);
+  if (inFunctionScope())
+    InsertValue(V, CurFun.LateResolveValues);
+  else
+    InsertValue(V, CurModule.LateResolveValues);
+  return V;
+}
 
-  std::string newTy;
-  TypeIDs oldTy;
-  Type *elemTy;
-  Type *resultTy;
-  TypeList *elements;
-  uint64_t nelems;
-  static TypeRegMap registry;
-public:
-  typedef std::vector TypeVector;
-  typedef std::map TypeMap;
-  typedef std::map TypePlaneMap;
-  typedef std::map GlobalsTypeMap;
-  static TypeVector EnumeratedTypes;
-  static TypeMap NamedTypes;
-  static GlobalsTypeMap Globals;
-};
-
-Type::TypeRegMap     Type::registry;
-Type::TypeVector     Type::EnumeratedTypes;
-Type::TypeMap        Type::NamedTypes;
-Type::GlobalsTypeMap Type::Globals;
-
-const Type* Type::get(const std::string &newType, TypeIDs oldType) {
-  Type* Ty = new Type();
-  Ty->newTy = newType;
-  Ty->oldTy = oldType;
-  return add_new_type(Ty);
-}
-
-const Type* Type::get(const std::string& newType, TypeIDs oldType, 
-                              const Type* eTy, const Type* rTy) {
-  Type* Ty= new Type();
-  Ty->newTy = newType;
-  Ty->oldTy = oldType;
-  Ty->elemTy = const_cast(eTy);
-  Ty->resultTy = const_cast(rTy);
-  return add_new_type(Ty);
-}
-
-const Type* Type::get(const std::string& newType, TypeIDs oldType, 
-                              const Type *eTy, uint64_t elems) {
-  Type* Ty = new Type();
-  Ty->newTy = newType;
-  Ty->oldTy = oldType;
-  Ty->elemTy = const_cast(eTy);
-  Ty->nelems = elems;
-  return  add_new_type(Ty);
-}
-
-const Type* Type::get(const std::string& newType, TypeIDs oldType, 
-                              TypeList* TL) {
-  Type* Ty = new Type();
-  Ty->newTy = newType;
-  Ty->oldTy = oldType;
-  Ty->elements = TL;
-  return add_new_type(Ty);
-}
-
-const Type* Type::get(const std::string& newType, const Type* resTy,
-                              TypeList* TL) {
-  Type* Ty = new Type();
-  Ty->newTy = newType;
-  Ty->oldTy = FunctionTy;
-  Ty->resultTy = const_cast(resTy);
-  Ty->elements = TL;
-  return add_new_type(Ty);
-}
-
-const Type* Type::resolve() const {
-  if (isUnresolved()) {
-    if (getNewTy()[0] == '%' && isdigit(newTy[1])) {
-      unsigned ref = atoi(&((newTy.c_str())[1])); // skip the %
-      if (ref < EnumeratedTypes.size()) {
-        return EnumeratedTypes[ref];
-      } else {
-        std::string msg("Can't resolve numbered type: ");
-        msg += getNewTy();
-        yyerror(msg.c_str());
-      }
-    } else {
-      Type::TypeMap::iterator I = NamedTypes.find(newTy);
-      if (I != NamedTypes.end()) {
-        return I->second;
-      } else {
-        std::string msg("Cannot resolve type: ");
-        msg += getNewTy();
-        yyerror(msg.c_str());
-      }
-    }
+/// getBBVal - This is used for two purposes:
+///  * If isDefinition is true, a new basic block with the specified ID is being
+///    defined.
+///  * If isDefinition is true, this is a reference to a basic block, which may
+///    or may not be a forward reference.
+///
+static BasicBlock *getBBVal(const ValID &ID, bool isDefinition = false) {
+  assert(inFunctionScope() && "Can't get basic block at global scope");
+
+  std::string Name;
+  BasicBlock *BB = 0;
+  switch (ID.Type) {
+  default: 
+    error("Illegal label reference " + ID.getName());
+    break;
+  case ValID::NumberVal:                // Is it a numbered definition?
+    if (unsigned(ID.Num) >= CurFun.NumberedBlocks.size())
+      CurFun.NumberedBlocks.resize(ID.Num+1);
+    BB = CurFun.NumberedBlocks[ID.Num];
+    break;
+  case ValID::NameVal:                  // Is it a named definition?
+    Name = ID.Name;
+    if (Value *N = CurFun.CurrentFunction->
+                   getValueSymbolTable().lookup(Type::LabelTy, Name)) {
+      if (N->getType() != Type::LabelTy)
+        error("Name '" + Name + "' does not refer to a BasicBlock");
+      BB = cast(N);
+    }
+    break;
+  }
+
+  // See if the block has already been defined.
+  if (BB) {
+    // If this is the definition of the block, make sure the existing value was
+    // just a forward reference.  If it was a forward reference, there will be
+    // an entry for it in the PlaceHolderInfo map.
+    if (isDefinition && !CurFun.BBForwardRefs.erase(BB))
+      // The existing value was a definition, not a forward reference.
+      error("Redefinition of label " + ID.getName());
+
+    ID.destroy();                       // Free strdup'd memory.
+    return BB;
+  }
+
+  // Otherwise this block has not been seen before.
+  BB = new BasicBlock("", CurFun.CurrentFunction);
+  if (ID.Type == ValID::NameVal) {
+    BB->setName(ID.Name);
+  } else {
+    CurFun.NumberedBlocks[ID.Num] = BB;
   }
-  // otherwise its already resolved.
-  return this;
-}
 
-bool Type::operator<(const Type& that) const {
-  if (this == &that)
-    return false;
-  if (oldTy != that.oldTy)
-    return oldTy < that.oldTy;
-  switch (oldTy) {
-    case UpRefTy: {
-      unsigned thisUp = this->getUpRefNum();
-      unsigned thatUp = that.getUpRefNum();
-      return thisUp < thatUp;
-    }
-    case PackedTy:
-    case ArrayTy:
-      if (this->nelems != that.nelems)
-        return nelems < that.nelems;
-    case PointerTy: {
-      const Type* thisTy = this->elemTy;
-      const Type* thatTy = that.elemTy;
-      return *thisTy < *thatTy;
-    }
-    case FunctionTy: {
-      const Type* thisTy = this->resultTy;
-      const Type* thatTy = that.resultTy;
-      if (!thisTy->sameOldTyAs(thatTy))
-        return *thisTy < *thatTy;
-      /* FALL THROUGH */
-    }
-    case StructTy:
-    case PackedStructTy: {
-      if (elements->size() != that.elements->size())
-        return elements->size() < that.elements->size();
-      for (unsigned i = 0; i < elements->size(); i++) {
-        const Type* thisTy = (*this->elements)[i];
-        const Type* thatTy = (*that.elements)[i];
-        if (!thisTy->sameOldTyAs(thatTy))
-          return *thisTy < *thatTy;
-      }
-      break;
-    }
-    case UnresolvedTy:
-      return this->newTy < that.newTy;
-    default:
-      break;
+  // If this is not a definition, keep track of it so we can use it as a forward
+  // reference.
+  if (!isDefinition) {
+    // Remember where this forward reference came from.
+    CurFun.BBForwardRefs[BB] = std::make_pair(ID, Upgradelineno);
+  } else {
+    // The forward declaration could have been inserted anywhere in the
+    // function: insert it into the correct place now.
+    CurFun.CurrentFunction->getBasicBlockList().remove(BB);
+    CurFun.CurrentFunction->getBasicBlockList().push_back(BB);
   }
-  return false; 
+  ID.destroy();
+  return BB;
 }
 
-bool Type::sameOldTyAs(const Type* that) const {
-  if (that == 0)
-    return false;
-  if ( this == that ) 
-    return true;
-  if (oldTy != that->oldTy)
-    return false;
-  switch (oldTy) {
-    case PackedTy:
-    case ArrayTy:
-      if (nelems != that->nelems)
-        return false;
-      /* FALL THROUGH */
-    case PointerTy: {
-      const Type* thisTy = this->elemTy;
-      const Type* thatTy = that->elemTy;
-      return thisTy->sameOldTyAs(thatTy);
-    }
-    case FunctionTy: {
-      const Type* thisTy = this->resultTy;
-      const Type* thatTy = that->resultTy;
-      if (!thisTy->sameOldTyAs(thatTy))
-        return false;
-      /* FALL THROUGH */
-    }
-    case StructTy:
-    case PackedStructTy: {
-      if (elements->size() != that->elements->size())
-        return false;
-      for (unsigned i = 0; i < elements->size(); i++) {
-        const Type* thisTy = (*this->elements)[i];
-        const Type* thatTy = (*that->elements)[i];
-        if (!thisTy->sameOldTyAs(thatTy))
-          return false;
+
+//===----------------------------------------------------------------------===//
+//              Code to handle forward references in instructions
+//===----------------------------------------------------------------------===//
+//
+// This code handles the late binding needed with statements that reference
+// values not defined yet... for example, a forward branch, or the PHI node for
+// a loop body.
+//
+// This keeps a table (CurFun.LateResolveValues) of all such forward references
+// and back patchs after we are done.
+//
+
+// ResolveDefinitions - If we could not resolve some defs at parsing
+// time (forward branches, phi functions for loops, etc...) resolve the
+// defs now...
+//
+static void 
+ResolveDefinitions(std::map &LateResolvers,
+                   std::map *FutureLateResolvers) {
+  // Loop over LateResolveDefs fixing up stuff that couldn't be resolved
+  for (std::map::iterator LRI = LateResolvers.begin(),
+         E = LateResolvers.end(); LRI != E; ++LRI) {
+    ValueList &List = LRI->second;
+    while (!List.empty()) {
+      Value *V = List.back();
+      List.pop_back();
+
+      std::map >::iterator PHI =
+        CurModule.PlaceHolderInfo.find(V);
+      assert(PHI != CurModule.PlaceHolderInfo.end() && "Placeholder error");
+
+      ValID &DID = PHI->second.first;
+
+      Value *TheRealValue = getExistingValue(LRI->first, DID);
+      if (TheRealValue) {
+        V->replaceAllUsesWith(TheRealValue);
+        delete V;
+        CurModule.PlaceHolderInfo.erase(PHI);
+      } else if (FutureLateResolvers) {
+        // Functions have their unresolved items forwarded to the module late
+        // resolver table
+        InsertValue(V, *FutureLateResolvers);
+      } else {
+        if (DID.Type == ValID::NameVal) {
+          error("Reference to an invalid definition: '" +DID.getName()+
+                "' of type '" + V->getType()->getDescription() + "'",
+                PHI->second.second);
+          return;
+        } else {
+          error("Reference to an invalid definition: #" +
+                itostr(DID.Num) + " of type '" + 
+                V->getType()->getDescription() + "'", PHI->second.second);
+          return;
+        }
       }
-      return true;
     }
-    case UnresolvedTy:
-      return this->newTy == that->newTy;
-    default:
-      return true; // for all others oldTy == that->oldTy is sufficient
   }
-  return true;
+
+  LateResolvers.clear();
 }
 
-bool Type::isUnresolvedDeep() const {
-  switch (oldTy) {
-    case UnresolvedTy: 
-      return true;
-    case PackedTy:
-    case ArrayTy:
-    case PointerTy:
-      return elemTy->isUnresolvedDeep();
-    case PackedStructTy:
-    case StructTy:
-      for (unsigned i = 0; i < elements->size(); i++)
-        if ((*elements)[i]->isUnresolvedDeep())
-          return true;
-      return false;
-    default:
-      return false;
+// ResolveTypeTo - A brand new type was just declared.  This means that (if
+// name is not null) things referencing Name can be resolved.  Otherwise, things
+// refering to the number can be resolved.  Do this now.
+//
+static void ResolveTypeTo(char *Name, const Type *ToTy) {
+  ValID D;
+  if (Name) D = ValID::create(Name);
+  else      D = ValID::create((int)CurModule.Types.size());
+
+  std::map::iterator I =
+    CurModule.LateResolveTypes.find(D);
+  if (I != CurModule.LateResolveTypes.end()) {
+    ((DerivedType*)I->second.get())->refineAbstractTypeTo(ToTy);
+    CurModule.LateResolveTypes.erase(I);
   }
 }
 
-unsigned Type::getBitWidth() const {
-  switch (oldTy) {
-    default:
-    case LabelTy:
-    case VoidTy : return 0;
-    case BoolTy : return 1;
-    case SByteTy: case UByteTy : return 8;
-    case ShortTy: case UShortTy : return 16;
-    case IntTy: case UIntTy: case FloatTy: return 32;
-    case LongTy: case ULongTy: case DoubleTy : return 64;
-    case PointerTy: return SizeOfPointer; // global var
-    case PackedTy: 
-    case ArrayTy: 
-      return nelems * elemTy->getBitWidth();
-    case StructTy:
-    case PackedStructTy: {
-      uint64_t size = 0;
-      for (unsigned i = 0; i < elements->size(); i++) {
-        size += (*elements)[i]->getBitWidth();
-      }
-      return size;
-    }
-  }
+static std::string makeNameUnique(const std::string& Name) {
+  static unsigned UniqueNameCounter = 1;
+  std::string Result(Name);
+  Result += ".upgrd." + llvm::utostr(UniqueNameCounter++);
+  return Result;
 }
 
-const Type* Type::getIndexedType(const Value*  V) const {
-  if (isStruct()) {
-    if (V->isConstant() && V->type->isInteger()) {
-      size_t pos = V->val->find(' ') + 1;
-      if (pos < V->val->size()) {
-        uint64_t idx = atoi(V->val->substr(pos).c_str());
-        return (*elements)[idx];
-      } else {
-        yyerror("Invalid value for constant integer");
-        return 0;
+// setValueName - Set the specified value to the name given.  The name may be
+// null potentially, in which case this is a noop.  The string passed in is
+// assumed to be a malloc'd string buffer, and is free'd by this function.
+//
+static void setValueName(Value *V, char *NameStr) {
+  if (NameStr) {
+    std::string Name(NameStr);      // Copy string
+    free(NameStr);                  // Free old string
+
+    if (V->getType() == Type::VoidTy) {
+      error("Can't assign name '" + Name + "' to value with void type");
+      return;
+    }
+
+    assert(!isa(V->getType()) && "Shouldn't have SignedType Value");
+    assert(inFunctionScope() && "Must be in function scope");
+
+    // Search the function's symbol table for an existing value of this name
+    Value* Existing = 0;
+    SymbolTable &ST = CurFun.CurrentFunction->getValueSymbolTable();
+    SymbolTable::plane_const_iterator PI = ST.plane_begin(), PE =ST.plane_end();
+    for ( ; PI != PE; ++PI) {
+      SymbolTable::value_const_iterator VI = PI->second.find(Name);
+      if (VI != PI->second.end()) {
+        Existing = VI->second;
+        break;
       }
-    } else {
-      yyerror("Structure requires constant index");
-      return 0;
     }
+    if (Existing) {
+      if (Existing->getType() == V->getType()) {
+        // The type of the Existing value and the new one are the same. This
+        // is probably a type plane collapsing error. If the types involved
+        // are both integer, just rename it. Otherwise it 
+        // is a redefinition error.
+        if (!Existing->getType()->isInteger()) {
+          error("Redefinition of value named '" + Name + "' in the '" +
+                V->getType()->getDescription() + "' type plane");
+          return;
+        }
+      } 
+      // In LLVM 2.0 we don't allow names to be re-used for any values in a 
+      // function, regardless of Type. Previously re-use of names was okay as 
+      // long as they were distinct types. With type planes collapsing because
+      // of the signedness change and because of PR411, this can no longer be
+      // supported. We must search the entire symbol table for a conflicting
+      // name and make the name unique. No warning is needed as this can't 
+      // cause a problem.
+      std::string NewName = makeNameUnique(Name);
+      // We're changing the name but it will probably be used by other 
+      // instructions as operands later on. Consequently we have to retain
+      // a mapping of the renaming that we're doing.
+      RenameMapKey Key = std::make_pair(Name,V->getType());
+      CurFun.RenameMap[Key] = NewName;
+      Name = NewName;
+    }
+
+    // Set the name.
+    V->setName(Name);
   }
-  if (isArray() || isPacked() || isPointer())
-    return elemTy;
-  yyerror("Invalid type for getIndexedType");
-  return 0;
 }
 
-void Type::getSignedness(unsigned &sNum, unsigned &uNum, 
-                             UpRefStack& stack) const {
-  switch (oldTy) {
-    default:
-    case OpaqueTy: case LabelTy: case VoidTy: case BoolTy: 
-    case FloatTy : case DoubleTy: case UpRefTy:
-      return;
-    case SByteTy: case ShortTy: case LongTy: case IntTy: 
-      sNum++;
-      return;
-    case UByteTy: case UShortTy: case UIntTy: case ULongTy: 
-      uNum++;
-      return;
-    case PointerTy:
-    case PackedTy: 
-    case ArrayTy:
-      stack.push_back(this);
-      elemTy->getSignedness(sNum, uNum, stack);
-      return;
-    case StructTy:
-    case PackedStructTy: {
-      stack.push_back(this);
-      for (unsigned i = 0; i < elements->size(); i++) {
-        (*elements)[i]->getSignedness(sNum, uNum, stack);
+/// ParseGlobalVariable - Handle parsing of a global.  If Initializer is null,
+/// this is a declaration, otherwise it is a definition.
+static GlobalVariable *
+ParseGlobalVariable(char *NameStr,GlobalValue::LinkageTypes Linkage,
+                    bool isConstantGlobal, const Type *Ty,
+                    Constant *Initializer) {
+  if (isa(Ty))
+    error("Cannot declare global vars of function type");
+
+  const PointerType *PTy = PointerType::get(Ty);
+
+  std::string Name;
+  if (NameStr) {
+    Name = NameStr;      // Copy string
+    free(NameStr);       // Free old string
+  }
+
+  // See if this global value was forward referenced.  If so, recycle the
+  // object.
+  ValID ID;
+  if (!Name.empty()) {
+    ID = ValID::create((char*)Name.c_str());
+  } else {
+    ID = ValID::create((int)CurModule.Values[PTy].size());
+  }
+
+  if (GlobalValue *FWGV = CurModule.GetForwardRefForGlobal(PTy, ID)) {
+    // Move the global to the end of the list, from whereever it was
+    // previously inserted.
+    GlobalVariable *GV = cast(FWGV);
+    CurModule.CurrentModule->getGlobalList().remove(GV);
+    CurModule.CurrentModule->getGlobalList().push_back(GV);
+    GV->setInitializer(Initializer);
+    GV->setLinkage(Linkage);
+    GV->setConstant(isConstantGlobal);
+    InsertValue(GV, CurModule.Values);
+    return GV;
+  }
+
+  // If this global has a name, check to see if there is already a definition
+  // of this global in the module and emit warnings if there are conflicts.
+  if (!Name.empty()) {
+    // The global has a name. See if there's an existing one of the same name.
+    if (CurModule.CurrentModule->getNamedGlobal(Name)) {
+      // We found an existing global ov the same name. This isn't allowed 
+      // in LLVM 2.0. Consequently, we must alter the name of the global so it
+      // can at least compile. This can happen because of type planes 
+      // There is alread a global of the same name which means there is a
+      // conflict. Let's see what we can do about it.
+      std::string NewName(makeNameUnique(Name));
+      if (Linkage == GlobalValue::InternalLinkage) {
+        // The linkage type is internal so just warn about the rename without
+        // invoking "scarey language" about linkage failures. GVars with
+        // InternalLinkage can be renamed at will.
+        warning("Global variable '" + Name + "' was renamed to '"+ 
+                NewName + "'");
+      } else {
+        // The linkage of this gval is external so we can't reliably rename 
+        // it because it could potentially create a linking problem.  
+        // However, we can't leave the name conflict in the output either or 
+        // it won't assemble with LLVM 2.0.  So, all we can do is rename 
+        // this one to something unique and emit a warning about the problem.
+        warning("Renaming global variable '" + Name + "' to '" + NewName + 
+                  "' may cause linkage errors");
       }
-      return;
-    }
-    case UnresolvedTy: {
-      const Type* Ty = this->resolve();
-      // Let's not recurse.
-      UpRefStack::const_iterator I = stack.begin(), E = stack.end();
-      for ( ; I != E && *I != Ty; ++I) 
-        ;
-      if (I == E)
-        Ty->getSignedness(sNum, uNum, stack);
-      return;
+
+      // Put the renaming in the global rename map
+      RenameMapKey Key = std::make_pair(Name,PointerType::get(Ty));
+      CurModule.RenameMap[Key] = NewName;
+
+      // Rename it
+      Name = NewName;
     }
   }
-}
 
-std::string AddSuffix(const std::string& Name, const std::string& Suffix) {
-  if (Name[Name.size()-1] == '"') {
-    std::string Result = Name;
-    Result.insert(Result.size()-1, Suffix);
-    return Result;
-  }
-  return Name + Suffix;
+  // Otherwise there is no existing GV to use, create one now.
+  GlobalVariable *GV =
+    new GlobalVariable(Ty, isConstantGlobal, Linkage, Initializer, Name,
+                       CurModule.CurrentModule);
+  InsertValue(GV, CurModule.Values);
+  return GV;
 }
 
-std::string Type::makeUniqueName(const std::string& BaseName) const {
-  if (BaseName == "\"alloca point\"")
-    return BaseName;
-  switch (oldTy) {
-    default:
-      break;
-    case OpaqueTy: case LabelTy: case VoidTy: case BoolTy: case UpRefTy:
-    case FloatTy : case DoubleTy: case UnresolvedTy:
-      return BaseName;
-    case SByteTy: case ShortTy: case LongTy: case IntTy: 
-      return AddSuffix(BaseName, ".s");
-    case UByteTy: case UShortTy: case UIntTy: case ULongTy: 
-      return AddSuffix(BaseName, ".u");
-  }
-
-  unsigned uNum = 0, sNum = 0;
-  std::string Suffix;
-  switch (oldTy) {
-    case PointerTy:
-    case PackedTy: 
-    case ArrayTy: {
-      Type::UpRefStack stack;
-      elemTy->resolve()->getSignedness(sNum, uNum, stack);
-      break;
-    }
-    case StructTy:
-    case PackedStructTy: {
-      for (unsigned i = 0; i < elements->size(); i++) {
-        Type::UpRefStack stack;
-        (*elements)[i]->resolve()->getSignedness(sNum, uNum, stack);
-      }
-      break;
-    }
-    default:
-      assert(0 && "Invalid Type");
-      break;
+// setTypeName - Set the specified type to the name given.  The name may be
+// null potentially, in which case this is a noop.  The string passed in is
+// assumed to be a malloc'd string buffer, and is freed by this function.
+//
+// This function returns true if the type has already been defined, but is
+// allowed to be redefined in the specified context.  If the name is a new name
+// for the type plane, it is inserted and false is returned.
+static bool setTypeName(const Type *T, char *NameStr) {
+  assert(!inFunctionScope() && "Can't give types function-local names");
+  if (NameStr == 0) return false;
+ 
+  std::string Name(NameStr);      // Copy string
+  free(NameStr);                  // Free old string
+
+  // We don't allow assigning names to void type
+  if (T == Type::VoidTy) {
+    error("Can't assign name '" + Name + "' to the void type");
+    return false;
   }
 
-  if (sNum == 0 && uNum == 0)
-    return BaseName;
+  // Set the type name, checking for conflicts as we do so.
+  bool AlreadyExists = CurModule.CurrentModule->addTypeName(Name, T);
 
-  switch (oldTy) {
-    default:             Suffix += ".nada"; break;
-    case PointerTy:      Suffix += ".pntr"; break;
-    case PackedTy:       Suffix += ".pckd"; break;
-    case ArrayTy:        Suffix += ".arry"; break;
-    case StructTy:       Suffix += ".strc"; break;
-    case PackedStructTy: Suffix += ".pstr"; break;
-  }
-
-  Suffix += ".s" + llvm::utostr(sNum);
-  Suffix += ".u" + llvm::utostr(uNum);
-  return AddSuffix(BaseName, Suffix);
-}
-
-Type& Type::operator=(const Type& that) {
-  oldTy = that.oldTy;
-  nelems = that.nelems;
-  newTy = that.newTy;
-  elemTy = that.elemTy;
-  resultTy = that.resultTy;
-  if (that.elements) {
-    elements = new TypeList(that.elements->size());
-    *elements = *that.elements;
-  } else {
-    elements = 0;
+  if (AlreadyExists) {   // Inserting a name that is already defined???
+    const Type *Existing = CurModule.CurrentModule->getTypeByName(Name);
+    assert(Existing && "Conflict but no matching type?");
+
+    // There is only one case where this is allowed: when we are refining an
+    // opaque type.  In this case, Existing will be an opaque type.
+    if (const OpaqueType *OpTy = dyn_cast(Existing)) {
+      // We ARE replacing an opaque type!
+      const_cast(OpTy)->refineAbstractTypeTo(T);
+      return true;
+    }
+
+    // Otherwise, this is an attempt to redefine a type. That's okay if
+    // the redefinition is identical to the original. This will be so if
+    // Existing and T point to the same Type object. In this one case we
+    // allow the equivalent redefinition.
+    if (Existing == T) return true;  // Yes, it's equal.
+
+    // Any other kind of (non-equivalent) redefinition is an error.
+    error("Redefinition of type named '" + Name + "' in the '" +
+          T->getDescription() + "' type plane");
   }
-  return *this;
+
+  return false;
 }
 
-const Type* Type::add_new_type(Type* newTy) {
-  TypeRegMap::iterator I = registry.find(newTy);
-  if (I != registry.end()) {
-    delete newTy;
-    return *I;
-  }
-  registry.insert(newTy);
-  return newTy;
-}
-
-class Instruction {
-};
-
-/// This type is used to keep track of the signedness of constants.
-struct Constant {
-  std::string *cnst;
-  const Type *type;
-  ~Constant() { delete cnst; }
-};
-
-/// This variable provides a counter for unique names. It is used in various
-/// productions to ensure a unique name is generated.
-static uint64_t UniqueNameCounter = 1;
-
-// This is set when a DECLARE keyword is recognized so that subsequent parsing
-// of a function prototype can know if its a declaration or definition.
-static bool isDeclare = false;
-
-// This bool is used to communicate between the InstVal and Inst rules about
-// whether or not a cast should be deleted. When the flag is set, InstVal has
-// determined that the cast is a candidate. However, it can only be deleted if
-// the value being casted is the same value name as the instruction. The Inst
-// rule makes that comparison if the flag is set and comments out the
-// instruction if they match.
-static bool deleteUselessCastFlag = false;
-static std::string* deleteUselessCastName = 0;
+//===----------------------------------------------------------------------===//
+// Code for handling upreferences in type names...
+//
 
+// TypeContains - Returns true if Ty directly contains E in it.
+//
+static bool TypeContains(const Type *Ty, const Type *E) {
+  return std::find(Ty->subtype_begin(), Ty->subtype_end(),
+                   E) != Ty->subtype_end();
+}
+
+namespace {
+  struct UpRefRecord {
+    // NestingLevel - The number of nesting levels that need to be popped before
+    // this type is resolved.
+    unsigned NestingLevel;
+
+    // LastContainedTy - This is the type at the current binding level for the
+    // type.  Every time we reduce the nesting level, this gets updated.
+    const Type *LastContainedTy;
+
+    // UpRefTy - This is the actual opaque type that the upreference is
+    // represented with.
+    OpaqueType *UpRefTy;
+
+    UpRefRecord(unsigned NL, OpaqueType *URTy)
+      : NestingLevel(NL), LastContainedTy(URTy), UpRefTy(URTy) {}
+  };
+}
 
+// UpRefs - A list of the outstanding upreferences that need to be resolved.
+static std::vector UpRefs;
+
+/// HandleUpRefs - Every time we finish a new layer of types, this function is
+/// called.  It loops through the UpRefs vector, which is a list of the
+/// currently active types.  For each type, if the up reference is contained in
+/// the newly completed type, we decrement the level count.  When the level
+/// count reaches zero, the upreferenced type is the type that is passed in:
+/// thus we can complete the cycle.
+///
+static PATypeHolder HandleUpRefs(const Type *ty) {
+  // If Ty isn't abstract, or if there are no up-references in it, then there is
+  // nothing to resolve here.
+  if (!ty->isAbstract() || UpRefs.empty()) return ty;
+  
+  PATypeHolder Ty(ty);
+  UR_OUT("Type '" << Ty->getDescription() <<
+         "' newly formed.  Resolving upreferences.\n" <<
+         UpRefs.size() << " upreferences active!\n");
+
+  // If we find any resolvable upreferences (i.e., those whose NestingLevel goes
+  // to zero), we resolve them all together before we resolve them to Ty.  At
+  // the end of the loop, if there is anything to resolve to Ty, it will be in
+  // this variable.
+  OpaqueType *TypeToResolve = 0;
+
+  for (unsigned i = 0; i != UpRefs.size(); ++i) {
+    UR_OUT("  UR#" << i << " - TypeContains(" << Ty->getDescription() << ", "
+           << UpRefs[i].second->getDescription() << ") = "
+           << (TypeContains(Ty, UpRefs[i].second) ? "true" : "false") << "\n");
+    if (TypeContains(Ty, UpRefs[i].LastContainedTy)) {
+      // Decrement level of upreference
+      unsigned Level = --UpRefs[i].NestingLevel;
+      UpRefs[i].LastContainedTy = Ty;
+      UR_OUT("  Uplevel Ref Level = " << Level << "\n");
+      if (Level == 0) {                     // Upreference should be resolved!
+        if (!TypeToResolve) {
+          TypeToResolve = UpRefs[i].UpRefTy;
+        } else {
+          UR_OUT("  * Resolving upreference for "
+                 << UpRefs[i].second->getDescription() << "\n";
+                 std::string OldName = UpRefs[i].UpRefTy->getDescription());
+          UpRefs[i].UpRefTy->refineAbstractTypeTo(TypeToResolve);
+          UR_OUT("  * Type '" << OldName << "' refined upreference to: "
+                 << (const void*)Ty << ", " << Ty->getDescription() << "\n");
+        }
+        UpRefs.erase(UpRefs.begin()+i);     // Remove from upreference list...
+        --i;                                // Do not skip the next element...
+      }
+    }
+  }
 
-const char* getCastOpcode(std::string& Source, const Type* SrcTy, 
-                          const Type* DstTy) {
-  unsigned SrcBits = SrcTy->getBitWidth();
-  unsigned DstBits = DstTy->getBitWidth();
-  const char* opcode = "bitcast";
-  // Run through the possibilities ...
-  if (DstTy->isIntegral()) {                        // Casting to integral
-    if (SrcTy->isIntegral()) {                      // Casting from integral
-      if (DstBits < SrcBits)
-        opcode = "trunc";
-      else if (DstBits > SrcBits) {                // its an extension
-        if (SrcTy->isSigned())
-          opcode ="sext";                          // signed -> SEXT
+  if (TypeToResolve) {
+    UR_OUT("  * Resolving upreference for "
+           << UpRefs[i].second->getDescription() << "\n";
+           std::string OldName = TypeToResolve->getDescription());
+    TypeToResolve->refineAbstractTypeTo(Ty);
+  }
+
+  return Ty;
+}
+
+static inline Instruction::TermOps 
+getTermOp(TermOps op) {
+  switch (op) {
+    default           : assert(0 && "Invalid OldTermOp");
+    case RetOp        : return Instruction::Ret;
+    case BrOp         : return Instruction::Br;
+    case SwitchOp     : return Instruction::Switch;
+    case InvokeOp     : return Instruction::Invoke;
+    case UnwindOp     : return Instruction::Unwind;
+    case UnreachableOp: return Instruction::Unreachable;
+  }
+}
+
+static inline Instruction::BinaryOps 
+getBinaryOp(BinaryOps op, const Type *Ty, Signedness Sign) {
+  switch (op) {
+    default     : assert(0 && "Invalid OldBinaryOps");
+    case SetEQ  : 
+    case SetNE  : 
+    case SetLE  :
+    case SetGE  :
+    case SetLT  :
+    case SetGT  : assert(0 && "Should use getCompareOp");
+    case AddOp  : return Instruction::Add;
+    case SubOp  : return Instruction::Sub;
+    case MulOp  : return Instruction::Mul;
+    case DivOp  : {
+      // This is an obsolete instruction so we must upgrade it based on the
+      // types of its operands.
+      bool isFP = Ty->isFloatingPoint();
+      if (const PackedType* PTy = dyn_cast(Ty))
+        // If its a packed type we want to use the element type
+        isFP = PTy->getElementType()->isFloatingPoint();
+      if (isFP)
+        return Instruction::FDiv;
+      else if (Sign == Signed)
+        return Instruction::SDiv;
+      return Instruction::UDiv;
+    }
+    case UDivOp : return Instruction::UDiv;
+    case SDivOp : return Instruction::SDiv;
+    case FDivOp : return Instruction::FDiv;
+    case RemOp  : {
+      // This is an obsolete instruction so we must upgrade it based on the
+      // types of its operands.
+      bool isFP = Ty->isFloatingPoint();
+      if (const PackedType* PTy = dyn_cast(Ty))
+        // If its a packed type we want to use the element type
+        isFP = PTy->getElementType()->isFloatingPoint();
+      // Select correct opcode
+      if (isFP)
+        return Instruction::FRem;
+      else if (Sign == Signed)
+        return Instruction::SRem;
+      return Instruction::URem;
+    }
+    case URemOp : return Instruction::URem;
+    case SRemOp : return Instruction::SRem;
+    case FRemOp : return Instruction::FRem;
+    case AndOp  : return Instruction::And;
+    case OrOp   : return Instruction::Or;
+    case XorOp  : return Instruction::Xor;
+  }
+}
+
+static inline Instruction::OtherOps 
+getCompareOp(BinaryOps op, unsigned short &predicate, const Type* &Ty,
+             Signedness Sign) {
+  bool isSigned = Sign == Signed;
+  bool isFP = Ty->isFloatingPoint();
+  switch (op) {
+    default     : assert(0 && "Invalid OldSetCC");
+    case SetEQ  : 
+      if (isFP) {
+        predicate = FCmpInst::FCMP_OEQ;
+        return Instruction::FCmp;
+      } else {
+        predicate = ICmpInst::ICMP_EQ;
+        return Instruction::ICmp;
+      }
+    case SetNE  : 
+      if (isFP) {
+        predicate = FCmpInst::FCMP_UNE;
+        return Instruction::FCmp;
+      } else {
+        predicate = ICmpInst::ICMP_NE;
+        return Instruction::ICmp;
+      }
+    case SetLE  : 
+      if (isFP) {
+        predicate = FCmpInst::FCMP_OLE;
+        return Instruction::FCmp;
+      } else {
+        if (isSigned)
+          predicate = ICmpInst::ICMP_SLE;
         else
-          opcode = "zext";                         // unsigned -> ZEXT
+          predicate = ICmpInst::ICMP_ULE;
+        return Instruction::ICmp;
+      }
+    case SetGE  : 
+      if (isFP) {
+        predicate = FCmpInst::FCMP_OGE;
+        return Instruction::FCmp;
       } else {
-        opcode = "bitcast";                        // Same size, No-op cast
+        if (isSigned)
+          predicate = ICmpInst::ICMP_SGE;
+        else
+          predicate = ICmpInst::ICMP_UGE;
+        return Instruction::ICmp;
+      }
+    case SetLT  : 
+      if (isFP) {
+        predicate = FCmpInst::FCMP_OLT;
+        return Instruction::FCmp;
+      } else {
+        if (isSigned)
+          predicate = ICmpInst::ICMP_SLT;
+        else
+          predicate = ICmpInst::ICMP_ULT;
+        return Instruction::ICmp;
+      }
+    case SetGT  : 
+      if (isFP) {
+        predicate = FCmpInst::FCMP_OGT;
+        return Instruction::FCmp;
+      } else {
+        if (isSigned)
+          predicate = ICmpInst::ICMP_SGT;
+        else
+          predicate = ICmpInst::ICMP_UGT;
+        return Instruction::ICmp;
       }
-    } else if (SrcTy->isFloatingPoint()) {          // Casting from floating pt
-      if (DstTy->isSigned()) 
-        opcode = "fptosi";                         // FP -> sint
-      else
-        opcode = "fptoui";                         // FP -> uint 
-    } else if (SrcTy->isPacked()) {
-      assert(DstBits == SrcTy->getBitWidth() &&
-               "Casting packed to integer of different width");
-        opcode = "bitcast";                        // same size, no-op cast
-    } else {
-      assert(SrcTy->isPointer() &&
-             "Casting from a value that is not first-class type");
-      opcode = "ptrtoint";                         // ptr -> int
-    }
-  } else if (DstTy->isFloatingPoint()) {           // Casting to floating pt
-    if (SrcTy->isIntegral()) {                     // Casting from integral
-      if (SrcTy->isSigned())
-        opcode = "sitofp";                         // sint -> FP
-      else
-        opcode = "uitofp";                         // uint -> FP
-    } else if (SrcTy->isFloatingPoint()) {         // Casting from floating pt
-      if (DstBits < SrcBits) {
-        opcode = "fptrunc";                        // FP -> smaller FP
-      } else if (DstBits > SrcBits) {
-        opcode = "fpext";                          // FP -> larger FP
-      } else  {
-        opcode ="bitcast";                         // same size, no-op cast
-      }
-    } else if (SrcTy->isPacked()) {
-      assert(DstBits == SrcTy->getBitWidth() &&
-             "Casting packed to floating point of different width");
-        opcode = "bitcast";                        // same size, no-op cast
-    } else {
-      assert(0 && "Casting pointer or non-first class to float");
-    }
-  } else if (DstTy->isPacked()) {
-    if (SrcTy->isPacked()) {
-      assert(DstTy->getBitWidth() == SrcTy->getBitWidth() &&
-             "Casting packed to packed of different widths");
-      opcode = "bitcast";                          // packed -> packed
-    } else if (DstTy->getBitWidth() == SrcBits) {
-      opcode = "bitcast";                          // float/int -> packed
-    } else {
-      assert(!"Illegal cast to packed (wrong type or size)");
-    }
-  } else if (DstTy->isPointer()) {
-    if (SrcTy->isPointer()) {
-      opcode = "bitcast";                          // ptr -> ptr
-    } else if (SrcTy->isIntegral()) {
-      opcode = "inttoptr";                         // int -> ptr
-    } else {
-      assert(!"Casting invalid type to pointer");
-    }
-  } else {
-    assert(!"Casting to type that is not first-class");
   }
-  return opcode;
 }
 
-std::string getCastUpgrade(const std::string& Src, const Type* SrcTy,
-                           const Type* DstTy, bool isConst) {
-  std::string Result;
-  std::string Source = Src;
-  if (SrcTy->isFloatingPoint() && DstTy->isPointer()) {
-    // fp -> ptr cast is no longer supported but we must upgrade this
-    // by doing a double cast: fp -> int -> ptr
-    if (isConst)
-      Source = "i64 fptoui(" + Source + " to i64)";
-    else {
-      *O << "    %cast_upgrade" << UniqueNameCounter << " = fptoui " 
-         << Source << " to i64\n";
-      Source = "i64 %cast_upgrade" + llvm::utostr(UniqueNameCounter++);
-    }
-    // Update the SrcTy for the getCastOpcode call below
-    SrcTy = Type::get("i64", ULongTy);
-  } else if (DstTy->isBool()) {
-    // cast type %x to bool was previously defined as setne type %x, null
-    // The cast semantic is now to truncate, not compare so we must retain
-    // the original intent by replacing the cast with a setne
-    const char* comparator = SrcTy->isPointer() ? ", null" : 
-      (SrcTy->isFloatingPoint() ? ", 0.0" : 
-       (SrcTy->isBool() ? ", false" : ", 0"));
-    const char* compareOp = SrcTy->isFloatingPoint() ? "fcmp one " : "icmp ne ";
-    if (isConst) { 
-      Result = "(" + Source + comparator + ")";
-      Result = compareOp + Result;
-    } else
-      Result = compareOp + Source + comparator;
-    return Result; // skip cast processing below
+static inline Instruction::MemoryOps getMemoryOp(MemoryOps op) {
+  switch (op) {
+    default              : assert(0 && "Invalid OldMemoryOps");
+    case MallocOp        : return Instruction::Malloc;
+    case FreeOp          : return Instruction::Free;
+    case AllocaOp        : return Instruction::Alloca;
+    case LoadOp          : return Instruction::Load;
+    case StoreOp         : return Instruction::Store;
+    case GetElementPtrOp : return Instruction::GetElementPtr;
   }
-  SrcTy = SrcTy->resolve();
-  DstTy = DstTy->resolve();
-  std::string Opcode(getCastOpcode(Source, SrcTy, DstTy));
-  if (isConst)
-    Result += Opcode + "( " + Source + " to " + DstTy->getNewTy() + ")";
-  else
-    Result += Opcode + " " + Source + " to " + DstTy->getNewTy();
-  return Result;
 }
 
-const char* getDivRemOpcode(const std::string& opcode, const Type* TI) {
-  const char* op = opcode.c_str();
-  const Type* Ty = TI->resolve();
-  if (Ty->isPacked())
-    Ty = Ty->getElementType();
-  if (opcode == "div")
-    if (Ty->isFloatingPoint())
-      op = "fdiv";
-    else if (Ty->isUnsigned())
-      op = "udiv";
-    else if (Ty->isSigned())
-      op = "sdiv";
-    else
-      yyerror("Invalid type for div instruction");
-  else if (opcode == "rem")
-    if (Ty->isFloatingPoint())
-      op = "frem";
-    else if (Ty->isUnsigned())
-      op = "urem";
-    else if (Ty->isSigned())
-      op = "srem";
-    else
-      yyerror("Invalid type for rem instruction");
-  return op;
-}
-
-std::string getCompareOp(const std::string& setcc, const Type* TI) {
-  assert(setcc.length() == 5);
-  char cc1 = setcc[3];
-  char cc2 = setcc[4];
-  assert(cc1 == 'e' || cc1 == 'n' || cc1 == 'l' || cc1 == 'g');
-  assert(cc2 == 'q' || cc2 == 'e' || cc2 == 'e' || cc2 == 't');
-  std::string result("xcmp xxx");
-  result[6] = cc1;
-  result[7] = cc2;
-  if (TI->isFloatingPoint()) {
-    result[0] = 'f';
-    result[5] = 'o';
-    if (cc1 == 'n')
-      result[5] = 'u'; // NE maps to unordered
-    else
-      result[5] = 'o'; // everything else maps to ordered
-  } else if (TI->isIntegral() || TI->isPointer()) {
-    result[0] = 'i';
-    if ((cc1 == 'e' && cc2 == 'q') || (cc1 == 'n' && cc2 == 'e'))
-      result.erase(5,1);
-    else if (TI->isSigned())
-      result[5] = 's';
-    else if (TI->isUnsigned() || TI->isPointer() || TI->isBool())
-      result[5] = 'u';
-    else
-      yyerror("Invalid integral type for setcc");
-  }
-  return result;
+static inline Instruction::OtherOps 
+getOtherOp(OtherOps op, Signedness Sign) {
+  switch (op) {
+    default               : assert(0 && "Invalid OldOtherOps");
+    case PHIOp            : return Instruction::PHI;
+    case CallOp           : return Instruction::Call;
+    case ShlOp            : return Instruction::Shl;
+    case ShrOp            : 
+      if (Sign == Signed)
+        return Instruction::AShr;
+      return Instruction::LShr;
+    case SelectOp         : return Instruction::Select;
+    case UserOp1          : return Instruction::UserOp1;
+    case UserOp2          : return Instruction::UserOp2;
+    case VAArg            : return Instruction::VAArg;
+    case ExtractElementOp : return Instruction::ExtractElement;
+    case InsertElementOp  : return Instruction::InsertElement;
+    case ShuffleVectorOp  : return Instruction::ShuffleVector;
+    case ICmpOp           : return Instruction::ICmp;
+    case FCmpOp           : return Instruction::FCmp;
+    case LShrOp           : return Instruction::LShr;
+    case AShrOp           : return Instruction::AShr;
+  };
 }
 
-const Type* getFunctionReturnType(const Type* PFTy) {
-  PFTy = PFTy->resolve();
-  if (PFTy->isPointer()) {
-    const Type* ElemTy = PFTy->getElementType();
-    ElemTy = ElemTy->resolve();
-    if (ElemTy->isFunction())
-      return ElemTy->getResultType();
-  } else if (PFTy->isFunction()) {
-    return PFTy->getResultType();
-  }
-  return PFTy;
-}
-
-const Type* ResolveUpReference(const Type* Ty, 
-                                   Type::UpRefStack* stack) {
-  assert(Ty->isUpReference() && "Can't resolve a non-upreference");
-  unsigned upref = Ty->getUpRefNum();
-  assert(upref < stack->size() && "Invalid up reference");
-  return (*stack)[upref - stack->size() - 1];
-}
-
-const Type* getGEPIndexedType(const Type* PTy, ValueList* idxs) {
-  const Type* Result = PTy = PTy->resolve();
-  assert(PTy->isPointer() && "GEP Operand is not a pointer?");
-  Type::UpRefStack stack;
-  for (unsigned i = 0; i < idxs->size(); ++i) {
-    if (Result->isComposite()) {
-      Result = Result->getIndexedType((*idxs)[i]);
-      Result = Result->resolve();
-      stack.push_back(Result);
-    } else
-      yyerror("Invalid type for index");
-  }
-  // Resolve upreferences so we can return a more natural type
-  if (Result->isPointer()) {
-    if (Result->getElementType()->isUpReference()) {
-      stack.push_back(Result);
-      Result = ResolveUpReference(Result->getElementType(), &stack);
+static inline Value*
+getCast(CastOps op, Value *Src, Signedness SrcSign, const Type *DstTy, 
+        Signedness DstSign, bool ForceInstruction = false) {
+  Instruction::CastOps Opcode;
+  const Type* SrcTy = Src->getType();
+  if (op == CastOp) {
+    if (SrcTy->isFloatingPoint() && isa(DstTy)) {
+      // fp -> ptr cast is no longer supported but we must upgrade this
+      // by doing a double cast: fp -> int -> ptr
+      SrcTy = Type::Int64Ty;
+      Opcode = Instruction::IntToPtr;
+      if (isa(Src)) {
+        Src = ConstantExpr::getCast(Instruction::FPToUI, 
+                                     cast(Src), SrcTy);
+      } else {
+        std::string NewName(makeNameUnique(Src->getName()));
+        Src = new FPToUIInst(Src, SrcTy, NewName, CurBB);
+      }
+    } else if (isa(DstTy) &&
+               cast(DstTy)->getBitWidth() == 1) {
+      // cast type %x to bool was previously defined as setne type %x, null
+      // The cast semantic is now to truncate, not compare so we must retain
+      // the original intent by replacing the cast with a setne
+      Constant* Null = Constant::getNullValue(SrcTy);
+      Instruction::OtherOps Opcode = Instruction::ICmp;
+      unsigned short predicate = ICmpInst::ICMP_NE;
+      if (SrcTy->isFloatingPoint()) {
+        Opcode = Instruction::FCmp;
+        predicate = FCmpInst::FCMP_ONE;
+      } else if (!SrcTy->isInteger() && !isa(SrcTy)) {
+        error("Invalid cast to bool");
+      }
+      if (isa(Src) && !ForceInstruction)
+        return ConstantExpr::getCompare(predicate, cast(Src), Null);
+      else
+        return CmpInst::create(Opcode, predicate, Src, Null);
+    }
+    // Determine the opcode to use by calling CastInst::getCastOpcode
+    Opcode = 
+      CastInst::getCastOpcode(Src, SrcSign == Signed, DstTy, DstSign == Signed);
+
+  } else switch (op) {
+    default: assert(0 && "Invalid cast token");
+    case TruncOp:    Opcode = Instruction::Trunc; break;
+    case ZExtOp:     Opcode = Instruction::ZExt; break;
+    case SExtOp:     Opcode = Instruction::SExt; break;
+    case FPTruncOp:  Opcode = Instruction::FPTrunc; break;
+    case FPExtOp:    Opcode = Instruction::FPExt; break;
+    case FPToUIOp:   Opcode = Instruction::FPToUI; break;
+    case FPToSIOp:   Opcode = Instruction::FPToSI; break;
+    case UIToFPOp:   Opcode = Instruction::UIToFP; break;
+    case SIToFPOp:   Opcode = Instruction::SIToFP; break;
+    case PtrToIntOp: Opcode = Instruction::PtrToInt; break;
+    case IntToPtrOp: Opcode = Instruction::IntToPtr; break;
+    case BitCastOp:  Opcode = Instruction::BitCast; break;
+  }
+
+  if (isa(Src) && !ForceInstruction)
+    return ConstantExpr::getCast(Opcode, cast(Src), DstTy);
+  return CastInst::create(Opcode, Src, DstTy);
+}
+
+static Instruction *
+upgradeIntrinsicCall(const Type* RetTy, const ValID &ID, 
+                     std::vector& Args) {
+
+  std::string Name = ID.Type == ValID::NameVal ? ID.Name : "";
+  if (Name == "llvm.isunordered.f32" || Name == "llvm.isunordered.f64") {
+    if (Args.size() != 2)
+      error("Invalid prototype for " + Name + " prototype");
+    return new FCmpInst(FCmpInst::FCMP_UNO, Args[0], Args[1]);
+  } else {
+    static unsigned upgradeCount = 1;
+    const Type* PtrTy = PointerType::get(Type::Int8Ty);
+    std::vector Params;
+    if (Name == "llvm.va_start" || Name == "llvm.va_end") {
+      if (Args.size() != 1)
+        error("Invalid prototype for " + Name + " prototype");
+      Params.push_back(PtrTy);
+      const FunctionType *FTy = FunctionType::get(Type::VoidTy, Params, false);
+      const PointerType *PFTy = PointerType::get(FTy);
+      Value* Func = getVal(PFTy, ID);
+      std::string InstName("va_upgrade");
+      InstName += llvm::utostr(upgradeCount++);
+      Args[0] = new BitCastInst(Args[0], PtrTy, InstName, CurBB);
+      return new CallInst(Func, Args);
+    } else if (Name == "llvm.va_copy") {
+      if (Args.size() != 2)
+        error("Invalid prototype for " + Name + " prototype");
+      Params.push_back(PtrTy);
+      Params.push_back(PtrTy);
+      const FunctionType *FTy = FunctionType::get(Type::VoidTy, Params, false);
+      const PointerType *PFTy = PointerType::get(FTy);
+      Value* Func = getVal(PFTy, ID);
+      std::string InstName0("va_upgrade");
+      InstName0 += llvm::utostr(upgradeCount++);
+      std::string InstName1("va_upgrade");
+      InstName1 += llvm::utostr(upgradeCount++);
+      Args[0] = new BitCastInst(Args[0], PtrTy, InstName0, CurBB);
+      Args[1] = new BitCastInst(Args[1], PtrTy, InstName1, CurBB);
+      return new CallInst(Func, Args);
     }
-  } else if (Result->isUpReference()) {
-    Result = ResolveUpReference(Result->getElementType(), &stack);
   }
-  return Result->getPointerType();
+  return 0;
 }
 
-// This function handles appending .u or .s to integer value names that
-// were previously unsigned or signed, respectively. This avoids name
-// collisions since the unsigned and signed type planes have collapsed
-// into a single signless type plane.
-std::string getUniqueName(const std::string *Name, const Type* Ty,
-                          bool isGlobal = false, bool isDef = false) {
+const Type* upgradeGEPIndices(const Type* PTy, 
+                       std::vector *Indices, 
+                       std::vector    &VIndices, 
+                       std::vector *CIndices = 0) {
+  // Traverse the indices with a gep_type_iterator so we can build the list
+  // of constant and value indices for use later. Also perform upgrades
+  VIndices.clear();
+  if (CIndices) CIndices->clear();
+  for (unsigned i = 0, e = Indices->size(); i != e; ++i)
+    VIndices.push_back((*Indices)[i].V);
+  generic_gep_type_iterator::iterator>
+    GTI = gep_type_begin(PTy, VIndices.begin(),  VIndices.end()),
+    GTE = gep_type_end(PTy,  VIndices.begin(),  VIndices.end());
+  for (unsigned i = 0, e = Indices->size(); i != e && GTI != GTE; ++i, ++GTI) {
+    Value *Index = VIndices[i];
+    if (CIndices && !isa(Index))
+      error("Indices to constant getelementptr must be constants");
+    // LLVM 1.2 and earlier used ubyte struct indices.  Convert any ubyte 
+    // struct indices to i32 struct indices with ZExt for compatibility.
+    else if (isa(*GTI)) {        // Only change struct indices
+      if (ConstantInt *CUI = dyn_cast(Index))
+        if (CUI->getType()->getBitWidth() == 8)
+          Index = 
+            ConstantExpr::getCast(Instruction::ZExt, CUI, Type::Int32Ty);
+    } else {
+      // Make sure that unsigned SequentialType indices are zext'd to 
+      // 64-bits if they were smaller than that because LLVM 2.0 will sext 
+      // all indices for SequentialType elements. We must retain the same 
+      // semantic (zext) for unsigned types.
+      if (const IntegerType *Ity = dyn_cast(Index->getType()))
+        if (Ity->getBitWidth() < 64 && (*Indices)[i].S == Unsigned)
+          if (CIndices)
+            Index = ConstantExpr::getCast(Instruction::ZExt, 
+              cast(Index), Type::Int64Ty);
+          else
+            Index = CastInst::create(Instruction::ZExt, Index, Type::Int64Ty,
+              "gep_upgrade", CurBB);
+    }
+    // Add to the CIndices list, if requested.
+    if (CIndices)
+      CIndices->push_back(cast(Index));
+  }
+
+  const Type *IdxTy =
+    GetElementPtrInst::getIndexedType(PTy, VIndices, true);
+    if (!IdxTy)
+      error("Index list invalid for constant getelementptr");
+  return IdxTy;
+}
 
-  // If its not a symbolic name, don't modify it, probably a constant val.
-  if ((*Name)[0] != '%' && (*Name)[0] != '"')
-    return *Name;
+Module* UpgradeAssembly(const std::string &infile, std::istream& in, 
+                              bool debug, bool addAttrs)
+{
+  Upgradelineno = 1; 
+  CurFilename = infile;
+  LexInput = ∈
+  yydebug = debug;
+  AddAttributes = addAttrs;
+  ObsoleteVarArgs = false;
+  NewVarArgs = false;
 
-  // If its a numeric reference, just leave it alone.
-  if (isdigit((*Name)[1]))
-    return *Name;
+  CurModule.CurrentModule = new Module(CurFilename);
 
-  // Resolve the type
-  Ty = Ty->resolve(); 
+  // Check to make sure the parser succeeded
+  if (yyparse()) {
+    if (ParserResult)
+      delete ParserResult;
+    std::cerr << "llvm-upgrade: parse failed.\n";
+    return 0;
+  }
 
-  // If its a global name, get its uniquified name, if any
-  Type::GlobalsTypeMap::iterator GI = Type::Globals.find(*Name);
-  if (GI != Type::Globals.end()) {
-    Type::TypePlaneMap::iterator TPI = GI->second.begin();
-    Type::TypePlaneMap::iterator TPE = GI->second.end();
-    for ( ; TPI != TPE ; ++TPI) {
-      if (TPI->first->sameNewTyAs(Ty)) 
-        return TPI->second;
-    }
+  // Check to make sure that parsing produced a result
+  if (!ParserResult) {
+    std::cerr << "llvm-upgrade: no parse result.\n";
+    return 0;
   }
 
-  if (isGlobal) {
-    // We didn't find a global name, but if its supposed to be global then all 
-    // we can do is return the name. This is probably a forward reference of a 
-    // global value that hasn't been defined yet. Since we have no definition
-    // we don't know its linkage class. Just assume its an external and the name
-    // shouldn't change.
-    return *Name;
+  // Reset ParserResult variable while saving its value for the result.
+  Module *Result = ParserResult;
+  ParserResult = 0;
+
+  //Not all functions use vaarg, so make a second check for ObsoleteVarArgs
+  {
+    Function* F;
+    if ((F = Result->getNamedFunction("llvm.va_start"))
+        && F->getFunctionType()->getNumParams() == 0)
+      ObsoleteVarArgs = true;
+    if((F = Result->getNamedFunction("llvm.va_copy"))
+       && F->getFunctionType()->getNumParams() == 1)
+      ObsoleteVarArgs = true;
   }
 
-  // Default the result to the current name
-  std::string Result = Ty->makeUniqueName(*Name);
+  if (ObsoleteVarArgs && NewVarArgs) {
+    error("This file is corrupt: it uses both new and old style varargs");
+    return 0;
+  }
 
-  return Result;
-}
+  if(ObsoleteVarArgs) {
+    if(Function* F = Result->getNamedFunction("llvm.va_start")) {
+      if (F->arg_size() != 0) {
+        error("Obsolete va_start takes 0 argument");
+        return 0;
+      }
+      
+      //foo = va_start()
+      // ->
+      //bar = alloca typeof(foo)
+      //va_start(bar)
+      //foo = load bar
+
+      const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID);
+      const Type* ArgTy = F->getFunctionType()->getReturnType();
+      const Type* ArgTyPtr = PointerType::get(ArgTy);
+      Function* NF = cast(Result->getOrInsertFunction(
+        "llvm.va_start", RetTy, ArgTyPtr, (Type *)0));
+
+      while (!F->use_empty()) {
+        CallInst* CI = cast(F->use_back());
+        AllocaInst* bar = new AllocaInst(ArgTy, 0, "vastart.fix.1", CI);
+        new CallInst(NF, bar, "", CI);
+        Value* foo = new LoadInst(bar, "vastart.fix.2", CI);
+        CI->replaceAllUsesWith(foo);
+        CI->getParent()->getInstList().erase(CI);
+      }
+      Result->getFunctionList().erase(F);
+    }
+    
+    if(Function* F = Result->getNamedFunction("llvm.va_end")) {
+      if(F->arg_size() != 1) {
+        error("Obsolete va_end takes 1 argument");
+        return 0;
+      }
 
-std::string getGlobalName(const std::string* Name, const std::string Linkage,
-                          const Type* Ty, bool isConstant) {
-  // Default to given name
-  std::string Result = *Name; 
-  // Look up the name in the Globals Map
-  Type::GlobalsTypeMap::iterator GI = Type::Globals.find(*Name);
-  // Did we see this global name before?
-  if (GI != Type::Globals.end()) {
-    if (Ty->isUnresolvedDeep()) {
-      // The Gval's type is unresolved. Consequently, we can't disambiguate it
-      // by type. We'll just change its name and emit a warning.
-      warning("Cannot disambiguate global value '" + *Name + 
-              "' because type '" + Ty->getNewTy() + "'is unresolved.\n");
-      Result = *Name + ".unique";
-      UniqueNameCounter++;
-      Result += llvm::utostr(UniqueNameCounter);
-      return Result;
-    } else {
-      Type::TypePlaneMap::iterator TPI = GI->second.find(Ty);
-      if (TPI != GI->second.end()) {
-        // We found an existing name of the same old type. This isn't allowed 
-        // in LLVM 2.0. Consequently, we must alter the name of the global so it
-        // can at least compile. References to the global will yield the first
-        // definition, which is okay. We also must warn about this.
-        Result = *Name + ".unique";
-        UniqueNameCounter++;
-        Result += llvm::utostr(UniqueNameCounter);
-        warning(std::string("Global variable '") + *Name + "' was renamed to '"+
-                Result + "'");
-      } else { 
-        // There isn't an existing definition for this name according to the
-        // old types. Now search the TypePlanMap for types with the same new
-        // name. 
-        Type::TypePlaneMap::iterator TPI = GI->second.begin();
-        Type::TypePlaneMap::iterator TPE = GI->second.end();
-        for ( ; TPI != TPE; ++TPI) {
-          if (TPI->first->sameNewTyAs(Ty)) {
-            // The new types are the same but the old types are different so 
-            // this is a global name collision resulting from type planes 
-            // collapsing. 
-            if (Linkage == "external" || Linkage == "dllimport" || 
-                Linkage == "extern_weak" || Linkage == "") {
-              // The linkage of this gval is external so we can't reliably 
-              // rename it because it could potentially create a linking 
-              // problem.  However, we can't leave the name conflict in the 
-              // output either or it won't assemble with LLVM 2.0.  So, all we 
-              // can do is rename this one to something unique and emit a 
-              // warning about the problem.
-              Result = *Name + ".unique";
-              UniqueNameCounter++;
-              Result += llvm::utostr(UniqueNameCounter);
-              warning("Renaming global value '" + *Name + "' to '" + Result + 
-                      "' may cause linkage errors.");
-              return Result;
-            } else {
-              // Its linkage is internal and its type is known so we can 
-              // disambiguate the name collision successfully based on the type.
-              Result = getUniqueName(Name, Ty);
-              TPI->second = Result;
-              return Result;
-            }
-          }
-        }
-        // We didn't find an entry in the type plane with the same new type and
-        // the old types differ so this is a new type plane for this global 
-        // variable. We just fall through to the logic below which inserts
-        // the global.
+      //vaend foo
+      // ->
+      //bar = alloca 1 of typeof(foo)
+      //vaend bar
+      const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID);
+      const Type* ArgTy = F->getFunctionType()->getParamType(0);
+      const Type* ArgTyPtr = PointerType::get(ArgTy);
+      Function* NF = cast(Result->getOrInsertFunction(
+        "llvm.va_end", RetTy, ArgTyPtr, (Type *)0));
+
+      while (!F->use_empty()) {
+        CallInst* CI = cast(F->use_back());
+        AllocaInst* bar = new AllocaInst(ArgTy, 0, "vaend.fix.1", CI);
+        new StoreInst(CI->getOperand(1), bar, CI);
+        new CallInst(NF, bar, "", CI);
+        CI->getParent()->getInstList().erase(CI);
       }
+      Result->getFunctionList().erase(F);
     }
-  }
 
-  // Its a new global name, if it is external we can't change it
-  if (isConstant || Linkage == "external" || Linkage == "dllimport" || 
-      Linkage == "extern_weak" || Linkage == "") {
-    Type::Globals[Result][Ty] = Result;
-    return Result;
+    if(Function* F = Result->getNamedFunction("llvm.va_copy")) {
+      if(F->arg_size() != 1) {
+        error("Obsolete va_copy takes 1 argument");
+        return 0;
+      }
+      //foo = vacopy(bar)
+      // ->
+      //a = alloca 1 of typeof(foo)
+      //b = alloca 1 of typeof(foo)
+      //store bar -> b
+      //vacopy(a, b)
+      //foo = load a
+      
+      const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID);
+      const Type* ArgTy = F->getFunctionType()->getReturnType();
+      const Type* ArgTyPtr = PointerType::get(ArgTy);
+      Function* NF = cast(Result->getOrInsertFunction(
+        "llvm.va_copy", RetTy, ArgTyPtr, ArgTyPtr, (Type *)0));
+
+      while (!F->use_empty()) {
+        CallInst* CI = cast(F->use_back());
+        AllocaInst* a = new AllocaInst(ArgTy, 0, "vacopy.fix.1", CI);
+        AllocaInst* b = new AllocaInst(ArgTy, 0, "vacopy.fix.2", CI);
+        new StoreInst(CI->getOperand(1), b, CI);
+        new CallInst(NF, a, b, "", CI);
+        Value* foo = new LoadInst(a, "vacopy.fix.3", CI);
+        CI->replaceAllUsesWith(foo);
+        CI->getParent()->getInstList().erase(CI);
+      }
+      Result->getFunctionList().erase(F);
+    }
   }
 
-  // Its a new global name, and it is internal, change the name to make it
-  // unique for its type.
-  // Result = getUniqueName(Name, Ty);
-  Type::Globals[*Name][Ty] = Result;
   return Result;
 }
 
-} // End anonymous namespace
+} // end llvm namespace
 
-// This function is used by the Lexer to create a Type. It can't be
-// in the anonymous namespace.
-const Type* getType(const std::string& newTy, TypeIDs oldTy) {
-  return Type::get(newTy, oldTy);
-}
+using namespace llvm;
 
 %}
 
-// %file-prefix="UpgradeParser"
-
 %union {
-  std::string*    String;
-  const Type*     Ty;
-  Value*          Val;
-  Constant*       Const;
-  ValueList*      ValList;
-  TypeList*       TypeVec;
-}
-
-%token      VOID BOOL SBYTE UBYTE SHORT USHORT INT UINT LONG ULONG
-%token      FLOAT DOUBLE LABEL 
-%token  OPAQUE ESINT64VAL EUINT64VAL SINTVAL UINTVAL FPVAL
-%token  NULL_TOK UNDEF ZEROINITIALIZER TRUETOK FALSETOK
-%token  TYPE VAR_ID LABELSTR STRINGCONSTANT
-%token  IMPLEMENTATION BEGINTOK ENDTOK
-%token  DECLARE GLOBAL CONSTANT SECTION VOLATILE
-%token  TO DOTDOTDOT CONST INTERNAL LINKONCE WEAK 
-%token  DLLIMPORT DLLEXPORT EXTERN_WEAK APPENDING
-%token  EXTERNAL TARGET TRIPLE ENDIAN POINTERSIZE LITTLE BIG
-%token  ALIGN UNINITIALIZED
-%token  DEPLIBS CALL TAIL ASM_TOK MODULE SIDEEFFECT
-%token  CC_TOK CCC_TOK CSRETCC_TOK FASTCC_TOK COLDCC_TOK
-%token  X86_STDCALLCC_TOK X86_FASTCALLCC_TOK
-%token  DATALAYOUT
-%token  RET BR SWITCH INVOKE EXCEPT UNWIND UNREACHABLE
-%token  ADD SUB MUL DIV UDIV SDIV FDIV REM UREM SREM FREM AND OR XOR
-%token  SETLE SETGE SETLT SETGT SETEQ SETNE  // Binary Comparators
-%token  ICMP FCMP EQ NE SLT SGT SLE SGE OEQ ONE OLT OGT OLE OGE 
-%token  ORD UNO UEQ UNE ULT UGT ULE UGE
-%token  MALLOC ALLOCA FREE LOAD STORE GETELEMENTPTR
-%token  PHI_TOK SELECT SHL SHR ASHR LSHR VAARG
-%token  EXTRACTELEMENT INSERTELEMENT SHUFFLEVECTOR
-%token  CAST TRUNC ZEXT SEXT FPTRUNC FPEXT FPTOUI FPTOSI UITOFP SITOFP 
-%token  PTRTOINT INTTOPTR BITCAST
-
-%type  OptAssign OptLinkage OptCallingConv OptAlign OptCAlign 
-%type  SectionString OptSection GlobalVarAttributes GlobalVarAttribute
-%type  ConstExpr DefinitionList
-%type  ConstPool TargetDefinition LibrariesDefinition LibList OptName
-%type  ArgVal ArgListH ArgList FunctionHeaderH BEGIN FunctionHeader END
-%type  Function FunctionProto BasicBlock 
-%type  InstructionList BBTerminatorInst JumpTable Inst
-%type  OptTailCall OptVolatile Unwind
-%type  SymbolicValueRef OptSideEffect GlobalType
-%type  FnDeclareLinkage BasicBlockList BigOrLittle AsmBlock
-%type  Name ConstValueRef ConstVector External
-%type  ShiftOps SetCondOps LogicalOps ArithmeticOps CastOps
-%type  IPredicates FPredicates
-
-%type  ValueRefList ValueRefListE IndexList
-%type  TypeListI ArgTypeListI
-
-%type  IntType SIntType UIntType FPType TypesV Types 
-%type  PrimType UpRTypesV UpRTypes
-
-%type  IntVal EInt64Val 
-%type   ConstVal
+  llvm::Module                           *ModuleVal;
+  llvm::Function                         *FunctionVal;
+  std::pair     *ArgVal;
+  llvm::BasicBlock                       *BasicBlockVal;
+  llvm::TerminatorInst                   *TermInstVal;
+  llvm::InstrInfo                        InstVal;
+  llvm::ConstInfo                        ConstVal;
+  llvm::ValueInfo                        ValueVal;
+  llvm::PATypeInfo                       TypeVal;
+  llvm::TypeInfo                         PrimType;
+  llvm::PHIListInfo                      PHIList;
+  std::list            *TypeList;
+  std::vector           *ValueList;
+  std::vector           *ConstVector;
+
+
+  std::vector > *ArgList;
+  // Represent the RHS of PHI node
+  std::vector > *JumpTable;
+
+  llvm::GlobalValue::LinkageTypes         Linkage;
+  int64_t                           SInt64Val;
+  uint64_t                          UInt64Val;
+  int                               SIntVal;
+  unsigned                          UIntVal;
+  double                            FPVal;
+  bool                              BoolVal;
+
+  char                             *StrVal;   // This memory is strdup'd!
+  llvm::ValID                       ValIDVal; // strdup'd memory maybe!
+
+  llvm::BinaryOps                   BinaryOpVal;
+  llvm::TermOps                     TermOpVal;
+  llvm::MemoryOps                   MemOpVal;
+  llvm::OtherOps                    OtherOpVal;
+  llvm::CastOps                     CastOpVal;
+  llvm::ICmpInst::Predicate         IPred;
+  llvm::FCmpInst::Predicate         FPred;
+  llvm::Module::Endianness          Endianness;
+}
+
+%type      Module FunctionList
+%type    Function FunctionProto FunctionHeader BasicBlockList
+%type  BasicBlock InstructionList
+%type    BBTerminatorInst
+%type        Inst InstVal MemoryInst
+%type       ConstVal ConstExpr
+%type    ConstVector
+%type        ArgList ArgListH
+%type         ArgVal
+%type        PHIList
+%type      ValueRefList ValueRefListE  // For call param lists
+%type      IndexList                   // For GEP derived indices
+%type       TypeListI ArgTypeListI
+%type      JumpTable
+%type        GlobalType                  // GLOBAL or CONSTANT?
+%type        OptVolatile                 // 'volatile' or not
+%type        OptTailCall                 // TAIL CALL or plain CALL.
+%type        OptSideEffect               // 'sideeffect' or not.
+%type        OptLinkage
+%type     BigOrLittle
+
+// ValueRef - Unresolved reference to a definition or BB
+%type       ValueRef ConstValueRef SymbolicValueRef
+%type       ResolvedVal            //   pair
+// Tokens and types for handling constant integer values
+//
+// ESINT64VAL - A negative number within long long range
+%token  ESINT64VAL
 
-%type  ValueRef ResolvedVal InstVal PHIList MemoryInst
+// EUINT64VAL - A positive number within uns. long long range
+%token  EUINT64VAL
+%type   EINT64VAL
+
+%token     SINTVAL   // Signed 32 bit ints...
+%token     UINTVAL   // Unsigned 32 bit ints...
+%type      INTVAL
+%token       FPVAL     // Float or Double constant
+
+// Built in types...
+%type   Types TypesV UpRTypes UpRTypesV
+%type   SIntType UIntType IntType FPType PrimType // Classifications
+%token  VOID BOOL SBYTE UBYTE SHORT USHORT INT UINT LONG ULONG
+%token  FLOAT DOUBLE TYPE LABEL
+
+%token  VAR_ID LABELSTR STRINGCONSTANT
+%type   Name OptName OptAssign
+%type   OptAlign OptCAlign
+%type  OptSection SectionString
+
+%token IMPLEMENTATION ZEROINITIALIZER TRUETOK FALSETOK BEGINTOK ENDTOK
+%token DECLARE GLOBAL CONSTANT SECTION VOLATILE
+%token TO DOTDOTDOT NULL_TOK UNDEF CONST INTERNAL LINKONCE WEAK APPENDING
+%token DLLIMPORT DLLEXPORT EXTERN_WEAK
+%token OPAQUE NOT EXTERNAL TARGET TRIPLE ENDIAN POINTERSIZE LITTLE BIG ALIGN
+%token DEPLIBS CALL TAIL ASM_TOK MODULE SIDEEFFECT
+%token CC_TOK CCC_TOK CSRETCC_TOK FASTCC_TOK COLDCC_TOK
+%token X86_STDCALLCC_TOK X86_FASTCALLCC_TOK
+%token DATALAYOUT
+%type  OptCallingConv
+
+// Basic Block Terminating Operators
+%token  RET BR SWITCH INVOKE UNREACHABLE
+%token UNWIND EXCEPT
+
+// Binary Operators
+%type   ArithmeticOps LogicalOps SetCondOps // Binops Subcatagories
+%token  ADD SUB MUL DIV UDIV SDIV FDIV REM UREM SREM FREM 
+%token  AND OR XOR
+%token  SETLE SETGE SETLT SETGT SETEQ SETNE  // Binary Comparators
+%token  ICMP FCMP
+
+// Memory Instructions
+%token  MALLOC ALLOCA FREE LOAD STORE GETELEMENTPTR
+
+// Other Operators
+%type   ShiftOps
+%token  PHI_TOK SELECT SHL SHR ASHR LSHR VAARG
+%token  EXTRACTELEMENT INSERTELEMENT SHUFFLEVECTOR
+%token VAARG_old VANEXT_old //OBSOLETE
+
+%type   IPredicates
+%type   FPredicates
+%token  EQ NE SLT SGT SLE SGE ULT UGT ULE UGE 
+%token  OEQ ONE OLT OGT OLE OGE ORD UNO UEQ UNE
+
+%token  CAST TRUNC ZEXT SEXT FPTRUNC FPEXT FPTOUI FPTOSI 
+%token  UITOFP SITOFP PTRTOINT INTTOPTR BITCAST 
+%type   CastOps
 
 %start Module
 
 %%
 
 // Handle constant integer size restriction and conversion...
-IntVal : SINTVAL | UINTVAL ;
-EInt64Val : ESINT64VAL | EUINT64VAL;
+//
+INTVAL 
+  : SINTVAL;
+  | UINTVAL {
+    if ($1 > (uint32_t)INT32_MAX)     // Outside of my range!
+      error("Value too large for type");
+    $$ = (int32_t)$1;
+  }
+  ;
+
+EINT64VAL 
+  : ESINT64VAL;      // These have same type and can't cause problems...
+  | EUINT64VAL {
+    if ($1 > (uint64_t)INT64_MAX)     // Outside of my range!
+      error("Value too large for type");
+    $$ = (int64_t)$1;
+  };
 
 // Operations that are notably excluded from this list include:
 // RET, BR, & SWITCH because they end basic blocks and are treated specially.
-ArithmeticOps: ADD | SUB | MUL | DIV | UDIV | SDIV | FDIV 
-             | REM | UREM | SREM | FREM;
-LogicalOps   : AND | OR | XOR;
-SetCondOps   : SETLE | SETGE | SETLT | SETGT | SETEQ | SETNE;
-IPredicates  : EQ | NE | SLT | SGT | SLE | SGE | ULT | UGT | ULE | UGE;
-FPredicates  : OEQ | ONE | OLT | OGT | OLE | OGE | ORD | UNO | UEQ | UNE
-             | ULT | UGT | ULE | UGE | TRUETOK | FALSETOK;
-ShiftOps     : SHL | SHR | ASHR | LSHR;
-CastOps      : TRUNC | ZEXT | SEXT | FPTRUNC | FPEXT | FPTOUI | FPTOSI | 
-               UITOFP | SITOFP | PTRTOINT | INTTOPTR | BITCAST | CAST
-             ;
+//
+ArithmeticOps
+  : ADD | SUB | MUL | DIV | UDIV | SDIV | FDIV | REM | UREM | SREM | FREM
+  ;
+
+LogicalOps   
+  : AND | OR | XOR
+  ;
+
+SetCondOps   
+  : SETLE | SETGE | SETLT | SETGT | SETEQ | SETNE
+  ;
+
+IPredicates  
+  : EQ   { $$ = ICmpInst::ICMP_EQ; }  | NE   { $$ = ICmpInst::ICMP_NE; }
+  | SLT  { $$ = ICmpInst::ICMP_SLT; } | SGT  { $$ = ICmpInst::ICMP_SGT; }
+  | SLE  { $$ = ICmpInst::ICMP_SLE; } | SGE  { $$ = ICmpInst::ICMP_SGE; }
+  | ULT  { $$ = ICmpInst::ICMP_ULT; } | UGT  { $$ = ICmpInst::ICMP_UGT; }
+  | ULE  { $$ = ICmpInst::ICMP_ULE; } | UGE  { $$ = ICmpInst::ICMP_UGE; } 
+  ;
+
+FPredicates  
+  : OEQ  { $$ = FCmpInst::FCMP_OEQ; } | ONE  { $$ = FCmpInst::FCMP_ONE; }
+  | OLT  { $$ = FCmpInst::FCMP_OLT; } | OGT  { $$ = FCmpInst::FCMP_OGT; }
+  | OLE  { $$ = FCmpInst::FCMP_OLE; } | OGE  { $$ = FCmpInst::FCMP_OGE; }
+  | ORD  { $$ = FCmpInst::FCMP_ORD; } | UNO  { $$ = FCmpInst::FCMP_UNO; }
+  | UEQ  { $$ = FCmpInst::FCMP_UEQ; } | UNE  { $$ = FCmpInst::FCMP_UNE; }
+  | ULT  { $$ = FCmpInst::FCMP_ULT; } | UGT  { $$ = FCmpInst::FCMP_UGT; }
+  | ULE  { $$ = FCmpInst::FCMP_ULE; } | UGE  { $$ = FCmpInst::FCMP_UGE; }
+  | TRUETOK { $$ = FCmpInst::FCMP_TRUE; }
+  | FALSETOK { $$ = FCmpInst::FCMP_FALSE; }
+  ;
+ShiftOps  
+  : SHL | SHR | ASHR | LSHR
+  ;
+
+CastOps      
+  : TRUNC | ZEXT | SEXT | FPTRUNC | FPEXT | FPTOUI | FPTOSI 
+  | UITOFP | SITOFP | PTRTOINT | INTTOPTR | BITCAST | CAST
+  ;
 
 // These are some types that allow classification if we only want a particular 
 // thing... for example, only a signed, unsigned, or integral type.
-SIntType :  LONG |  INT |  SHORT | SBYTE;
-UIntType : ULONG | UINT | USHORT | UBYTE;
-IntType  : SIntType | UIntType;
-FPType   : FLOAT | DOUBLE;
+SIntType 
+  :  LONG |  INT |  SHORT | SBYTE
+  ;
+
+UIntType 
+  : ULONG | UINT | USHORT | UBYTE
+  ;
+
+IntType  
+  : SIntType | UIntType
+  ;
+
+FPType   
+  : FLOAT | DOUBLE
+  ;
 
 // OptAssign - Value producing statements have an optional assignment component
-OptAssign : Name '=' {
+OptAssign 
+  : Name '=' {
     $$ = $1;
   }
   | /*empty*/ {
-    $$ = new std::string(""); 
+    $$ = 0;
   };
 
 OptLinkage 
-  : INTERNAL | LINKONCE | WEAK | APPENDING | DLLIMPORT | DLLEXPORT 
-  | EXTERN_WEAK 
-  | /*empty*/   { $$ = new std::string(""); } ;
+  : INTERNAL    { $$ = GlobalValue::InternalLinkage; } 
+  | LINKONCE    { $$ = GlobalValue::LinkOnceLinkage; } 
+  | WEAK        { $$ = GlobalValue::WeakLinkage; } 
+  | APPENDING   { $$ = GlobalValue::AppendingLinkage; } 
+  | DLLIMPORT   { $$ = GlobalValue::DLLImportLinkage; } 
+  | DLLEXPORT   { $$ = GlobalValue::DLLExportLinkage; } 
+  | EXTERN_WEAK { $$ = GlobalValue::ExternalWeakLinkage; } 
+  | /*empty*/   { $$ = GlobalValue::ExternalLinkage; }
+  ;
 
 OptCallingConv 
-  : CCC_TOK | CSRETCC_TOK | FASTCC_TOK | COLDCC_TOK | X86_STDCALLCC_TOK 
-  | X86_FASTCALLCC_TOK 
-  | CC_TOK EUINT64VAL { 
-    *$1 += *$2; 
-    delete $2;
-    $$ = $1; 
-    }
-  | /*empty*/ { $$ = new std::string(""); } ;
+  : /*empty*/          { $$ = CallingConv::C; } 
+  | CCC_TOK            { $$ = CallingConv::C; } 
+  | CSRETCC_TOK        { $$ = CallingConv::CSRet; } 
+  | FASTCC_TOK         { $$ = CallingConv::Fast; } 
+  | COLDCC_TOK         { $$ = CallingConv::Cold; } 
+  | X86_STDCALLCC_TOK  { $$ = CallingConv::X86_StdCall; } 
+  | X86_FASTCALLCC_TOK { $$ = CallingConv::X86_FastCall; } 
+  | CC_TOK EUINT64VAL  {
+    if ((unsigned)$2 != $2)
+      error("Calling conv too large");
+    $$ = $2;
+  }
+  ;
 
 // OptAlign/OptCAlign - An optional alignment, and an optional alignment with
 // a comma before it.
 OptAlign 
-  : /*empty*/        { $$ = new std::string(); }
-  | ALIGN EUINT64VAL { *$1 += " " + *$2; delete $2; $$ = $1; };
+  : /*empty*/        { $$ = 0; } 
+  | ALIGN EUINT64VAL {
+    $$ = $2;
+    if ($$ != 0 && !isPowerOf2_32($$))
+      error("Alignment must be a power of two");
+  }
+  ;
 
 OptCAlign 
-  : /*empty*/            { $$ = new std::string(); } 
-  | ',' ALIGN EUINT64VAL { 
-    $2->insert(0, ", "); 
-    *$2 += " " + *$3;
-    delete $3;
-    $$ = $2;
-  };
+  : /*empty*/ { $$ = 0; } 
+  | ',' ALIGN EUINT64VAL {
+    $$ = $3;
+    if ($$ != 0 && !isPowerOf2_32($$))
+      error("Alignment must be a power of two");
+  }
+  ;
 
 SectionString 
-  : SECTION STRINGCONSTANT { 
-    *$1 += " " + *$2;
-    delete $2;
-    $$ = $1;
-  };
+  : SECTION STRINGCONSTANT {
+    for (unsigned i = 0, e = strlen($2); i != e; ++i)
+      if ($2[i] == '"' || $2[i] == '\\')
+        error("Invalid character in section name");
+    $$ = $2;
+  }
+  ;
 
-OptSection : /*empty*/     { $$ = new std::string(); } 
-           | SectionString;
+OptSection 
+  : /*empty*/ { $$ = 0; } 
+  | SectionString { $$ = $1; }
+  ;
 
+// GlobalVarAttributes - Used to pass the attributes string on a global.  CurGV
+// is set to be the global we are processing.
+//
 GlobalVarAttributes 
-    : /* empty */ { $$ = new std::string(); } 
-    | ',' GlobalVarAttribute GlobalVarAttributes  {
-      $2->insert(0, ", ");
-      if (!$3->empty())
-        *$2 += " " + *$3;
-      delete $3;
-      $$ = $2;
-    };
+  : /* empty */ {} 
+  | ',' GlobalVarAttribute GlobalVarAttributes {}
+  ;
 
-GlobalVarAttribute 
-    : SectionString 
-    | ALIGN EUINT64VAL {
-      *$1 += " " + *$2;
-      delete $2;
-      $$ = $1;
-    };
+GlobalVarAttribute
+  : SectionString {
+    CurGV->setSection($1);
+    free($1);
+  } 
+  | ALIGN EUINT64VAL {
+    if ($2 != 0 && !isPowerOf2_32($2))
+      error("Alignment must be a power of two");
+    CurGV->setAlignment($2);
+    
+  }
+  ;
 
 //===----------------------------------------------------------------------===//
 // Types includes all predefined types... except void, because it can only be
@@ -1130,112 +1778,164 @@
 //
 
 // TypesV includes all of 'Types', but it also includes the void type.
-TypesV    : Types    | VOID ;
-UpRTypesV : UpRTypes | VOID ; 
-Types     : UpRTypes ;
+TypesV    
+  : Types
+  | VOID { 
+    $$.T = new PATypeHolder($1.T); 
+    $$.S = Signless;
+  }
+  ;
+
+UpRTypesV 
+  : UpRTypes 
+  | VOID { 
+    $$.T = new PATypeHolder($1.T); 
+    $$.S = Signless;
+  }
+  ;
+
+Types
+  : UpRTypes {
+    if (!UpRefs.empty())
+      error("Invalid upreference in type: " + (*$1.T)->getDescription());
+    $$ = $1;
+  }
+  ;
+
+PrimType
+  : BOOL | SBYTE | UBYTE | SHORT  | USHORT | INT   | UINT 
+  | LONG | ULONG | FLOAT | DOUBLE | LABEL
+  ;
 
 // Derived types are added later...
-//
-PrimType : BOOL | SBYTE | UBYTE | SHORT  | USHORT | INT   | UINT ;
-PrimType : LONG | ULONG | FLOAT | DOUBLE | LABEL;
 UpRTypes 
-  : OPAQUE { 
-    $$ = Type::get(*$1, OpaqueTy);
-  } 
-  | SymbolicValueRef { 
-    $$ = Type::get(*$1, UnresolvedTy);
-  }
-  | PrimType { 
-    $$ = $1; 
+  : PrimType { 
+    $$.T = new PATypeHolder($1.T);
+    $$.S = $1.S;
+  }
+  | OPAQUE {
+    $$.T = new PATypeHolder(OpaqueType::get());
+    $$.S = Signless;
+  }
+  | SymbolicValueRef {            // Named types are also simple types...
+    const Type* tmp = getTypeVal($1);
+    $$.T = new PATypeHolder(tmp);
+    $$.S = Signless; // FIXME: what if its signed?
   }
   | '\\' EUINT64VAL {                   // Type UpReference
-    $2->insert(0, "\\");
-    $$ = Type::get(*$2, UpRefTy);
+    if ($2 > (uint64_t)~0U) 
+      error("Value out of range");
+    OpaqueType *OT = OpaqueType::get();        // Use temporary placeholder
+    UpRefs.push_back(UpRefRecord((unsigned)$2, OT));  // Add to vector...
+    $$.T = new PATypeHolder(OT);
+    $$.S = Signless;
+    UR_OUT("New Upreference!\n");
   }
   | UpRTypesV '(' ArgTypeListI ')' {           // Function derived type?
-    std::string newTy( $1->getNewTy() + "(");
-    for (unsigned i = 0; i < $3->size(); ++i) {
-      if (i != 0)
-        newTy +=  ", ";
-      if ((*$3)[i]->isVoid())
-        newTy += "...";
-      else
-        newTy += (*$3)[i]->getNewTy();
-    }
-    newTy += ")";
-    $$ = Type::get(newTy, $1, $3);
+    std::vector Params;
+    for (std::list::iterator I = $3->begin(),
+           E = $3->end(); I != E; ++I) {
+      Params.push_back(I->T->get());
+      delete I->T;
+    }
+    bool isVarArg = Params.size() && Params.back() == Type::VoidTy;
+    if (isVarArg) Params.pop_back();
+
+    $$.T = new PATypeHolder(HandleUpRefs(
+                           FunctionType::get($1.T->get(),Params,isVarArg)));
+    $$.S = $1.S;
+    delete $1.T;    // Delete the return type handle
+    delete $3;      // Delete the argument list
   }
   | '[' EUINT64VAL 'x' UpRTypes ']' {          // Sized array type?
-    uint64_t elems = atoi($2->c_str());
-    $2->insert(0,"[ ");
-    *$2 += " x " + $4->getNewTy() + " ]";
-    $$ = Type::get(*$2, ArrayTy, $4, elems);
+    $$.T = new PATypeHolder(HandleUpRefs(ArrayType::get($4.T->get(), 
+                                                        (unsigned)$2)));
+    $$.S = $4.S;
+    delete $4.T;
   }
   | '<' EUINT64VAL 'x' UpRTypes '>' {          // Packed array type?
-    uint64_t elems = atoi($2->c_str());
-    $2->insert(0,"< ");
-    *$2 += " x " + $4->getNewTy() + " >";
-    $$ = Type::get(*$2, PackedTy, $4, elems);
+     const llvm::Type* ElemTy = $4.T->get();
+     if ((unsigned)$2 != $2)
+        error("Unsigned result not equal to signed result");
+     if (!(ElemTy->isInteger() || ElemTy->isFloatingPoint()))
+        error("Elements of a PackedType must be integer or floating point");
+     if (!isPowerOf2_32($2))
+       error("PackedType length should be a power of 2");
+     $$.T = new PATypeHolder(HandleUpRefs(PackedType::get(ElemTy, 
+                                          (unsigned)$2)));
+     $$.S = $4.S;
+     delete $4.T;
   }
   | '{' TypeListI '}' {                        // Structure type?
-    std::string newTy("{");
-    for (unsigned i = 0; i < $2->size(); ++i) {
-      if (i != 0)
-        newTy +=  ", ";
-      newTy += (*$2)[i]->getNewTy();
-    }
-    newTy += "}";
-    $$ = Type::get(newTy, StructTy, $2);
+    std::vector Elements;
+    for (std::list::iterator I = $2->begin(),
+           E = $2->end(); I != E; ++I)
+      Elements.push_back(I->T->get());
+    $$.T = new PATypeHolder(HandleUpRefs(StructType::get(Elements)));
+    $$.S = Signless;
+    delete $2;
   }
   | '{' '}' {                                  // Empty structure type?
-    $$ = Type::get("{}", StructTy, new TypeList());
+    $$.T = new PATypeHolder(StructType::get(std::vector()));
+    $$.S = Signless;
   }
   | '<' '{' TypeListI '}' '>' {                // Packed Structure type?
-    std::string newTy("<{");
-    for (unsigned i = 0; i < $3->size(); ++i) {
-      if (i != 0)
-        newTy +=  ", ";
-      newTy += (*$3)[i]->getNewTy();
+    std::vector Elements;
+    for (std::list::iterator I = $3->begin(),
+           E = $3->end(); I != E; ++I) {
+      Elements.push_back(I->T->get());
+      delete I->T;
     }
-    newTy += "}>";
-    $$ = Type::get(newTy, PackedStructTy, $3);
+    $$.T = new PATypeHolder(HandleUpRefs(StructType::get(Elements, true)));
+    $$.S = Signless;
+    delete $3;
   }
   | '<' '{' '}' '>' {                          // Empty packed structure type?
-    $$ = Type::get("<{}>", PackedStructTy, new TypeList());
+    $$.T = new PATypeHolder(StructType::get(std::vector(),true));
+    $$.S = Signless;
   }
   | UpRTypes '*' {                             // Pointer type?
-    $$ = $1->getPointerType();
-  };
+    if ($1.T->get() == Type::LabelTy)
+      error("Cannot form a pointer to a basic block");
+    $$.T = new PATypeHolder(HandleUpRefs(PointerType::get($1.T->get())));
+    $$.S = $1.S;
+    delete $1.T;
+  }
+  ;
 
 // TypeList - Used for struct declarations and as a basis for function type 
 // declaration type lists
 //
 TypeListI 
   : UpRTypes {
-    $$ = new TypeList();
-    $$->push_back($1);
+    $$ = new std::list();
+    $$->push_back($1); 
   }
   | TypeListI ',' UpRTypes {
-    $$ = $1;
-    $$->push_back($3);
-  };
+    ($$=$1)->push_back($3);
+  }
+  ;
 
 // ArgTypeList - List of types for a function type declaration...
 ArgTypeListI 
-  : TypeListI 
+  : TypeListI
   | TypeListI ',' DOTDOTDOT {
-    $$ = $1;
-    $$->push_back(Type::get("void",VoidTy));
-    delete $3;
+    PATypeInfo VoidTI;
+    VoidTI.T = new PATypeHolder(Type::VoidTy);
+    VoidTI.S = Signless;
+    ($$=$1)->push_back(VoidTI);
   }
   | DOTDOTDOT {
-    $$ = new TypeList();
-    $$->push_back(Type::get("void",VoidTy));
-    delete $1;
+    $$ = new std::list();
+    PATypeInfo VoidTI;
+    VoidTI.T = new PATypeHolder(Type::VoidTy);
+    VoidTI.S = Signless;
+    $$->push_back(VoidTI);
   }
   | /*empty*/ {
-    $$ = new TypeList();
-  };
+    $$ = new std::list();
+  }
+  ;
 
 // ConstVal - The various declarations that go into the constant pool.  This
 // production is used ONLY to represent constants that show up AFTER a 'const',
@@ -1243,215 +1943,429 @@
 // into other expressions (such as integers and constexprs) are handled by the
 // ResolvedVal, ValueRef and ConstValueRef productions.
 //
-ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr
-    $$ = new Constant;
-    $$->type = $1;
-    $$->cnst = new std::string($1->getNewTy());
-    *$$->cnst += " [ " + *$3 + " ]";
+ConstVal
+  : Types '[' ConstVector ']' { // Nonempty unsized arr
+    const ArrayType *ATy = dyn_cast($1.T->get());
+    if (ATy == 0)
+      error("Cannot make array constant with type: '" + 
+            $1.T->get()->getDescription() + "'");
+    const Type *ETy = ATy->getElementType();
+    int NumElements = ATy->getNumElements();
+
+    // Verify that we have the correct size...
+    if (NumElements != -1 && NumElements != (int)$3->size())
+      error("Type mismatch: constant sized array initialized with " +
+            utostr($3->size()) +  " arguments, but has size of " + 
+            itostr(NumElements) + "");
+
+    // Verify all elements are correct type!
+    std::vector Elems;
+    for (unsigned i = 0; i < $3->size(); i++) {
+      Constant *C = (*$3)[i].C;
+      const Type* ValTy = C->getType();
+      if (ETy != ValTy)
+        error("Element #" + utostr(i) + " is not of type '" + 
+              ETy->getDescription() +"' as required!\nIt is of type '"+
+              ValTy->getDescription() + "'");
+      Elems.push_back(C);
+    }
+    $$.C = ConstantArray::get(ATy, Elems);
+    $$.S = $1.S;
+    delete $1.T; 
     delete $3;
   }
   | Types '[' ']' {
-    $$ = new Constant;
-    $$->type = $1;
-    $$->cnst = new std::string($1->getNewTy());
-    *$$->cnst += "[ ]";
+    const ArrayType *ATy = dyn_cast($1.T->get());
+    if (ATy == 0)
+      error("Cannot make array constant with type: '" + 
+            $1.T->get()->getDescription() + "'");
+    int NumElements = ATy->getNumElements();
+    if (NumElements != -1 && NumElements != 0) 
+      error("Type mismatch: constant sized array initialized with 0"
+            " arguments, but has size of " + itostr(NumElements) +"");
+    $$.C = ConstantArray::get(ATy, std::vector());
+    $$.S = $1.S;
+    delete $1.T;
   }
   | Types 'c' STRINGCONSTANT {
-    $$ = new Constant;
-    $$->type = $1;
-    $$->cnst = new std::string($1->getNewTy());
-    *$$->cnst += " c" + *$3;
-    delete $3;
+    const ArrayType *ATy = dyn_cast($1.T->get());
+    if (ATy == 0)
+      error("Cannot make array constant with type: '" + 
+            $1.T->get()->getDescription() + "'");
+    int NumElements = ATy->getNumElements();
+    const Type *ETy = dyn_cast(ATy->getElementType());
+    if (!ETy || cast(ETy)->getBitWidth() != 8)
+      error("String arrays require type i8, not '" + ETy->getDescription() + 
+            "'");
+    char *EndStr = UnEscapeLexed($3, true);
+    if (NumElements != -1 && NumElements != (EndStr-$3))
+      error("Can't build string constant of size " + 
+            itostr((int)(EndStr-$3)) + " when array has size " + 
+            itostr(NumElements) + "");
+    std::vector Vals;
+    for (char *C = (char *)$3; C != (char *)EndStr; ++C)
+      Vals.push_back(ConstantInt::get(ETy, *C));
+    free($3);
+    $$.C = ConstantArray::get(ATy, Vals);
+    $$.S = $1.S;
+    delete $1.T;
   }
   | Types '<' ConstVector '>' { // Nonempty unsized arr
-    $$ = new Constant;
-    $$->type = $1;
-    $$->cnst = new std::string($1->getNewTy());
-    *$$->cnst += " < " + *$3 + " >";
+    const PackedType *PTy = dyn_cast($1.T->get());
+    if (PTy == 0)
+      error("Cannot make packed constant with type: '" + 
+            $1.T->get()->getDescription() + "'");
+    const Type *ETy = PTy->getElementType();
+    int NumElements = PTy->getNumElements();
+    // Verify that we have the correct size...
+    if (NumElements != -1 && NumElements != (int)$3->size())
+      error("Type mismatch: constant sized packed initialized with " +
+            utostr($3->size()) +  " arguments, but has size of " + 
+            itostr(NumElements) + "");
+    // Verify all elements are correct type!
+    std::vector Elems;
+    for (unsigned i = 0; i < $3->size(); i++) {
+      Constant *C = (*$3)[i].C;
+      const Type* ValTy = C->getType();
+      if (ETy != ValTy)
+        error("Element #" + utostr(i) + " is not of type '" + 
+              ETy->getDescription() +"' as required!\nIt is of type '"+
+              ValTy->getDescription() + "'");
+      Elems.push_back(C);
+    }
+    $$.C = ConstantPacked::get(PTy, Elems);
+    $$.S = $1.S;
+    delete $1.T;
     delete $3;
   }
   | Types '{' ConstVector '}' {
-    $$ = new Constant;
-    $$->type = $1;
-    $$->cnst = new std::string($1->getNewTy());
-    *$$->cnst += " { " + *$3 + " }";
+    const StructType *STy = dyn_cast($1.T->get());
+    if (STy == 0)
+      error("Cannot make struct constant with type: '" + 
+            $1.T->get()->getDescription() + "'");
+    if ($3->size() != STy->getNumContainedTypes())
+      error("Illegal number of initializers for structure type");
+
+    // Check to ensure that constants are compatible with the type initializer!
+    std::vector Fields;
+    for (unsigned i = 0, e = $3->size(); i != e; ++i) {
+      Constant *C = (*$3)[i].C;
+      if (C->getType() != STy->getElementType(i))
+        error("Expected type '" + STy->getElementType(i)->getDescription() +
+              "' for element #" + utostr(i) + " of structure initializer");
+      Fields.push_back(C);
+    }
+    $$.C = ConstantStruct::get(STy, Fields);
+    $$.S = $1.S;
+    delete $1.T;
     delete $3;
   }
   | Types '{' '}' {
-    $$ = new Constant;
-    $$->type = $1;
-    $$->cnst = new std::string($1->getNewTy());
-    *$$->cnst += " {}";
+    const StructType *STy = dyn_cast($1.T->get());
+    if (STy == 0)
+      error("Cannot make struct constant with type: '" + 
+              $1.T->get()->getDescription() + "'");
+    if (STy->getNumContainedTypes() != 0)
+      error("Illegal number of initializers for structure type");
+    $$.C = ConstantStruct::get(STy, std::vector());
+    $$.S = $1.S;
+    delete $1.T;
+  }
+  | Types '<' '{' ConstVector '}' '>' {
+    const StructType *STy = dyn_cast($1.T->get());
+    if (STy == 0)
+      error("Cannot make packed struct constant with type: '" + 
+            $1.T->get()->getDescription() + "'");
+    if ($4->size() != STy->getNumContainedTypes())
+      error("Illegal number of initializers for packed structure type");
+
+    // Check to ensure that constants are compatible with the type initializer!
+    std::vector Fields;
+    for (unsigned i = 0, e = $4->size(); i != e; ++i) {
+      Constant *C = (*$4)[i].C;
+      if (C->getType() != STy->getElementType(i))
+        error("Expected type '" + STy->getElementType(i)->getDescription() +
+              "' for element #" + utostr(i) + " of packed struct initializer");
+      Fields.push_back(C);
+    }
+    $$.C = ConstantStruct::get(STy, Fields);
+    $$.S = $1.S;
+    delete $1.T; 
+    delete $4;
+  }
+  | Types '<' '{' '}' '>' {
+    const StructType *STy = dyn_cast($1.T->get());
+    if (STy == 0)
+      error("Cannot make packed struct constant with type: '" + 
+              $1.T->get()->getDescription() + "'");
+    if (STy->getNumContainedTypes() != 0)
+      error("Illegal number of initializers for packed structure type");
+    $$.C = ConstantStruct::get(STy, std::vector());
+    $$.S = $1.S;
+    delete $1.T;
   }
   | Types NULL_TOK {
-    $$ = new Constant;
-    $$->type = $1;
-    $$->cnst = new std::string($1->getNewTy());
-    *$$->cnst +=  " " + *$2;
-    delete $2;
+    const PointerType *PTy = dyn_cast($1.T->get());
+    if (PTy == 0)
+      error("Cannot make null pointer constant with type: '" + 
+            $1.T->get()->getDescription() + "'");
+    $$.C = ConstantPointerNull::get(PTy);
+    $$.S = $1.S;
+    delete $1.T;
   }
   | Types UNDEF {
-    $$ = new Constant;
-    $$->type = $1;
-    $$->cnst = new std::string($1->getNewTy());
-    *$$->cnst += " " + *$2;
-    delete $2;
+    $$.C = UndefValue::get($1.T->get());
+    $$.S = $1.S;
+    delete $1.T;
   }
   | Types SymbolicValueRef {
-    $$ = new Constant;
-    std::string Name = getUniqueName($2, $1->resolve(), true);
-    $$->type = $1;
-    $$->cnst = new std::string($1->getNewTy());
-    *$$->cnst += " " + Name;
-    delete $2;
+    const PointerType *Ty = dyn_cast($1.T->get());
+    if (Ty == 0)
+      error("Global const reference must be a pointer type, not" +
+            $1.T->get()->getDescription());
+
+    // ConstExprs can exist in the body of a function, thus creating
+    // GlobalValues whenever they refer to a variable.  Because we are in
+    // the context of a function, getExistingValue will search the functions
+    // symbol table instead of the module symbol table for the global symbol,
+    // which throws things all off.  To get around this, we just tell
+    // getExistingValue that we are at global scope here.
+    //
+    Function *SavedCurFn = CurFun.CurrentFunction;
+    CurFun.CurrentFunction = 0;
+    Value *V = getExistingValue(Ty, $2);
+    CurFun.CurrentFunction = SavedCurFn;
+
+    // If this is an initializer for a constant pointer, which is referencing a
+    // (currently) undefined variable, create a stub now that shall be replaced
+    // in the future with the right type of variable.
+    //
+    if (V == 0) {
+      assert(isa(Ty) && "Globals may only be used as pointers");
+      const PointerType *PT = cast(Ty);
+
+      // First check to see if the forward references value is already created!
+      PerModuleInfo::GlobalRefsType::iterator I =
+        CurModule.GlobalRefs.find(std::make_pair(PT, $2));
+    
+      if (I != CurModule.GlobalRefs.end()) {
+        V = I->second;             // Placeholder already exists, use it...
+        $2.destroy();
+      } else {
+        std::string Name;
+        if ($2.Type == ValID::NameVal) Name = $2.Name;
+
+        // Create the forward referenced global.
+        GlobalValue *GV;
+        if (const FunctionType *FTy = 
+                 dyn_cast(PT->getElementType())) {
+          GV = new Function(FTy, GlobalValue::ExternalLinkage, Name,
+                            CurModule.CurrentModule);
+        } else {
+          GV = new GlobalVariable(PT->getElementType(), false,
+                                  GlobalValue::ExternalLinkage, 0,
+                                  Name, CurModule.CurrentModule);
+        }
+
+        // Keep track of the fact that we have a forward ref to recycle it
+        CurModule.GlobalRefs.insert(std::make_pair(std::make_pair(PT, $2), GV));
+        V = GV;
+      }
+    }
+    $$.C = cast(V);
+    $$.S = $1.S;
+    delete $1.T;            // Free the type handle
   }
   | Types ConstExpr {
-    $$ = new Constant;
-    $$->type = $1;
-    $$->cnst = new std::string($1->getNewTy());
-    *$$->cnst += " " + *$2;
-    delete $2;
+    if ($1.T->get() != $2.C->getType())
+      error("Mismatched types for constant expression");
+    $$ = $2;
+    $$.S = $1.S;
+    delete $1.T;
   }
   | Types ZEROINITIALIZER {
-    $$ = new Constant;
-    $$->type = $1;
-    $$->cnst = new std::string($1->getNewTy());
-    *$$->cnst += " " + *$2;
-    delete $2;
-  }
-  | SIntType EInt64Val {      // integral constants
-    $$ = new Constant;
-    $$->type = $1;
-    $$->cnst = new std::string($1->getNewTy());
-    *$$->cnst += " " + *$2;
-    delete $2;
-  }
-  | UIntType EInt64Val {            // integral constants
-    $$ = new Constant;
-    $$->type = $1;
-    $$->cnst = new std::string($1->getNewTy());
-    *$$->cnst += " " + *$2;
-    delete $2;
+    const Type *Ty = $1.T->get();
+    if (isa(Ty) || Ty == Type::LabelTy || isa(Ty))
+      error("Cannot create a null initialized value of this type");
+    $$.C = Constant::getNullValue(Ty);
+    $$.S = $1.S;
+    delete $1.T;
+  }
+  | SIntType EINT64VAL {      // integral constants
+    const Type *Ty = $1.T;
+    if (!ConstantInt::isValueValidForType(Ty, $2))
+      error("Constant value doesn't fit in type");
+    $$.C = ConstantInt::get(Ty, $2);
+    $$.S = Signed;
+  }
+  | UIntType EUINT64VAL {            // integral constants
+    const Type *Ty = $1.T;
+    if (!ConstantInt::isValueValidForType(Ty, $2))
+      error("Constant value doesn't fit in type");
+    $$.C = ConstantInt::get(Ty, $2);
+    $$.S = Unsigned;
   }
   | BOOL TRUETOK {                      // Boolean constants
-    $$ = new Constant;
-    $$->type = $1;
-    $$->cnst = new std::string($1->getNewTy());
-    *$$->cnst += " " + *$2;
-    delete $2;
+    $$.C = ConstantInt::get(Type::Int1Ty, true);
+    $$.S = Unsigned;
   }
   | BOOL FALSETOK {                     // Boolean constants
-    $$ = new Constant;
-    $$->type = $1;
-    $$->cnst = new std::string($1->getNewTy());
-    *$$->cnst += " " + *$2;
-    delete $2;
+    $$.C = ConstantInt::get(Type::Int1Ty, false);
+    $$.S = Unsigned;
   }
   | FPType FPVAL {                   // Float & Double constants
-    $$ = new Constant;
-    $$->type = $1;
-    $$->cnst = new std::string($1->getNewTy());
-    *$$->cnst += " " + *$2;
-    delete $2;
-  };
+    if (!ConstantFP::isValueValidForType($1.T, $2))
+      error("Floating point constant invalid for type");
+    $$.C = ConstantFP::get($1.T, $2);
+    $$.S = Signless;
+  }
+  ;
 
-ConstExpr: CastOps '(' ConstVal TO Types ')' {
-    std::string source = *$3->cnst;
-    const Type* SrcTy = $3->type->resolve();
-    const Type* DstTy = $5->resolve(); 
-    if (*$1 == "cast") {
-      // Call getCastUpgrade to upgrade the old cast
-      $$ = new std::string(getCastUpgrade(source, SrcTy, DstTy, true));
-    } else {
-      // Nothing to upgrade, just create the cast constant expr
-      $$ = new std::string(*$1);
-      *$$ += "( " + source + " to " + $5->getNewTy() + ")";
-    }
-    delete $1; delete $3; delete $4;
+ConstExpr
+  : CastOps '(' ConstVal TO Types ')' {
+    const Type* SrcTy = $3.C->getType();
+    const Type* DstTy = $5.T->get();
+    Signedness SrcSign = $3.S;
+    Signedness DstSign = $5.S;
+    if (!SrcTy->isFirstClassType())
+      error("cast constant expression from a non-primitive type: '" +
+            SrcTy->getDescription() + "'");
+    if (!DstTy->isFirstClassType())
+      error("cast constant expression to a non-primitive type: '" +
+            DstTy->getDescription() + "'");
+    $$.C = cast(getCast($1, $3.C, SrcSign, DstTy, DstSign));
+    $$.S = DstSign;
+    delete $5.T;
   }
   | GETELEMENTPTR '(' ConstVal IndexList ')' {
-    *$1 += "(" + *$3->cnst;
-    for (unsigned i = 0; i < $4->size(); ++i) {
-      Value* V = (*$4)[i];
-      *$1 += ", " + *V->val;
-      delete V;
-    }
-    *$1 += ")";
-    $$ = $1;
-    delete $3;
+    const Type *Ty = $3.C->getType();
+    if (!isa(Ty))
+      error("GetElementPtr requires a pointer operand");
+
+    std::vector VIndices;
+    std::vector CIndices;
+    upgradeGEPIndices($3.C->getType(), $4, VIndices, &CIndices);
+
     delete $4;
+    $$.C = ConstantExpr::getGetElementPtr($3.C, CIndices);
+    $$.S = Signless;
   }
   | SELECT '(' ConstVal ',' ConstVal ',' ConstVal ')' {
-    *$1 += "(" + *$3->cnst + "," + *$5->cnst + "," + *$7->cnst + ")";
-    delete $3; delete $5; delete $7;
-    $$ = $1;
+    if (!$3.C->getType()->isInteger() ||
+        cast($3.C->getType())->getBitWidth() != 1)
+      error("Select condition must be bool type");
+    if ($5.C->getType() != $7.C->getType())
+      error("Select operand types must match");
+    $$.C = ConstantExpr::getSelect($3.C, $5.C, $7.C);
+    $$.S = Unsigned;
   }
   | ArithmeticOps '(' ConstVal ',' ConstVal ')' {
-    const char* op = getDivRemOpcode(*$1, $3->type); 
-    $$ = new std::string(op);
-    *$$ += "(" + *$3->cnst + "," + *$5->cnst + ")";
-    delete $1; delete $3; delete $5;
+    const Type *Ty = $3.C->getType();
+    if (Ty != $5.C->getType())
+      error("Binary operator types must match");
+    // First, make sure we're dealing with the right opcode by upgrading from
+    // obsolete versions.
+    Instruction::BinaryOps Opcode = getBinaryOp($1, Ty, $3.S);
+
+    // HACK: llvm 1.3 and earlier used to emit invalid pointer constant exprs.
+    // To retain backward compatibility with these early compilers, we emit a
+    // cast to the appropriate integer type automatically if we are in the
+    // broken case.  See PR424 for more information.
+    if (!isa(Ty)) {
+      $$.C = ConstantExpr::get(Opcode, $3.C, $5.C);
+    } else {
+      const Type *IntPtrTy = 0;
+      switch (CurModule.CurrentModule->getPointerSize()) {
+      case Module::Pointer32: IntPtrTy = Type::Int32Ty; break;
+      case Module::Pointer64: IntPtrTy = Type::Int64Ty; break;
+      default: error("invalid pointer binary constant expr");
+      }
+      $$.C = ConstantExpr::get(Opcode, 
+             ConstantExpr::getCast(Instruction::PtrToInt, $3.C, IntPtrTy),
+             ConstantExpr::getCast(Instruction::PtrToInt, $5.C, IntPtrTy));
+      $$.C = ConstantExpr::getCast(Instruction::IntToPtr, $$.C, Ty);
+    }
+    $$.S = $3.S; 
   }
   | LogicalOps '(' ConstVal ',' ConstVal ')' {
-    *$1 += "(" + *$3->cnst + "," + *$5->cnst + ")";
-    delete $3; delete $5;
-    $$ = $1;
+    const Type* Ty = $3.C->getType();
+    if (Ty != $5.C->getType())
+      error("Logical operator types must match");
+    if (!Ty->isInteger()) {
+      if (!isa(Ty) || 
+          !cast(Ty)->getElementType()->isInteger())
+        error("Logical operator requires integer operands");
+    }
+    Instruction::BinaryOps Opcode = getBinaryOp($1, Ty, $3.S);
+    $$.C = ConstantExpr::get(Opcode, $3.C, $5.C);
+    $$.S = $3.S;
   }
   | SetCondOps '(' ConstVal ',' ConstVal ')' {
-    *$1 = getCompareOp(*$1, $3->type);
-    *$1 += "(" + *$3->cnst + "," + *$5->cnst + ")";
-    delete $3; delete $5;
-    $$ = $1;
+    const Type* Ty = $3.C->getType();
+    if (Ty != $5.C->getType())
+      error("setcc operand types must match");
+    unsigned short pred;
+    Instruction::OtherOps Opcode = getCompareOp($1, pred, Ty, $3.S);
+    $$.C = ConstantExpr::getCompare(Opcode, $3.C, $5.C);
+    $$.S = Unsigned;
   }
   | ICMP IPredicates '(' ConstVal ',' ConstVal ')' {
-    *$1 += " " + *$2 + " (" +  *$4->cnst + "," + *$6->cnst + ")";
-    delete $2; delete $4; delete $6;
-    $$ = $1;
+    if ($4.C->getType() != $6.C->getType()) 
+      error("icmp operand types must match");
+    $$.C = ConstantExpr::getCompare($2, $4.C, $6.C);
+    $$.S = Unsigned;
   }
   | FCMP FPredicates '(' ConstVal ',' ConstVal ')' {
-    *$1 += " " + *$2 + " (" + *$4->cnst + "," + *$6->cnst + ")";
-    delete $2; delete $4; delete $6;
-    $$ = $1;
+    if ($4.C->getType() != $6.C->getType()) 
+      error("fcmp operand types must match");
+    $$.C = ConstantExpr::getCompare($2, $4.C, $6.C);
+    $$.S = Unsigned;
   }
   | ShiftOps '(' ConstVal ',' ConstVal ')' {
-    const char* shiftop = $1->c_str();
-    if (*$1 == "shr")
-      shiftop = ($3->type->isUnsigned()) ? "lshr" : "ashr";
-    $$ = new std::string(shiftop);
-    *$$ += "(" + *$3->cnst + "," + *$5->cnst + ")";
-    delete $1; delete $3; delete $5;
+    if (!$5.C->getType()->isInteger() ||
+        cast($5.C->getType())->getBitWidth() != 8)
+      error("Shift count for shift constant must be unsigned byte");
+    if (!$3.C->getType()->isInteger())
+      error("Shift constant expression requires integer operand");
+    $$.C = ConstantExpr::get(getOtherOp($1, $3.S), $3.C, $5.C);
+    $$.S = $3.S;
   }
   | EXTRACTELEMENT '(' ConstVal ',' ConstVal ')' {
-    *$1 += "(" + *$3->cnst + "," + *$5->cnst + ")";
-    delete $3; delete $5;
-    $$ = $1;
+    if (!ExtractElementInst::isValidOperands($3.C, $5.C))
+      error("Invalid extractelement operands");
+    $$.C = ConstantExpr::getExtractElement($3.C, $5.C);
+    $$.S = $3.S;
   }
   | INSERTELEMENT '(' ConstVal ',' ConstVal ',' ConstVal ')' {
-    *$1 += "(" + *$3->cnst + "," + *$5->cnst + "," + *$7->cnst + ")";
-    delete $3; delete $5; delete $7;
-    $$ = $1;
+    if (!InsertElementInst::isValidOperands($3.C, $5.C, $7.C))
+      error("Invalid insertelement operands");
+    $$.C = ConstantExpr::getInsertElement($3.C, $5.C, $7.C);
+    $$.S = $3.S;
   }
   | SHUFFLEVECTOR '(' ConstVal ',' ConstVal ',' ConstVal ')' {
-    *$1 += "(" + *$3->cnst + "," + *$5->cnst + "," + *$7->cnst + ")";
-    delete $3; delete $5; delete $7;
-    $$ = $1;
-  };
+    if (!ShuffleVectorInst::isValidOperands($3.C, $5.C, $7.C))
+      error("Invalid shufflevector operands");
+    $$.C = ConstantExpr::getShuffleVector($3.C, $5.C, $7.C);
+    $$.S = $3.S;
+  }
+  ;
 
 
 // ConstVector - A list of comma separated constants.
-
 ConstVector 
-  : ConstVector ',' ConstVal {
-    *$1 += ", " + *$3->cnst;
-    delete $3;
-    $$ = $1;
+  : ConstVector ',' ConstVal { ($$ = $1)->push_back($3); }
+  | ConstVal {
+    $$ = new std::vector();
+    $$->push_back($1);
   }
-  | ConstVal { $$ = new std::string(*$1->cnst); delete $1; }
   ;
 
 
 // GlobalType - Match either GLOBAL or CONSTANT for global declarations...
-GlobalType : GLOBAL | CONSTANT ;
+GlobalType 
+  : GLOBAL { $$ = false; } 
+  | CONSTANT { $$ = true; }
+  ;
 
 
 //===----------------------------------------------------------------------===//
@@ -1461,819 +2375,1059 @@
 // Module rule: Capture the result of parsing the whole file into a result
 // variable...
 //
-Module : DefinitionList {
-};
+Module 
+  : FunctionList {
+    $$ = ParserResult = $1;
+    CurModule.ModuleDone();
+  }
+  ;
 
-// DefinitionList - Top level definitions
+// FunctionList - A list of functions, preceeded by a constant pool.
 //
-DefinitionList : DefinitionList Function {
-    $$ = 0;
-  } 
-  | DefinitionList FunctionProto {
-    *O << *$2 << '\n';
-    delete $2;
-    $$ = 0;
-  }
-  | DefinitionList MODULE ASM_TOK AsmBlock {
-    *O << "module asm " << ' ' << *$4 << '\n';
-    $$ = 0;
-  }  
-  | DefinitionList IMPLEMENTATION {
-    *O << "implementation\n";
-    $$ = 0;
+FunctionList 
+  : FunctionList Function { $$ = $1; CurFun.FunctionDone(); } 
+  | FunctionList FunctionProto { $$ = $1; }
+  | FunctionList MODULE ASM_TOK AsmBlock { $$ = $1; }  
+  | FunctionList IMPLEMENTATION { $$ = $1; }
+  | ConstPool {
+    $$ = CurModule.CurrentModule;
+    // Emit an error if there are any unresolved types left.
+    if (!CurModule.LateResolveTypes.empty()) {
+      const ValID &DID = CurModule.LateResolveTypes.begin()->first;
+      if (DID.Type == ValID::NameVal) {
+        error("Reference to an undefined type: '"+DID.getName() + "'");
+      } else {
+        error("Reference to an undefined type: #" + itostr(DID.Num));
+      }
+    }
   }
-  | ConstPool { $$ = 0; }
   ;
 
-External : EXTERNAL | UNINITIALIZED { $$ = $1; *$$ = "external"; } ;
-
 // ConstPool - Constants with optional names assigned to them.
-ConstPool : ConstPool OptAssign TYPE TypesV {
-    Type::EnumeratedTypes.push_back($4);
-    if (!$2->empty()) {
-      Type::NamedTypes[*$2] = $4;
-      *O << *$2 << " = ";
+ConstPool 
+  : ConstPool OptAssign TYPE TypesV {
+    // Eagerly resolve types.  This is not an optimization, this is a
+    // requirement that is due to the fact that we could have this:
+    //
+    // %list = type { %list * }
+    // %list = type { %list * }    ; repeated type decl
+    //
+    // If types are not resolved eagerly, then the two types will not be
+    // determined to be the same type!
+    //
+    const Type* Ty = $4.T->get();
+    ResolveTypeTo($2, Ty);
+
+    if (!setTypeName(Ty, $2) && !$2) {
+      // If this is a named type that is not a redefinition, add it to the slot
+      // table.
+      CurModule.Types.push_back(Ty);
     }
-    *O << "type " << $4->getNewTy() << '\n';
-    delete $2; delete $3;
-    $$ = 0;
+    delete $4.T;
   }
   | ConstPool FunctionProto {       // Function prototypes can be in const pool
-    *O << *$2 << '\n';
-    delete $2;
-    $$ = 0;
   }
   | ConstPool MODULE ASM_TOK AsmBlock {  // Asm blocks can be in the const pool
-    *O << *$2 << ' ' << *$3 << ' ' << *$4 << '\n';
-    delete $2; delete $3; delete $4; 
-    $$ = 0;
   }
-  | ConstPool OptAssign OptLinkage GlobalType ConstVal  GlobalVarAttributes {
-    if (!$2->empty()) {
-      std::string Name = getGlobalName($2,*$3, $5->type->getPointerType(),
-                                       *$4 == "constant");
-      *O << Name << " = ";
-    }
-    *O << *$3 << ' ' << *$4 << ' ' << *$5->cnst << ' ' << *$6 << '\n';
-    delete $2; delete $3; delete $4; delete $6; 
-    $$ = 0;
-  }
-  | ConstPool OptAssign External GlobalType Types  GlobalVarAttributes {
-    if (!$2->empty()) {
-      std::string Name = getGlobalName($2,*$3,$5->getPointerType(),
-                                       *$4 == "constant");
-      *O << Name << " = ";
-    }
-    *O <<  *$3 << ' ' << *$4 << ' ' << $5->getNewTy() << ' ' << *$6 << '\n';
-    delete $2; delete $3; delete $4; delete $6;
-    $$ = 0;
-  }
-  | ConstPool OptAssign DLLIMPORT GlobalType Types GlobalVarAttributes {
-    if (!$2->empty()) {
-      std::string Name = getGlobalName($2,*$3,$5->getPointerType(),
-                                       *$4 == "constant");
-      *O << Name << " = ";
-    }
-    *O << *$3 << ' ' << *$4 << ' ' << $5->getNewTy() << ' ' << *$6 << '\n';
-    delete $2; delete $3; delete $4; delete $6;
-    $$ = 0;
-  }
-  | ConstPool OptAssign EXTERN_WEAK GlobalType Types  GlobalVarAttributes {
-    if (!$2->empty()) {
-      std::string Name = getGlobalName($2,*$3,$5->getPointerType(),
-                                       *$4 == "constant");
-      *O << Name << " = ";
-    }
-    *O << *$3 << ' ' << *$4 << ' ' << $5->getNewTy() << ' ' << *$6 << '\n';
-    delete $2; delete $3; delete $4; delete $6;
-    $$ = 0;
+  | ConstPool OptAssign OptLinkage GlobalType ConstVal {
+    if ($5.C == 0) 
+      error("Global value initializer is not a constant");
+    CurGV = ParseGlobalVariable($2, $3, $4, $5.C->getType(), $5.C);
+  } GlobalVarAttributes {
+    CurGV = 0;
+  }
+  | ConstPool OptAssign EXTERNAL GlobalType Types {
+    const Type *Ty = $5.T->get();
+    CurGV = ParseGlobalVariable($2, GlobalValue::ExternalLinkage, $4, Ty, 0);
+    delete $5.T;
+  } GlobalVarAttributes {
+    CurGV = 0;
+  }
+  | ConstPool OptAssign DLLIMPORT GlobalType Types {
+    const Type *Ty = $5.T->get();
+    CurGV = ParseGlobalVariable($2, GlobalValue::DLLImportLinkage, $4, Ty, 0);
+    delete $5.T;
+  } GlobalVarAttributes {
+    CurGV = 0;
+  }
+  | ConstPool OptAssign EXTERN_WEAK GlobalType Types {
+    const Type *Ty = $5.T->get();
+    CurGV = 
+      ParseGlobalVariable($2, GlobalValue::ExternalWeakLinkage, $4, Ty, 0);
+    delete $5.T;
+  } GlobalVarAttributes {
+    CurGV = 0;
   }
   | ConstPool TARGET TargetDefinition { 
-    *O << *$2 << ' ' << *$3 << '\n';
-    delete $2; delete $3;
-    $$ = 0;
   }
   | ConstPool DEPLIBS '=' LibrariesDefinition {
-    *O << *$2 << " = " << *$4 << '\n';
-    delete $2; delete $4;
-    $$ = 0;
   }
   | /* empty: end of list */ { 
-    $$ = 0;
-  };
+  }
+  ;
 
+AsmBlock 
+  : STRINGCONSTANT {
+    const std::string &AsmSoFar = CurModule.CurrentModule->getModuleInlineAsm();
+    char *EndStr = UnEscapeLexed($1, true);
+    std::string NewAsm($1, EndStr);
+    free($1);
 
-AsmBlock : STRINGCONSTANT ;
+    if (AsmSoFar.empty())
+      CurModule.CurrentModule->setModuleInlineAsm(NewAsm);
+    else
+      CurModule.CurrentModule->setModuleInlineAsm(AsmSoFar+"\n"+NewAsm);
+  }
+  ;
 
-BigOrLittle : BIG | LITTLE ;
+BigOrLittle 
+  : BIG    { $$ = Module::BigEndian; };
+  | LITTLE { $$ = Module::LittleEndian; }
+  ;
 
 TargetDefinition 
   : ENDIAN '=' BigOrLittle {
-    *$1 += " = " + *$3;
-    delete $3;
-    $$ = $1;
+    CurModule.setEndianness($3);
   }
   | POINTERSIZE '=' EUINT64VAL {
-    *$1 += " = " + *$3;
-    if (*$3 == "64")
-      SizeOfPointer = 64;
-    delete $3;
-    $$ = $1;
+    if ($3 == 32)
+      CurModule.setPointerSize(Module::Pointer32);
+    else if ($3 == 64)
+      CurModule.setPointerSize(Module::Pointer64);
+    else
+      error("Invalid pointer size: '" + utostr($3) + "'");
   }
   | TRIPLE '=' STRINGCONSTANT {
-    *$1 += " = " + *$3;
-    delete $3;
-    $$ = $1;
+    CurModule.CurrentModule->setTargetTriple($3);
+    free($3);
   }
   | DATALAYOUT '=' STRINGCONSTANT {
-    *$1 += " = " + *$3;
-    delete $3;
-    $$ = $1;
-  };
+    CurModule.CurrentModule->setDataLayout($3);
+    free($3);
+  }
+  ;
 
 LibrariesDefinition 
-  : '[' LibList ']' {
-    $2->insert(0, "[ ");
-    *$2 += " ]";
-    $$ = $2;
-  };
+  : '[' LibList ']'
+  ;
 
 LibList 
   : LibList ',' STRINGCONSTANT {
-    *$1 += ", " + *$3;
-    delete $3;
-    $$ = $1;
+      CurModule.CurrentModule->addLibrary($3);
+      free($3);
   }
-  | STRINGCONSTANT 
-  | /* empty: end of list */ {
-    $$ = new std::string();
-  };
+  | STRINGCONSTANT {
+    CurModule.CurrentModule->addLibrary($1);
+    free($1);
+  }
+  | /* empty: end of list */ { }
+  ;
 
 //===----------------------------------------------------------------------===//
 //                       Rules to match Function Headers
 //===----------------------------------------------------------------------===//
 
-Name : VAR_ID | STRINGCONSTANT;
-OptName : Name | /*empty*/ { $$ = new std::string(); };
+Name 
+  : VAR_ID | STRINGCONSTANT
+  ;
+
+OptName 
+  : Name 
+  | /*empty*/ { $$ = 0; }
+  ;
 
-ArgVal : Types OptName {
-  $$ = new std::string($1->getNewTy());
-  if (!$2->empty()) {
-    std::string Name = getUniqueName($2, $1->resolve());
-    *$$ += " " + Name;
+ArgVal 
+  : Types OptName {
+    if ($1.T->get() == Type::VoidTy)
+      error("void typed arguments are invalid");
+    $$ = new std::pair($1, $2);
   }
-  delete $2;
-};
+  ;
 
-ArgListH : ArgListH ',' ArgVal {
-    *$1 += ", " + *$3;
+ArgListH 
+  : ArgListH ',' ArgVal {
+    $$ = $1;
+    $$->push_back(*$3);
     delete $3;
   }
   | ArgVal {
-    $$ = $1;
-  };
-
-ArgList : ArgListH {
-    $$ = $1;
+    $$ = new std::vector >();
+    $$->push_back(*$1);
+    delete $1;
   }
+  ;
+
+ArgList 
+  : ArgListH { $$ = $1; }
   | ArgListH ',' DOTDOTDOT {
-    *$1 += ", ...";
     $$ = $1;
-    delete $3;
+    PATypeInfo VoidTI;
+    VoidTI.T = new PATypeHolder(Type::VoidTy);
+    VoidTI.S = Signless;
+    $$->push_back(std::pair(VoidTI, 0));
   }
   | DOTDOTDOT {
-    $$ = $1;
+    $$ = new std::vector >();
+    PATypeInfo VoidTI;
+    VoidTI.T = new PATypeHolder(Type::VoidTy);
+    VoidTI.S = Signless;
+    $$->push_back(std::pair(VoidTI, 0));
   }
-  | /* empty */ { $$ = new std::string(); };
+  | /* empty */ { $$ = 0; }
+  ;
 
 FunctionHeaderH 
   : OptCallingConv TypesV Name '(' ArgList ')' OptSection OptAlign {
-    if (*$3 == "%llvm.va_start" || *$3 == "%llvm.va_end") {
-      *$5 = "i8*";
-    } else if (*$3 == "%llvm.va_copy") {
-      *$5 = "i8*, i8*";
-    }
-    if (!$1->empty()) {
-      *$1 += " ";
-    }
-    *$1 += $2->getNewTy() + " " + *$3 + "(" + *$5 + ")";
-    if (!$7->empty()) {
-      *$1 += " " + *$7;
+    UnEscapeLexed($3);
+    std::string FunctionName($3);
+    free($3);  // Free strdup'd memory!
+
+    const Type* RetTy = $2.T->get();
+    
+    if (!RetTy->isFirstClassType() && RetTy != Type::VoidTy)
+      error("LLVM functions cannot return aggregate types");
+
+    std::vector ParamTypeList;
+
+    // In LLVM 2.0 the signatures of three varargs intrinsics changed to take
+    // i8*. We check here for those names and override the parameter list
+    // types to ensure the prototype is correct.
+    if (FunctionName == "llvm.va_start" || FunctionName == "llvm.va_end") {
+      ParamTypeList.push_back(PointerType::get(Type::Int8Ty));
+    } else if (FunctionName == "llvm.va_copy") {
+      ParamTypeList.push_back(PointerType::get(Type::Int8Ty));
+      ParamTypeList.push_back(PointerType::get(Type::Int8Ty));
+    } else if ($5) {   // If there are arguments...
+      for (std::vector >::iterator 
+           I = $5->begin(), E = $5->end(); I != E; ++I) {
+        const Type *Ty = I->first.T->get();
+        ParamTypeList.push_back(Ty);
+      }
     }
-    if (!$8->empty()) {
-      *$1 += " " + *$8;
+
+    bool isVarArg = 
+      ParamTypeList.size() && ParamTypeList.back() == Type::VoidTy;
+    if (isVarArg) ParamTypeList.pop_back();
+
+    const FunctionType *FT = FunctionType::get(RetTy, ParamTypeList, isVarArg);
+    const PointerType *PFT = PointerType::get(FT);
+    delete $2.T;
+
+    ValID ID;
+    if (!FunctionName.empty()) {
+      ID = ValID::create((char*)FunctionName.c_str());
+    } else {
+      ID = ValID::create((int)CurModule.Values[PFT].size());
     }
-    delete $3;
-    delete $5;
-    delete $7;
-    delete $8;
-    $$ = $1;
-  };
 
-BEGIN : BEGINTOK { $$ = new std::string("{"); delete $1; }
-  | '{' { $$ = new std::string ("{"); }
+    Function *Fn = 0;
+    // See if this function was forward referenced.  If so, recycle the object.
+    if (GlobalValue *FWRef = CurModule.GetForwardRefForGlobal(PFT, ID)) {
+      // Move the function to the end of the list, from whereever it was 
+      // previously inserted.
+      Fn = cast(FWRef);
+      CurModule.CurrentModule->getFunctionList().remove(Fn);
+      CurModule.CurrentModule->getFunctionList().push_back(Fn);
+    } else if (!FunctionName.empty() &&     // Merge with an earlier prototype?
+               (Fn = CurModule.CurrentModule->getFunction(FunctionName, FT))) {
+      // If this is the case, either we need to be a forward decl, or it needs 
+      // to be.
+      if (!CurFun.isDeclare && !Fn->isExternal())
+        error("Redefinition of function '" + FunctionName + "'");
+      
+      // Make sure to strip off any argument names so we can't get conflicts.
+      if (Fn->isExternal())
+        for (Function::arg_iterator AI = Fn->arg_begin(), AE = Fn->arg_end();
+             AI != AE; ++AI)
+          AI->setName("");
+    } else  {  // Not already defined?
+      Fn = new Function(FT, GlobalValue::ExternalLinkage, FunctionName,
+                        CurModule.CurrentModule);
+
+      InsertValue(Fn, CurModule.Values);
+    }
+
+    CurFun.FunctionStart(Fn);
+
+    if (CurFun.isDeclare) {
+      // If we have declaration, always overwrite linkage.  This will allow us 
+      // to correctly handle cases, when pointer to function is passed as 
+      // argument to another function.
+      Fn->setLinkage(CurFun.Linkage);
+    }
+    Fn->setCallingConv($1);
+    Fn->setAlignment($8);
+    if ($7) {
+      Fn->setSection($7);
+      free($7);
+    }
+
+    // Add all of the arguments we parsed to the function...
+    if ($5) {                     // Is null if empty...
+      if (isVarArg) {  // Nuke the last entry
+        assert($5->back().first.T->get() == Type::VoidTy && 
+               $5->back().second == 0 && "Not a varargs marker");
+        delete $5->back().first.T;
+        $5->pop_back();  // Delete the last entry
+      }
+      Function::arg_iterator ArgIt = Fn->arg_begin();
+      for (std::vector >::iterator 
+           I = $5->begin(), E = $5->end(); I != E; ++I, ++ArgIt) {
+        delete I->first.T;                        // Delete the typeholder...
+        setValueName(ArgIt, I->second);           // Insert arg into symtab...
+        InsertValue(ArgIt);
+      }
+      delete $5;                     // We're now done with the argument list
+    }
+  }
+  ;
+
+BEGIN 
+  : BEGINTOK | '{'                // Allow BEGIN or '{' to start a function
   ;
 
 FunctionHeader 
   : OptLinkage FunctionHeaderH BEGIN {
-    *O << "define ";
-    if (!$1->empty()) {
-      *O << *$1 << ' ';
-    }
-    *O << *$2 << ' ' << *$3 << '\n';
-    delete $1; delete $2; delete $3;
-    $$ = 0;
+    $$ = CurFun.CurrentFunction;
+
+    // Make sure that we keep track of the linkage type even if there was a
+    // previous "declare".
+    $$->setLinkage($1);
   }
   ;
 
-END : ENDTOK { $$ = new std::string("}"); delete $1; }
-    | '}' { $$ = new std::string("}"); };
+END 
+  : ENDTOK | '}'                    // Allow end of '}' to end a function
+  ;
 
-Function : FunctionHeader BasicBlockList END {
-  if ($2)
-    *O << *$2;
-  *O << *$3 << "\n\n";
-  delete $1; delete $2; delete $3;
-  $$ = 0;
-};
+Function 
+  : BasicBlockList END {
+    $$ = $1;
+  };
 
 FnDeclareLinkage
-  : /*default*/ { $$ = new std::string(); }
-  | DLLIMPORT    
-  | EXTERN_WEAK 
+  : /*default*/ 
+  | DLLIMPORT   { CurFun.Linkage = GlobalValue::DLLImportLinkage; } 
+  | EXTERN_WEAK { CurFun.Linkage = GlobalValue::ExternalWeakLinkage; }
   ;
   
 FunctionProto 
-  : DECLARE { isDeclare = true; } FnDeclareLinkage FunctionHeaderH { 
-    if (!$3->empty())
-      *$1 += " " + *$3;
-    *$1 += " " + *$4;
-    delete $3;
-    delete $4;
-    $$ = $1;
-    isDeclare = false;
-  };
+  : DECLARE { CurFun.isDeclare = true; } FnDeclareLinkage FunctionHeaderH {
+    $$ = CurFun.CurrentFunction;
+    CurFun.FunctionDone();
+    
+  }
+  ;
 
 //===----------------------------------------------------------------------===//
 //                        Rules to match Basic Blocks
 //===----------------------------------------------------------------------===//
 
-OptSideEffect : /* empty */ { $$ = new std::string(); }
-  | SIDEEFFECT;
+OptSideEffect 
+  : /* empty */ { $$ = false; }
+  | SIDEEFFECT { $$ = true; }
+  ;
 
 ConstValueRef 
-  : ESINT64VAL | EUINT64VAL | FPVAL | TRUETOK | FALSETOK | NULL_TOK | UNDEF
-  | ZEROINITIALIZER 
-  | '<' ConstVector '>' { 
-    $2->insert(0, "<");
-    *$2 += ">";
-    $$ = $2;
+    // A reference to a direct constant
+  : ESINT64VAL {    $$ = ValID::create($1); }
+  | EUINT64VAL { $$ = ValID::create($1); }
+  | FPVAL { $$ = ValID::create($1); } 
+  | TRUETOK { $$ = ValID::create(ConstantInt::get(Type::Int1Ty, true)); } 
+  | FALSETOK { $$ = ValID::create(ConstantInt::get(Type::Int1Ty, false)); }
+  | NULL_TOK { $$ = ValID::createNull(); }
+  | UNDEF { $$ = ValID::createUndef(); }
+  | ZEROINITIALIZER { $$ = ValID::createZeroInit(); }
+  | '<' ConstVector '>' { // Nonempty unsized packed vector
+    const Type *ETy = (*$2)[0].C->getType();
+    int NumElements = $2->size(); 
+    PackedType* pt = PackedType::get(ETy, NumElements);
+    PATypeHolder* PTy = new PATypeHolder(
+      HandleUpRefs(PackedType::get(ETy, NumElements)));
+    
+    // Verify all elements are correct type!
+    std::vector Elems;
+    for (unsigned i = 0; i < $2->size(); i++) {
+      Constant *C = (*$2)[i].C;
+      const Type *CTy = C->getType();
+      if (ETy != CTy)
+        error("Element #" + utostr(i) + " is not of type '" + 
+              ETy->getDescription() +"' as required!\nIt is of type '" +
+              CTy->getDescription() + "'");
+      Elems.push_back(C);
+    }
+    $$ = ValID::create(ConstantPacked::get(pt, Elems));
+    delete PTy; delete $2;
+  }
+  | ConstExpr {
+    $$ = ValID::create($1.C);
   }
-  | ConstExpr 
   | ASM_TOK OptSideEffect STRINGCONSTANT ',' STRINGCONSTANT {
-    if (!$2->empty()) {
-      *$1 += " " + *$2;
-    }
-    *$1 += " " + *$3 + ", " + *$5;
-    delete $2; delete $3; delete $5;
-    $$ = $1;
-  };
+    char *End = UnEscapeLexed($3, true);
+    std::string AsmStr = std::string($3, End);
+    End = UnEscapeLexed($5, true);
+    std::string Constraints = std::string($5, End);
+    $$ = ValID::createInlineAsm(AsmStr, Constraints, $2);
+    free($3);
+    free($5);
+  }
+  ;
 
-SymbolicValueRef : IntVal | Name ;
+// SymbolicValueRef - Reference to one of two ways of symbolically refering to
+// another value.
+//
+SymbolicValueRef 
+  : INTVAL {  $$ = ValID::create($1); }
+  | Name   {  $$ = ValID::create($1); }
+  ;
 
 // ValueRef - A reference to a definition... either constant or symbolic
 ValueRef 
-  : SymbolicValueRef {
-    $$ = new Value;
-    $$->val = $1;
-    $$->constant = false;
-    $$->type = 0;
-  }
-  | ConstValueRef {
-    $$ = new Value;
-    $$->val = $1;
-    $$->constant = true;
-    $$->type = 0;
-  }
+  : SymbolicValueRef | ConstValueRef
   ;
 
+
 // ResolvedVal - a   pair.  This is used only in cases where the
 // type immediately preceeds the value reference, and allows complex constant
 // pool references (for things like: 'ret [2 x int] [ int 12, int 42]')
-ResolvedVal : Types ValueRef {
-    $1 = $1->resolve();
-    std::string Name = getUniqueName($2->val, $1);
-    $$ = $2;
-    delete $$->val;
-    $$->val = new std::string($1->getNewTy() + " " + Name);
-    $$->type = $1;
-  };
+ResolvedVal 
+  : Types ValueRef { 
+    const Type *Ty = $1.T->get();
+    $$.S = $1.S;
+    $$.V = getVal(Ty, $2); 
+    delete $1.T;
+  }
+  ;
 
-BasicBlockList : BasicBlockList BasicBlock {
-    $$ = 0;
+BasicBlockList 
+  : BasicBlockList BasicBlock {
+    $$ = $1;
   }
-  | BasicBlock { // Do not allow functions with 0 basic blocks   
-    $$ = 0;
+  | FunctionHeader BasicBlock { // Do not allow functions with 0 basic blocks   
+    $$ = $1;
   };
 
 
 // Basic blocks are terminated by branching instructions: 
 // br, br/cc, switch, ret
 //
-BasicBlock : InstructionList BBTerminatorInst  {
-    $$ = 0;
-  };
+BasicBlock 
+  : InstructionList OptAssign BBTerminatorInst  {
+    setValueName($3, $2);
+    InsertValue($3);
+    $1->getInstList().push_back($3);
+    InsertValue($1);
+    $$ = $1;
+  }
+  ;
 
-InstructionList : InstructionList Inst {
-    *O << "    " << *$2 << '\n';
-    delete $2;
-    $$ = 0;
+InstructionList
+  : InstructionList Inst {
+    if ($2.I)
+      $1->getInstList().push_back($2.I);
+    $$ = $1;
   }
   | /* empty */ {
-    $$ = 0;
+    $$ = CurBB = getBBVal(ValID::create((int)CurFun.NextBBNum++), true);
+    // Make sure to move the basic block to the correct location in the
+    // function, instead of leaving it inserted wherever it was first
+    // referenced.
+    Function::BasicBlockListType &BBL = 
+      CurFun.CurrentFunction->getBasicBlockList();
+    BBL.splice(BBL.end(), BBL, $$);
   }
   | LABELSTR {
-    *O << *$1 << '\n';
-    delete $1;
-    $$ = 0;
-  };
+    $$ = CurBB = getBBVal(ValID::create($1), true);
+    // Make sure to move the basic block to the correct location in the
+    // function, instead of leaving it inserted wherever it was first
+    // referenced.
+    Function::BasicBlockListType &BBL = 
+      CurFun.CurrentFunction->getBasicBlockList();
+    BBL.splice(BBL.end(), BBL, $$);
+  }
+  ;
 
-Unwind : UNWIND | EXCEPT { $$ = $1; *$$ = "unwind"; } ;
+Unwind : UNWIND | EXCEPT;
 
-BBTerminatorInst : RET ResolvedVal {              // Return with a result...
-    *O << "    " << *$1 << ' ' << *$2->val << '\n';
-    delete $1; delete $2;
-    $$ = 0;
+BBTerminatorInst 
+  : RET ResolvedVal {              // Return with a result...
+    $$ = new ReturnInst($2.V);
   }
   | RET VOID {                                       // Return with no result...
-    *O << "    " << *$1 << ' ' << $2->getNewTy() << '\n';
-    delete $1;
-    $$ = 0;
+    $$ = new ReturnInst();
   }
   | BR LABEL ValueRef {                         // Unconditional Branch...
-    *O << "    " << *$1 << ' ' << $2->getNewTy() << ' ' << *$3->val << '\n';
-    delete $1; delete $3;
-    $$ = 0;
+    BasicBlock* tmpBB = getBBVal($3);
+    $$ = new BranchInst(tmpBB);
   }                                                  // Conditional Branch...
   | BR BOOL ValueRef ',' LABEL ValueRef ',' LABEL ValueRef {  
-    std::string Name = getUniqueName($3->val, $2);
-    *O << "    " << *$1 << ' ' << $2->getNewTy() << ' ' << Name << ", " 
-       << $5->getNewTy() << ' ' << *$6->val << ", " << $8->getNewTy() << ' ' 
-       << *$9->val << '\n';
-    delete $1; delete $3; delete $6; delete $9;
-    $$ = 0;
+    BasicBlock* tmpBBA = getBBVal($6);
+    BasicBlock* tmpBBB = getBBVal($9);
+    Value* tmpVal = getVal(Type::Int1Ty, $3);
+    $$ = new BranchInst(tmpBBA, tmpBBB, tmpVal);
   }
   | SWITCH IntType ValueRef ',' LABEL ValueRef '[' JumpTable ']' {
-    std::string Name = getUniqueName($3->val, $2);
-    *O << "    " << *$1 << ' ' << $2->getNewTy() << ' ' << Name << ", " 
-       << $5->getNewTy() << ' ' << *$6->val << " [" << *$8 << " ]\n";
-    delete $1; 
-    delete $3;
-    delete $6; 
+    Value* tmpVal = getVal($2.T, $3);
+    BasicBlock* tmpBB = getBBVal($6);
+    SwitchInst *S = new SwitchInst(tmpVal, tmpBB, $8->size());
+    $$ = S;
+    std::vector >::iterator I = $8->begin(),
+      E = $8->end();
+    for (; I != E; ++I) {
+      if (ConstantInt *CI = dyn_cast(I->first))
+          S->addCase(CI, I->second);
+      else
+        error("Switch case is constant, but not a simple integer");
+    }
     delete $8;
-    $$ = 0;
   }
   | SWITCH IntType ValueRef ',' LABEL ValueRef '[' ']' {
-    std::string Name = getUniqueName($3->val, $2);
-    *O << "    " << *$1 << ' ' << $2->getNewTy() << ' ' << Name << ", " 
-       << $5->getNewTy() << ' ' << *$6->val << "[]\n";
-    delete $1; 
-    delete $3; 
-    delete $6;
-    $$ = 0;
+    Value* tmpVal = getVal($2.T, $3);
+    BasicBlock* tmpBB = getBBVal($6);
+    SwitchInst *S = new SwitchInst(tmpVal, tmpBB, 0);
+    $$ = S;
   }
-  | OptAssign INVOKE OptCallingConv TypesV ValueRef '(' ValueRefListE ')'
+  | INVOKE OptCallingConv TypesV ValueRef '(' ValueRefListE ')'
     TO LABEL ValueRef Unwind LABEL ValueRef {
-    const Type* ResTy = getFunctionReturnType($4);
-    *O << "    ";
-    if (!$1->empty()) {
-      std::string Name = getUniqueName($1, ResTy);
-      *O << Name << " = ";
-    }
-    *O << *$2 << ' ' << *$3 << ' ' << $4->getNewTy() << ' ' << *$5->val << " (";
-    for (unsigned i = 0; i < $7->size(); ++i) {
-      Value* V = (*$7)[i];
-      *O << *V->val;
-      if (i+1 < $7->size())
-        *O << ", ";
-      delete V;
-    }
-    *O << ") " << *$9 << ' ' << $10->getNewTy() << ' ' << *$11->val << ' ' 
-       << *$12 << ' ' << $13->getNewTy() << ' ' << *$14->val << '\n';
-    delete $1; delete $2; delete $3; delete $5; delete $7; 
-    delete $9; delete $11; delete $12; delete $14; 
-    $$ = 0;
+    const PointerType *PFTy;
+    const FunctionType *Ty;
+
+    if (!(PFTy = dyn_cast($3.T->get())) ||
+        !(Ty = dyn_cast(PFTy->getElementType()))) {
+      // Pull out the types of all of the arguments...
+      std::vector ParamTypes;
+      if ($6) {
+        for (std::vector::iterator I = $6->begin(), E = $6->end();
+             I != E; ++I)
+          ParamTypes.push_back((*I).V->getType());
+      }
+      bool isVarArg = ParamTypes.size() && ParamTypes.back() == Type::VoidTy;
+      if (isVarArg) ParamTypes.pop_back();
+      Ty = FunctionType::get($3.T->get(), ParamTypes, isVarArg);
+      PFTy = PointerType::get(Ty);
+    }
+    Value *V = getVal(PFTy, $4);   // Get the function we're calling...
+    BasicBlock *Normal = getBBVal($10);
+    BasicBlock *Except = getBBVal($13);
+
+    // Create the call node...
+    if (!$6) {                                   // Has no arguments?
+      $$ = new InvokeInst(V, Normal, Except, std::vector());
+    } else {                                     // Has arguments?
+      // Loop through FunctionType's arguments and ensure they are specified
+      // correctly!
+      //
+      FunctionType::param_iterator I = Ty->param_begin();
+      FunctionType::param_iterator E = Ty->param_end();
+      std::vector::iterator ArgI = $6->begin(), ArgE = $6->end();
+
+      std::vector Args;
+      for (; ArgI != ArgE && I != E; ++ArgI, ++I) {
+        if ((*ArgI).V->getType() != *I)
+          error("Parameter " +(*ArgI).V->getName()+ " is not of type '" +
+                (*I)->getDescription() + "'");
+        Args.push_back((*ArgI).V);
+      }
+
+      if (I != E || (ArgI != ArgE && !Ty->isVarArg()))
+        error("Invalid number of parameters detected");
+
+      $$ = new InvokeInst(V, Normal, Except, Args);
+    }
+    cast($$)->setCallingConv($2);
+    delete $3.T;
+    delete $6;
   }
   | Unwind {
-    *O << "    " << *$1 << '\n';
-    delete $1;
-    $$ = 0;
+    $$ = new UnwindInst();
   }
   | UNREACHABLE {
-    *O << "    " << *$1 << '\n';
-    delete $1;
-    $$ = 0;
-  };
+    $$ = new UnreachableInst();
+  }
+  ;
 
-JumpTable : JumpTable IntType ConstValueRef ',' LABEL ValueRef {
-    *$1 += " " + $2->getNewTy() + " " + *$3 + ", " + $5->getNewTy() + " " + 
-           *$6->val;
-    delete $3; delete $6;
+JumpTable 
+  : JumpTable IntType ConstValueRef ',' LABEL ValueRef {
     $$ = $1;
+    Constant *V = cast(getExistingValue($2.T, $3));
+    
+    if (V == 0)
+      error("May only switch on a constant pool value");
+
+    BasicBlock* tmpBB = getBBVal($6);
+    $$->push_back(std::make_pair(V, tmpBB));
   }
   | IntType ConstValueRef ',' LABEL ValueRef {
-    $2->insert(0, $1->getNewTy() + " " );
-    *$2 += ", " + $4->getNewTy() + " " + *$5->val;
-    delete $5;
-    $$ = $2;
-  };
+    $$ = new std::vector >();
+    Constant *V = cast(getExistingValue($1.T, $2));
+
+    if (V == 0)
+      error("May only switch on a constant pool value");
+
+    BasicBlock* tmpBB = getBBVal($5);
+    $$->push_back(std::make_pair(V, tmpBB)); 
+  }
+  ;
 
 Inst 
   : OptAssign InstVal {
-    if (!$1->empty()) {
-      // Get a unique name for this value, based on its type.
-      std::string Name = getUniqueName($1, $2->type);
-      *$1 = Name + " = ";
-      if (deleteUselessCastFlag && *deleteUselessCastName == Name) {
-        // don't actually delete it, just comment it out
-        $1->insert(0, "; USELSS BITCAST: "); 
-        delete deleteUselessCastName;
-      }
+    bool omit = false;
+    if ($1)
+      if (BitCastInst *BCI = dyn_cast($2.I))
+        if (BCI->getSrcTy() == BCI->getDestTy() && 
+            BCI->getOperand(0)->getName() == $1)
+          // This is a useless bit cast causing a name redefinition. It is
+          // a bit cast from a type to the same type of an operand with the
+          // same name as the name we would give this instruction. Since this
+          // instruction results in no code generation, it is safe to omit
+          // the instruction. This situation can occur because of collapsed
+          // type planes. For example:
+          //   %X = add int %Y, %Z
+          //   %X = cast int %Y to uint
+          // After upgrade, this looks like:
+          //   %X = add i32 %Y, %Z
+          //   %X = bitcast i32 to i32
+          // The bitcast is clearly useless so we omit it.
+          omit = true;
+    if (omit) {
+      $$.I = 0;
+      $$.S = Signless;
+    } else {
+      setValueName($2.I, $1);
+      InsertValue($2.I);
+      $$ = $2;
     }
-    *$1 += *$2->val;
-    delete $2;
-    deleteUselessCastFlag = false;
-    $$ = $1; 
   };
 
-PHIList 
-  : Types '[' ValueRef ',' ValueRef ']' {    // Used for PHI nodes
-    std::string Name = getUniqueName($3->val, $1);
-    Name.insert(0, $1->getNewTy() + "[");
-    Name += "," + *$5->val + "]";
-    $$ = new Value;
-    $$->val = new std::string(Name);
-    $$->type = $1;
-    delete $3; delete $5;
+PHIList : Types '[' ValueRef ',' ValueRef ']' {    // Used for PHI nodes
+    $$.P = new std::list >();
+    $$.S = $1.S;
+    Value* tmpVal = getVal($1.T->get(), $3);
+    BasicBlock* tmpBB = getBBVal($5);
+    $$.P->push_back(std::make_pair(tmpVal, tmpBB));
+    delete $1.T;
   }
   | PHIList ',' '[' ValueRef ',' ValueRef ']' {
-    std::string Name = getUniqueName($4->val, $1->type);
-    *$1->val += ", [" + Name + "," + *$6->val + "]";
-    delete $4; 
-    delete $6;
     $$ = $1;
-  };
-
+    Value* tmpVal = getVal($1.P->front().first->getType(), $4);
+    BasicBlock* tmpBB = getBBVal($6);
+    $1.P->push_back(std::make_pair(tmpVal, tmpBB));
+  }
+  ;
 
-ValueRefList 
-  : ResolvedVal {
-    $$ = new ValueList();
+ValueRefList : ResolvedVal {    // Used for call statements, and memory insts...
+    $$ = new std::vector();
     $$->push_back($1);
   }
   | ValueRefList ',' ResolvedVal {
     $$ = $1;
-    $$->push_back($3);
+    $1->push_back($3);
   };
 
 // ValueRefListE - Just like ValueRefList, except that it may also be empty!
 ValueRefListE 
-  : ValueRefList  { $$ = $1; }
-  | /*empty*/ { $$ = new ValueList(); }
+  : ValueRefList 
+  | /*empty*/ { $$ = 0; }
   ;
 
 OptTailCall 
   : TAIL CALL {
-    *$1 += " " + *$2;
-    delete $2;
-    $$ = $1;
+    $$ = true;
+  }
+  | CALL {
+    $$ = false;
   }
-  | CALL 
   ;
 
-InstVal : ArithmeticOps Types ValueRef ',' ValueRef {
-    const char* op = getDivRemOpcode(*$1, $2); 
-    std::string Name1 = getUniqueName($3->val, $2);
-    std::string Name2 = getUniqueName($5->val, $2);
-    $$ = $3;
-    delete $$->val;
-    $$->val = new std::string(op);
-    *$$->val += " " + $2->getNewTy() + " " + Name1 + ", " + Name2;
-    $$->type = $2;
-    delete $1; delete $5;
+InstVal 
+  : ArithmeticOps Types ValueRef ',' ValueRef {
+    const Type* Ty = $2.T->get();
+    if (!Ty->isInteger() && !Ty->isFloatingPoint() && !isa(Ty))
+      error("Arithmetic operator requires integer, FP, or packed operands");
+    if (isa(Ty) && 
+        ($1 == URemOp || $1 == SRemOp || $1 == FRemOp || $1 == RemOp))
+      error("Remainder not supported on packed types");
+    // Upgrade the opcode from obsolete versions before we do anything with it.
+    Instruction::BinaryOps Opcode = getBinaryOp($1, Ty, $2.S);
+    Value* val1 = getVal(Ty, $3); 
+    Value* val2 = getVal(Ty, $5);
+    $$.I = BinaryOperator::create(Opcode, val1, val2);
+    if ($$.I == 0)
+      error("binary operator returned null");
+    $$.S = $2.S;
+    delete $2.T;
   }
   | LogicalOps Types ValueRef ',' ValueRef {
-    std::string Name1 = getUniqueName($3->val, $2);
-    std::string Name2 = getUniqueName($5->val, $2);
-    *$1 += " " + $2->getNewTy() + " " + Name1 + ", " + Name2;
-    $$ = $3;
-    delete $$->val;
-    $$->val = $1;
-    $$->type = $2;
-    delete $5;
+    const Type *Ty = $2.T->get();
+    if (!Ty->isInteger()) {
+      if (!isa(Ty) ||
+          !cast(Ty)->getElementType()->isInteger())
+        error("Logical operator requires integral operands");
+    }
+    Instruction::BinaryOps Opcode = getBinaryOp($1, Ty, $2.S);
+    Value* tmpVal1 = getVal(Ty, $3);
+    Value* tmpVal2 = getVal(Ty, $5);
+    $$.I = BinaryOperator::create(Opcode, tmpVal1, tmpVal2);
+    if ($$.I == 0)
+      error("binary operator returned null");
+    $$.S = $2.S;
+    delete $2.T;
   }
   | SetCondOps Types ValueRef ',' ValueRef {
-    std::string Name1 = getUniqueName($3->val, $2);
-    std::string Name2 = getUniqueName($5->val, $2);
-    *$1 = getCompareOp(*$1, $2);
-    *$1 += " " + $2->getNewTy() + " " + Name1 + ", " + Name2;
-    $$ = $3;
-    delete $$->val;
-    $$->val = $1;
-    $$->type = Type::get("i1",BoolTy);
-    delete $5;
+    const Type* Ty = $2.T->get();
+    if(isa(Ty))
+      error("PackedTypes currently not supported in setcc instructions");
+    unsigned short pred;
+    Instruction::OtherOps Opcode = getCompareOp($1, pred, Ty, $2.S);
+    Value* tmpVal1 = getVal(Ty, $3);
+    Value* tmpVal2 = getVal(Ty, $5);
+    $$.I = CmpInst::create(Opcode, pred, tmpVal1, tmpVal2);
+    if ($$.I == 0)
+      error("binary operator returned null");
+    $$.S = Unsigned;
+    delete $2.T;
   }
   | ICMP IPredicates Types ValueRef ',' ValueRef {
-    std::string Name1 = getUniqueName($4->val, $3);
-    std::string Name2 = getUniqueName($6->val, $3);
-    *$1 += " " + *$2 + " " + $3->getNewTy() + " " + Name1 + "," + Name2;
-    $$ = $4;
-    delete $$->val;
-    $$->val = $1;
-    $$->type = Type::get("i1",BoolTy);
-    delete $2; delete $6;
+    const Type *Ty = $3.T->get();
+    if (isa(Ty)) 
+      error("PackedTypes currently not supported in icmp instructions");
+    else if (!Ty->isInteger() && !isa(Ty))
+      error("icmp requires integer or pointer typed operands");
+    Value* tmpVal1 = getVal(Ty, $4);
+    Value* tmpVal2 = getVal(Ty, $6);
+    $$.I = new ICmpInst($2, tmpVal1, tmpVal2);
+    $$.S = Unsigned;
+    delete $3.T;
   }
   | FCMP FPredicates Types ValueRef ',' ValueRef {
-    std::string Name1 = getUniqueName($4->val, $3);
-    std::string Name2 = getUniqueName($6->val, $3);
-    *$1 += " " + *$2 + " " + $3->getNewTy() + " " + Name1 + "," + Name2;
-    $$ = $4;
-    delete $$->val;
-    $$->val = $1;
-    $$->type = Type::get("i1",BoolTy);
-    delete $2; delete $6;
+    const Type *Ty = $3.T->get();
+    if (isa(Ty))
+      error("PackedTypes currently not supported in fcmp instructions");
+    else if (!Ty->isFloatingPoint())
+      error("fcmp instruction requires floating point operands");
+    Value* tmpVal1 = getVal(Ty, $4);
+    Value* tmpVal2 = getVal(Ty, $6);
+    $$.I = new FCmpInst($2, tmpVal1, tmpVal2);
+    $$.S = Unsigned;
+    delete $3.T;
+  }
+  | NOT ResolvedVal {
+    warning("Use of obsolete 'not' instruction: Replacing with 'xor");
+    const Type *Ty = $2.V->getType();
+    Value *Ones = ConstantInt::getAllOnesValue(Ty);
+    if (Ones == 0)
+      error("Expected integral type for not instruction");
+    $$.I = BinaryOperator::create(Instruction::Xor, $2.V, Ones);
+    if ($$.I == 0)
+      error("Could not create a xor instruction");
+    $$.S = $2.S
   }
   | ShiftOps ResolvedVal ',' ResolvedVal {
-    const char* shiftop = $1->c_str();
-    if (*$1 == "shr")
-      shiftop = ($2->type->isUnsigned()) ? "lshr" : "ashr";
-    std::string *val = new std::string(shiftop);
-    *val += " " + *$2->val + ", " + *$4->val;
-    $$ = $2;
-    delete $$->val;
-    $$->val = val;
-    delete $1; delete $4;
+    if (!$4.V->getType()->isInteger() ||
+        cast($4.V->getType())->getBitWidth() != 8)
+      error("Shift amount must be int8");
+    if (!$2.V->getType()->isInteger())
+      error("Shift constant expression requires integer operand");
+    $$.I = new ShiftInst(getOtherOp($1, $2.S), $2.V, $4.V);
+    $$.S = $2.S;
   }
   | CastOps ResolvedVal TO Types {
-    std::string source = *$2->val;
-    const Type* SrcTy = $2->type->resolve();
-    const Type* DstTy = $4->resolve();
-    $$ = $2;
-    delete $$->val;
-    $$->val = new std::string();
-    $$->type = DstTy;
-    if (*$1 == "cast") {
-      *$$->val += getCastUpgrade(source, SrcTy, DstTy, false);
-    } else {
-      *$$->val += *$1 + " " + source + " to " + DstTy->getNewTy();
-    }
-    // Check to see if this is a useless cast of a value to the same name
-    // and the same type. Such casts will probably cause redefinition errors
-    // when assembled and perform no code gen action so just remove them.
-    if (*$1 == "cast" || *$1 == "bitcast")
-      if (SrcTy->isInteger() && DstTy->isInteger() &&
-          SrcTy->getBitWidth() == DstTy->getBitWidth()) {
-        deleteUselessCastFlag = true; // Flag the "Inst" rule
-        deleteUselessCastName = new std::string(*$2->val); // save the name
-        size_t pos = deleteUselessCastName->find_first_of("%\"",0);
-        if (pos != std::string::npos) {
-          // remove the type portion before val
-          deleteUselessCastName->erase(0, pos);
-        }
-      }
-    delete $1; 
-    delete $3;
+    const Type *DstTy = $4.T->get();
+    if (!DstTy->isFirstClassType())
+      error("cast instruction to a non-primitive type: '" +
+            DstTy->getDescription() + "'");
+    $$.I = cast(getCast($1, $2.V, $2.S, DstTy, $4.S, true));
+    $$.S = $4.S;
+    delete $4.T;
   }
   | SELECT ResolvedVal ',' ResolvedVal ',' ResolvedVal {
-    *$1 += " " + *$2->val + ", " + *$4->val + ", " + *$6->val;
-    $$ = $2;
-    delete $$->val;
-    $$->val = $1;
-    $$->type = $4->type;
-    delete $4;
-    delete $6;
+    if (!$2.V->getType()->isInteger() ||
+        cast($2.V->getType())->getBitWidth() != 1)
+      error("select condition must be bool");
+    if ($4.V->getType() != $6.V->getType())
+      error("select value types should match");
+    $$.I = new SelectInst($2.V, $4.V, $6.V);
+    $$.S = $2.S;
   }
   | VAARG ResolvedVal ',' Types {
-    *$1 += " " + *$2->val + ", " + $4->getNewTy();
-    $$ = $2;
-    delete $$->val;
-    $$->val = $1;
-    $$->type = $4;
+    const Type *Ty = $4.T->get();
+    NewVarArgs = true;
+    $$.I = new VAArgInst($2.V, Ty);
+    $$.S = $4.S;
+    delete $4.T;
+  }
+  | VAARG_old ResolvedVal ',' Types {
+    const Type* ArgTy = $2.V->getType();
+    const Type* DstTy = $4.T->get();
+    ObsoleteVarArgs = true;
+    Function* NF = cast(CurModule.CurrentModule->
+      getOrInsertFunction("llvm.va_copy", ArgTy, ArgTy, (Type *)0));
+
+    //b = vaarg a, t -> 
+    //foo = alloca 1 of t
+    //bar = vacopy a 
+    //store bar -> foo
+    //b = vaarg foo, t
+    AllocaInst* foo = new AllocaInst(ArgTy, 0, "vaarg.fix");
+    CurBB->getInstList().push_back(foo);
+    CallInst* bar = new CallInst(NF, $2.V);
+    CurBB->getInstList().push_back(bar);
+    CurBB->getInstList().push_back(new StoreInst(bar, foo));
+    $$.I = new VAArgInst(foo, DstTy);
+    $$.S = $4.S;
+    delete $4.T;
+  }
+  | VANEXT_old ResolvedVal ',' Types {
+    const Type* ArgTy = $2.V->getType();
+    const Type* DstTy = $4.T->get();
+    ObsoleteVarArgs = true;
+    Function* NF = cast(CurModule.CurrentModule->
+      getOrInsertFunction("llvm.va_copy", ArgTy, ArgTy, (Type *)0));
+
+    //b = vanext a, t ->
+    //foo = alloca 1 of t
+    //bar = vacopy a
+    //store bar -> foo
+    //tmp = vaarg foo, t
+    //b = load foo
+    AllocaInst* foo = new AllocaInst(ArgTy, 0, "vanext.fix");
+    CurBB->getInstList().push_back(foo);
+    CallInst* bar = new CallInst(NF, $2.V);
+    CurBB->getInstList().push_back(bar);
+    CurBB->getInstList().push_back(new StoreInst(bar, foo));
+    Instruction* tmp = new VAArgInst(foo, DstTy);
+    CurBB->getInstList().push_back(tmp);
+    $$.I = new LoadInst(foo);
+    $$.S = $4.S;
+    delete $4.T;
   }
   | EXTRACTELEMENT ResolvedVal ',' ResolvedVal {
-    *$1 += " " + *$2->val + ", " + *$4->val;
-    $$ = $2;
-    delete $$->val;
-    $$->val = $1;
-    $$->type = $$->type->resolve();
-    $$->type = $$->type->getElementType();
-    delete $4;
+    if (!ExtractElementInst::isValidOperands($2.V, $4.V))
+      error("Invalid extractelement operands");
+    $$.I = new ExtractElementInst($2.V, $4.V);
+    $$.S = $2.S;
   }
   | INSERTELEMENT ResolvedVal ',' ResolvedVal ',' ResolvedVal {
-    *$1 += " " + *$2->val + ", " + *$4->val + ", " + *$6->val;
-    $$ = $2;
-    delete $$->val;
-    $$->val = $1;
-    delete $4; delete $6;
+    if (!InsertElementInst::isValidOperands($2.V, $4.V, $6.V))
+      error("Invalid insertelement operands");
+    $$.I = new InsertElementInst($2.V, $4.V, $6.V);
+    $$.S = $2.S;
   }
   | SHUFFLEVECTOR ResolvedVal ',' ResolvedVal ',' ResolvedVal {
-    *$1 += " " + *$2->val + ", " + *$4->val + ", " + *$6->val;
-    $$ = $2;
-    delete $$->val;
-    $$->val = $1;
-    delete $4; delete $6;
+    if (!ShuffleVectorInst::isValidOperands($2.V, $4.V, $6.V))
+      error("Invalid shufflevector operands");
+    $$.I = new ShuffleVectorInst($2.V, $4.V, $6.V);
+    $$.S = $2.S;
   }
   | PHI_TOK PHIList {
-    *$1 += " " + *$2->val;
-    $$ = $2;
-    delete $2->val;
-    $$->val = $1;
+    const Type *Ty = $2.P->front().first->getType();
+    if (!Ty->isFirstClassType())
+      error("PHI node operands must be of first class type");
+    PHINode *PHI = new PHINode(Ty);
+    PHI->reserveOperandSpace($2.P->size());
+    while ($2.P->begin() != $2.P->end()) {
+      if ($2.P->front().first->getType() != Ty) 
+        error("All elements of a PHI node must be of the same type");
+      PHI->addIncoming($2.P->front().first, $2.P->front().second);
+      $2.P->pop_front();
+    }
+    $$.I = PHI;
+    $$.S = $2.S;
+    delete $2.P;  // Free the list...
   }
   | OptTailCall OptCallingConv TypesV ValueRef '(' ValueRefListE ')'  {
-    // map llvm.isunordered to "fcmp uno" 
-    $$ = new Value;
-    if (*$4->val == "%llvm.isunordered.f32" ||
-        *$4->val == "%llvm.isunordered.f64") {
-      $$->val = new std::string( "fcmp uno " + *(*$6)[0]->val + ", ");
-      size_t pos = (*$6)[1]->val->find(' ');
-      assert(pos != std::string::npos && "no space?");
-      *$$->val += (*$6)[1]->val->substr(pos+1);
-      $$->type = Type::get("i1", BoolTy);
+
+    // Handle the short call syntax
+    const PointerType *PFTy;
+    const FunctionType *FTy;
+    if (!(PFTy = dyn_cast($3.T->get())) ||
+        !(FTy = dyn_cast(PFTy->getElementType()))) {
+      // Pull out the types of all of the arguments...
+      std::vector ParamTypes;
+      if ($6) {
+        for (std::vector::iterator I = $6->begin(), E = $6->end();
+             I != E; ++I)
+          ParamTypes.push_back((*I).V->getType());
+      }
+
+      bool isVarArg = ParamTypes.size() && ParamTypes.back() == Type::VoidTy;
+      if (isVarArg) ParamTypes.pop_back();
+
+      const Type *RetTy = $3.T->get();
+      if (!RetTy->isFirstClassType() && RetTy != Type::VoidTy)
+        error("Functions cannot return aggregate types");
+
+      FTy = FunctionType::get(RetTy, ParamTypes, isVarArg);
+      PFTy = PointerType::get(FTy);
+    }
+
+    // First upgrade any intrinsic calls.
+    std::vector Args;
+    if ($6)
+      for (unsigned i = 0, e = $6->size(); i < e; ++i) 
+        Args.push_back((*$6)[i].V);
+    Instruction *Inst = upgradeIntrinsicCall(FTy, $4, Args);
+
+    // If we got an upgraded intrinsic
+    if (Inst) {
+      $$.I = Inst;
+      $$.S = Signless;
     } else {
-      static unsigned upgradeCount = 1;
-      if (*$4->val == "%llvm.va_start" || *$4->val == "%llvm.va_end") {
-        if (!$6->empty()) {
-          std::string name("%va_upgrade");
-          name += llvm::utostr(upgradeCount++);
-          $1->insert(0, name + " = bitcast " + *(*$6)[0]->val + " to i8*\n    ");
-          *(*$6)[0]->val = "i8* " + name;
-          (*$6)[0]->type = Type::get("i8", UByteTy)->getPointerType();
-        }
-      } else if (*$4->val == "%llvm.va_copy") {
-        std::string name0("%va_upgrade");
-        name0 += llvm::utostr(upgradeCount++);
-        std::string name1("%va_upgrade");
-        name1 += llvm::utostr(upgradeCount++);
-        $1->insert(0, name0 + " = bitcast " + *(*$6)[0]->val + " to i8*\n    " +
-                      name1 + " = bitcast " + *(*$6)[1]->val + " to i8*\n    ");
-        *(*$6)[0]->val = "i8* " + name0;
-        (*$6)[0]->type = Type::get("i8", UByteTy)->getPointerType();
-        *(*$6)[1]->val = "i8* " + name1;
-        (*$6)[0]->type = Type::get("i8", UByteTy)->getPointerType();
-      }
-      if (!$2->empty())
-        *$1 += " " + *$2;
-      if (!$1->empty())
-        *$1 += " ";
-      *$1 += $3->getNewTy() + " " + *$4->val + "(";
-      for (unsigned i = 0; i < $6->size(); ++i) {
-        Value* V = (*$6)[i];
-        *$1 += *V->val;
-        if (i+1 < $6->size())
-          *$1 += ", ";
-        delete V;
+      // Get the function we're calling
+      Value *V = getVal(PFTy, $4);
+
+      // Check the argument values match
+      if (!$6) {                                   // Has no arguments?
+        // Make sure no arguments is a good thing!
+        if (FTy->getNumParams() != 0)
+          error("No arguments passed to a function that expects arguments");
+      } else {                                     // Has arguments?
+        // Loop through FunctionType's arguments and ensure they are specified
+        // correctly!
+        //
+        FunctionType::param_iterator I = FTy->param_begin();
+        FunctionType::param_iterator E = FTy->param_end();
+        std::vector::iterator ArgI = $6->begin(), ArgE = $6->end();
+
+        for (; ArgI != ArgE && I != E; ++ArgI, ++I)
+          if ((*ArgI).V->getType() != *I)
+            error("Parameter " +(*ArgI).V->getName()+ " is not of type '" +
+                  (*I)->getDescription() + "'");
+
+        if (I != E || (ArgI != ArgE && !FTy->isVarArg()))
+          error("Invalid number of parameters detected");
       }
-      *$1 += ")";
-      $$ = new Value;
-      $$->val = $1;
-      $$->type = getFunctionReturnType($3);
+
+      // Create the call instruction
+      CallInst *CI = new CallInst(V, Args);
+      CI->setTailCall($1);
+      CI->setCallingConv($2);
+      $$.I = CI;
+      $$.S = $3.S;
     }
-    delete $2; delete $4; delete $6;
+    delete $3.T;
+    delete $6;
+  }
+  | MemoryInst {
+    $$ = $1;
   }
-  | MemoryInst ;
+  ;
 
 
 // IndexList - List of indices for GEP based instructions...
 IndexList 
-  : ',' ValueRefList { $$ = $2; }
-  | /* empty */ {  $$ = new ValueList(); }
+  : ',' ValueRefList { $$ = $2; } 
+  | /* empty */ { $$ = new std::vector(); }
   ;
 
 OptVolatile 
-  : VOLATILE 
-  | /* empty */ { $$ = new std::string(); }
+  : VOLATILE { $$ = true; }
+  | /* empty */ { $$ = false; }
   ;
 
-MemoryInst : MALLOC Types OptCAlign {
-    *$1 += " " + $2->getNewTy();
-    if (!$3->empty())
-      *$1 += " " + *$3;
-    $$ = new Value;
-    $$->val = $1;
-    $$->type = $2->getPointerType();
-    delete $3;
+MemoryInst 
+  : MALLOC Types OptCAlign {
+    const Type *Ty = $2.T->get();
+    $$.S = $2.S;
+    $$.I = new MallocInst(Ty, 0, $3);
+    delete $2.T;
   }
   | MALLOC Types ',' UINT ValueRef OptCAlign {
-    std::string Name = getUniqueName($5->val, $4);
-    *$1 += " " + $2->getNewTy() + ", " + $4->getNewTy() + " " + Name;
-    if (!$6->empty())
-      *$1 += " " + *$6;
-    $$ = new Value;
-    $$->val = $1;
-    $$->type = $2->getPointerType();
-    delete $5; delete $6;
+    const Type *Ty = $2.T->get();
+    $$.S = $2.S;
+    $$.I = new MallocInst(Ty, getVal($4.T, $5), $6);
+    delete $2.T;
   }
   | ALLOCA Types OptCAlign {
-    *$1 += " " + $2->getNewTy();
-    if (!$3->empty())
-      *$1 += " " + *$3;
-    $$ = new Value;
-    $$->val = $1;
-    $$->type = $2->getPointerType();
-    delete $3;
+    const Type *Ty = $2.T->get();
+    $$.S = $2.S;
+    $$.I = new AllocaInst(Ty, 0, $3);
+    delete $2.T;
   }
   | ALLOCA Types ',' UINT ValueRef OptCAlign {
-    std::string Name = getUniqueName($5->val, $4);
-    *$1 += " " + $2->getNewTy() + ", " + $4->getNewTy() + " " + Name;
-    if (!$6->empty())
-      *$1 += " " + *$6;
-    $$ = $5;
-    delete $$->val;
-    $$->val = $1;
-    $$->type = $2->getPointerType();
-    delete $6;
+    const Type *Ty = $2.T->get();
+    $$.S = $2.S;
+    $$.I = new AllocaInst(Ty, getVal($4.T, $5), $6);
+    delete $2.T;
   }
   | FREE ResolvedVal {
-    *$1 += " " + *$2->val;
-    $$ = $2;
-    delete $2->val;
-    $$->val = $1;
-    $$->type = Type::get("void", VoidTy); 
+    const Type *PTy = $2.V->getType();
+    if (!isa(PTy))
+      error("Trying to free nonpointer type '" + PTy->getDescription() + "'");
+    $$.I = new FreeInst($2.V);
+    $$.S = Signless;
   }
   | OptVolatile LOAD Types ValueRef {
-    std::string Name = getUniqueName($4->val, $3);
-    if (!$1->empty())
-      *$1 += " ";
-    *$1 += *$2 + " " + $3->getNewTy() + " " + Name;
-    $$ = $4;
-    delete $$->val;
-    $$->val = $1;
-    $$->type = $3->getElementType();
-    delete $2;
+    const Type* Ty = $3.T->get();
+    $$.S = $3.S;
+    if (!isa(Ty))
+      error("Can't load from nonpointer type: " + Ty->getDescription());
+    if (!cast(Ty)->getElementType()->isFirstClassType())
+      error("Can't load from pointer of non-first-class type: " +
+                     Ty->getDescription());
+    Value* tmpVal = getVal(Ty, $4);
+    $$.I = new LoadInst(tmpVal, "", $1);
+    delete $3.T;
   }
   | OptVolatile STORE ResolvedVal ',' Types ValueRef {
-    std::string Name = getUniqueName($6->val, $5);
-    if (!$1->empty())
-      *$1 += " ";
-    *$1 += *$2 + " " + *$3->val + ", " + $5->getNewTy() + " " + Name;
-    $$ = $3;
-    delete $$->val;
-    $$->val = $1;
-    $$->type = Type::get("void", VoidTy);
-    delete $2; delete $6;
+    const PointerType *PTy = dyn_cast($5.T->get());
+    if (!PTy)
+      error("Can't store to a nonpointer type: " + 
+             $5.T->get()->getDescription());
+    const Type *ElTy = PTy->getElementType();
+    if (ElTy != $3.V->getType())
+      error("Can't store '" + $3.V->getType()->getDescription() +
+            "' into space of type '" + ElTy->getDescription() + "'");
+    Value* tmpVal = getVal(PTy, $6);
+    $$.I = new StoreInst($3.V, tmpVal, $1);
+    $$.S = Signless;
+    delete $5.T;
   }
   | GETELEMENTPTR Types ValueRef IndexList {
-    std::string Name = getUniqueName($3->val, $2);
-    // Upgrade the indices
-    for (unsigned i = 0; i < $4->size(); ++i) {
-      Value* V = (*$4)[i];
-      if (V->type->isUnsigned() && !V->isConstant() && 
-          V->type->getBitWidth() < 64) {
-        *O << "    %gep_upgrade" << UniqueNameCounter << " = zext " << *V->val 
-           << " to i64\n";
-        *V->val = "i64 %gep_upgrade" + llvm::utostr(UniqueNameCounter++);
-        V->type = Type::get("i64",ULongTy);
-      }
-    }
-    *$1 += " " + $2->getNewTy() + " " + Name;
-    for (unsigned i = 0; i < $4->size(); ++i) {
-      Value* V = (*$4)[i];
-      *$1 += ", " + *V->val;
-    }
-    $$ = $3;
-    delete $$->val;
-    $$->val = $1;
-    $$->type = getGEPIndexedType($2,$4); 
-    for (unsigned i = 0; i < $4->size(); ++i)
-      delete (*$4)[i];
+    const Type* Ty = $2.T->get();
+    if (!isa(Ty))
+      error("getelementptr insn requires pointer operand");
+
+    std::vector VIndices;
+    upgradeGEPIndices(Ty, $4, VIndices);
+
+    Value* tmpVal = getVal(Ty, $3);
+    $$.I = new GetElementPtrInst(tmpVal, VIndices);
+    $$.S = Signless;
+    delete $2.T;
     delete $4;
   };
 
+
 %%
 
 int yyerror(const char *ErrorMsg) {
   std::string where 
     = std::string((CurFilename == "-") ? std::string("") : CurFilename)
-                  + ":" + llvm::utostr((unsigned) Upgradelineno) + ": ";
-  std::string errMsg = where + "error: " + std::string(ErrorMsg) + 
-                       " while reading ";
-  if (yychar == YYEMPTY || yychar == 0)
-    errMsg += "end-of-file.";
-  else
-    errMsg += "token: '" + std::string(Upgradetext, Upgradeleng) + "'";
+                  + ":" + llvm::utostr((unsigned) Upgradelineno-1) + ": ";
+  std::string errMsg = where + "error: " + std::string(ErrorMsg);
+  if (yychar != YYEMPTY && yychar != 0)
+    errMsg += " while reading token '" + std::string(Upgradetext, Upgradeleng) +
+              "'.";
   std::cerr << "llvm-upgrade: " << errMsg << '\n';
-  *O << "llvm-upgrade parse failed.\n";
+  std::cout << "llvm-upgrade: parse failed.\n";
   exit(1);
 }
 
 void warning(const std::string& ErrorMsg) {
   std::string where 
     = std::string((CurFilename == "-") ? std::string("") : CurFilename)
-                  + ":" + llvm::utostr((unsigned) Upgradelineno) + ": ";
-  std::string errMsg = where + "warning: " + std::string(ErrorMsg) + 
-                       " while reading ";
-  if (yychar == YYEMPTY || yychar == 0)
-    errMsg += "end-of-file.";
-  else
-    errMsg += "token: '" + std::string(Upgradetext, Upgradeleng) + "'";
+                  + ":" + llvm::utostr((unsigned) Upgradelineno-1) + ": ";
+  std::string errMsg = where + "warning: " + std::string(ErrorMsg);
+  if (yychar != YYEMPTY && yychar != 0)
+    errMsg += " while reading token '" + std::string(Upgradetext, Upgradeleng) +
+              "'.";
   std::cerr << "llvm-upgrade: " << errMsg << '\n';
 }
+
+void error(const std::string& ErrorMsg, int LineNo) {
+  if (LineNo == -1) LineNo = Upgradelineno;
+  Upgradelineno = LineNo;
+  yyerror(ErrorMsg.c_str());
+}
+


Index: llvm/tools/llvm-upgrade/UpgradeInternals.h
diff -u llvm/tools/llvm-upgrade/UpgradeInternals.h:1.4 llvm/tools/llvm-upgrade/UpgradeInternals.h:1.5
--- llvm/tools/llvm-upgrade/UpgradeInternals.h:1.4	Sun Jan 14 20:40:33 2007
+++ llvm/tools/llvm-upgrade/UpgradeInternals.h	Fri Jan 26 02:18:34 2007
@@ -1,65 +1,279 @@
-//===-- UpgradeInternals.h - Internal parser definitionsr -------*- C++ -*-===//
+//===-- ParserInternals.h - Definitions internal to the parser --*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file was developed by Reid Spencer and is distributed under
+// This file was developed by the LLVM research group and is distributed under
 // the University of Illinois Open Source License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
-//  This header file defines the variables that are shared between the lexer,
-//  the parser, and the main program.
+//  This header file defines the various variables that are shared among the
+//  different components of the parser...
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef UPGRADE_INTERNALS_H
-#define UPGRADE_INTERNALS_H
+#ifndef PARSER_INTERNALS_H
+#define PARSER_INTERNALS_H
+
+#include "llvm/Constants.h"
+#include "llvm/DerivedTypes.h"
+#include "llvm/Function.h"
+#include "llvm/Instructions.h"
+#include "llvm/ADT/StringExtras.h"
+#include 
 
-#include 
-#include 
-#include 
-#include 
-#include 
-#include 
 
 // Global variables exported from the lexer.
-extern std::string CurFileName;
-extern std::string Textin;
+extern int yydebug;
+extern void error(const std::string& msg, int line = -1);
+extern char* Upgradetext;
+extern int   Upgradeleng;
 extern int Upgradelineno;
+
+namespace llvm {
+
+
+class Module;
+Module* UpgradeAssembly(const std::string &infile, std::istream& in, 
+                        bool debug, bool addAttrs);
+
+
+class SignedType : public IntegerType {
+  const IntegerType *base_type;
+  static SignedType *SByteTy;
+  static SignedType *SShortTy;
+  static SignedType *SIntTy;
+  static SignedType *SLongTy;
+  SignedType(const IntegerType* ITy);
+public:
+  static const SignedType *get(const IntegerType* ITy);
+
+  bool isSigned() const { return true; }
+  const IntegerType* getBaseType() const {
+    return base_type;
+  }
+  const IntegerType*  resolve() const {
+    ForwardType = base_type;
+    return base_type;
+  }
+
+  // Methods for support type inquiry through isa, cast, and dyn_cast:
+  static inline bool classof(const SignedType *T) { return true; }
+  static inline bool classof(const Type *T); 
+};
+
 extern std::istream* LexInput;
 
-// Global variables exported from the parser.
-extern char* Upgradetext;
-extern int   Upgradeleng;
-extern unsigned SizeOfPointer;
+// UnEscapeLexed - Run through the specified buffer and change \xx codes to the
+// appropriate character.  If AllowNull is set to false, a \00 value will cause
+// an error.
+//
+// If AllowNull is set to true, the return value of the function points to the
+// last character of the string in memory.
+//
+char *UnEscapeLexed(char *Buffer, bool AllowNull = false);
+
+/// InlineAsmDescriptor - This is a simple class that holds info about inline
+/// asm blocks, for use by ValID.
+struct InlineAsmDescriptor {
+  std::string AsmString, Constraints;
+  bool HasSideEffects;
+  
+  InlineAsmDescriptor(const std::string &as, const std::string &c, bool HSE)
+    : AsmString(as), Constraints(c), HasSideEffects(HSE) {}
+};
+
+
+// ValID - Represents a reference of a definition of some sort.  This may either
+// be a numeric reference or a symbolic (%var) reference.  This is just a
+// discriminated union.
+//
+// Note that I can't implement this class in a straight forward manner with
+// constructors and stuff because it goes in a union.
+//
+struct ValID {
+  enum {
+    NumberVal, NameVal, ConstSIntVal, ConstUIntVal, ConstFPVal, ConstNullVal,
+    ConstUndefVal, ConstZeroVal, ConstantVal, InlineAsmVal
+  } Type;
+
+  union {
+    int      Num;         // If it's a numeric reference
+    char    *Name;        // If it's a named reference.  Memory must be free'd.
+    int64_t  ConstPool64; // Constant pool reference.  This is the value
+    uint64_t UConstPool64;// Unsigned constant pool reference.
+    double   ConstPoolFP; // Floating point constant pool reference
+    Constant *ConstantValue; // Fully resolved constant for ConstantVal case.
+    InlineAsmDescriptor *IAD;
+  };
+
+  static ValID create(int Num) {
+    ValID D; D.Type = NumberVal; D.Num = Num; return D;
+  }
+
+  static ValID create(char *Name) {
+    ValID D; D.Type = NameVal; D.Name = Name; return D;
+  }
+
+  static ValID create(int64_t Val) {
+    ValID D; D.Type = ConstSIntVal; D.ConstPool64 = Val; return D;
+  }
+
+  static ValID create(uint64_t Val) {
+    ValID D; D.Type = ConstUIntVal; D.UConstPool64 = Val; return D;
+  }
+
+  static ValID create(double Val) {
+    ValID D; D.Type = ConstFPVal; D.ConstPoolFP = Val; return D;
+  }
+
+  static ValID createNull() {
+    ValID D; D.Type = ConstNullVal; return D;
+  }
+
+  static ValID createUndef() {
+    ValID D; D.Type = ConstUndefVal; return D;
+  }
 
-// Functions exported by the parser
-void UpgradeAssembly(
-  const std::string & infile, std::istream& in, std::ostream &out, bool debug,
-  bool addAttrs);
-int yyerror(const char *ErrorMsg) ;
-
-/// This enum is used to keep track of the original (1.9) type used to form
-/// a type. These are needed for type upgrades and to determine how to upgrade
-/// signed instructions with signless operands. The Lexer uses thse in its
-/// calls to getType
-enum TypeIDs {
-  BoolTy, SByteTy, UByteTy, ShortTy, UShortTy, IntTy, UIntTy, LongTy, ULongTy,
-  FloatTy, DoubleTy, PointerTy, PackedTy, ArrayTy, StructTy, PackedStructTy, 
-  OpaqueTy, VoidTy, LabelTy, FunctionTy, UnresolvedTy, UpRefTy
-};
-
-namespace {
-class Type;
-class Value;
-class Constant;
-class Instruction;
-}
+  static ValID createZeroInit() {
+    ValID D; D.Type = ConstZeroVal; return D;
+  }
+  
+  static ValID create(Constant *Val) {
+    ValID D; D.Type = ConstantVal; D.ConstantValue = Val; return D;
+  }
+  
+  static ValID createInlineAsm(const std::string &AsmString,
+                               const std::string &Constraints,
+                               bool HasSideEffects) {
+    ValID D;
+    D.Type = InlineAsmVal;
+    D.IAD = new InlineAsmDescriptor(AsmString, Constraints, HasSideEffects);
+    return D;
+  }
 
-typedef std::vector TypeList;
-typedef std::vector ValueList;
+  inline void destroy() const {
+    if (Type == NameVal)
+      free(Name);    // Free this strdup'd memory.
+    else if (Type == InlineAsmVal)
+      delete IAD;
+  }
+
+  inline ValID copy() const {
+    if (Type != NameVal) return *this;
+    ValID Result = *this;
+    Result.Name = strdup(Name);
+    return Result;
+  }
+
+  inline std::string getName() const {
+    switch (Type) {
+    case NumberVal     : return std::string("#") + itostr(Num);
+    case NameVal       : return Name;
+    case ConstFPVal    : return ftostr(ConstPoolFP);
+    case ConstNullVal  : return "null";
+    case ConstUndefVal : return "undef";
+    case ConstZeroVal  : return "zeroinitializer";
+    case ConstUIntVal  :
+    case ConstSIntVal  : return std::string("%") + itostr(ConstPool64);
+    case ConstantVal:
+      if (ConstantValue == ConstantInt::get(Type::Int1Ty, true)) 
+        return "true";
+      if (ConstantValue == ConstantInt::get(Type::Int1Ty, false))
+        return "false";
+      return "";
+    default:
+      assert(0 && "Unknown value!");
+      abort();
+      return "";
+    }
+  }
+
+  bool operator<(const ValID &V) const {
+    if (Type != V.Type) return Type < V.Type;
+    switch (Type) {
+    case NumberVal:     return Num < V.Num;
+    case NameVal:       return strcmp(Name, V.Name) < 0;
+    case ConstSIntVal:  return ConstPool64  < V.ConstPool64;
+    case ConstUIntVal:  return UConstPool64 < V.UConstPool64;
+    case ConstFPVal:    return ConstPoolFP  < V.ConstPoolFP;
+    case ConstNullVal:  return false;
+    case ConstUndefVal: return false;
+    case ConstZeroVal: return false;
+    case ConstantVal:   return ConstantValue < V.ConstantValue;
+    default:  assert(0 && "Unknown value type!"); return false;
+    }
+  }
+};
+
+
+// This structure is used to keep track of obsolete opcodes. The lexer will
+// retain the ability to parse obsolete opcode mnemonics. In this case it will
+// set "obsolete" to true and the opcode will be the replacement opcode. For
+// example if "rem" is encountered then opcode will be set to "urem" and the
+// "obsolete" flag will be true. If the opcode is not obsolete then "obsolete"
+// will be false. 
+
+enum TermOps {
+  RetOp, BrOp, SwitchOp, InvokeOp, UnwindOp, UnreachableOp
+};
+
+enum BinaryOps {
+  AddOp, SubOp, MulOp,
+  DivOp, UDivOp, SDivOp, FDivOp, 
+  RemOp, URemOp, SRemOp, FRemOp, 
+  AndOp, OrOp, XorOp,
+  SetEQ, SetNE, SetLE, SetGE, SetLT, SetGT
+};
+
+enum MemoryOps {
+  MallocOp, FreeOp, AllocaOp, LoadOp, StoreOp, GetElementPtrOp
+};
+
+enum OtherOps {
+  PHIOp, CallOp, ShlOp, ShrOp, SelectOp, UserOp1, UserOp2, VAArg,
+  ExtractElementOp, InsertElementOp, ShuffleVectorOp,
+  ICmpOp, FCmpOp,
+  LShrOp, AShrOp
+};
+
+enum CastOps {
+  CastOp, TruncOp, ZExtOp, SExtOp, FPTruncOp, FPExtOp, FPToUIOp, FPToSIOp,
+  UIToFPOp, SIToFPOp, PtrToIntOp, IntToPtrOp, BitCastOp
+};
+
+enum Signedness { Signless, Unsigned, Signed };
+
+struct TypeInfo {
+  const llvm::Type *T;
+  Signedness S;
+};
+
+struct PATypeInfo {
+  llvm::PATypeHolder* T;
+  Signedness S;
+};
+
+struct ConstInfo {
+  llvm::Constant* C;
+  Signedness S;
+};
+
+struct ValueInfo {
+  llvm::Value* V;
+  Signedness S;
+};
+
+struct InstrInfo {
+  llvm::Instruction *I;
+  Signedness S;
+};
+
+struct PHIListInfo {
+  std::list > *P;
+  Signedness S;
+};
 
-/// A function to create a Typeo* used in the Lexer.
-extern const Type* getType(const std::string& newTy, TypeIDs oldTy);
+} // End llvm namespace
 
 #endif





From reid at x10sys.com  Fri Jan 26 02:19:26 2007
From: reid at x10sys.com (Reid Spencer)
Date: Fri, 26 Jan 2007 02:19:26 -0600
Subject: [llvm-commits] CVS: llvm/tools/llvm-upgrade/Makefile
	UpgradeLexer.cpp.cvs UpgradeLexer.l.cvs UpgradeParser.cpp.cvs
	UpgradeParser.h.cvs UpgradeParser.y.cvs llvm-upgrade.cpp
Message-ID: <200701260819.l0Q8JQTk031443@zion.cs.uiuc.edu>



Changes in directory llvm/tools/llvm-upgrade:

Makefile updated: 1.5 -> 1.6
UpgradeLexer.cpp.cvs updated: 1.16 -> 1.17
UpgradeLexer.l.cvs updated: 1.16 -> 1.17
UpgradeParser.cpp.cvs updated: 1.44 -> 1.45
UpgradeParser.h.cvs updated: 1.31 -> 1.32
UpgradeParser.y.cvs updated: 1.43 -> 1.44
llvm-upgrade.cpp updated: 1.7 -> 1.8
---
Log message:

Regenerate.


---
Diffs of the changes:  (+9268 -6194)

 Makefile              |    2 
 UpgradeLexer.cpp.cvs  | 1838 ++++++-----
 UpgradeLexer.l.cvs    |  479 +--
 UpgradeParser.cpp.cvs | 7944 +++++++++++++++++++++++++++++---------------------
 UpgradeParser.h.cvs   |  498 +--
 UpgradeParser.y.cvs   | 4678 ++++++++++++++++++-----------
 llvm-upgrade.cpp      |   23 
 7 files changed, 9268 insertions(+), 6194 deletions(-)


Index: llvm/tools/llvm-upgrade/Makefile
diff -u llvm/tools/llvm-upgrade/Makefile:1.5 llvm/tools/llvm-upgrade/Makefile:1.6
--- llvm/tools/llvm-upgrade/Makefile:1.5	Fri Jan  5 16:03:42 2007
+++ llvm/tools/llvm-upgrade/Makefile	Fri Jan 26 02:19:09 2007
@@ -9,7 +9,7 @@
 
 LEVEL = ../..
 TOOLNAME = llvm-upgrade
-LINK_COMPONENTS := support system
+LINK_COMPONENTS := BCWriter Core support system
 REQUIRES_EH := 1
 
 include $(LEVEL)/Makefile.common


Index: llvm/tools/llvm-upgrade/UpgradeLexer.cpp.cvs
diff -u llvm/tools/llvm-upgrade/UpgradeLexer.cpp.cvs:1.16 llvm/tools/llvm-upgrade/UpgradeLexer.cpp.cvs:1.17
--- llvm/tools/llvm-upgrade/UpgradeLexer.cpp.cvs:1.16	Sun Jan 14 20:41:46 2007
+++ llvm/tools/llvm-upgrade/UpgradeLexer.cpp.cvs	Fri Jan 26 02:19:09 2007
@@ -20,7 +20,7 @@
 /* A lexical scanner generated by flex*/
 
 /* Scanner skeleton version:
- * $Header: /var/cvs/llvm/llvm/tools/llvm-upgrade/UpgradeLexer.cpp.cvs,v 1.16 2007/01/15 02:41:46 reid Exp $
+ * $Header: /var/cvs/llvm/llvm/tools/llvm-upgrade/UpgradeLexer.cpp.cvs,v 1.17 2007/01/26 08:19:09 reid Exp $
  */
 
 #define FLEX_SCANNER
@@ -317,39 +317,39 @@
 	*yy_cp = '\0'; \
 	yy_c_buf_p = yy_cp;
 
-#define YY_NUM_RULES 157
-#define YY_END_OF_BUFFER 158
-static yyconst short int yy_acclist[235] =
+#define YY_NUM_RULES 156
+#define YY_END_OF_BUFFER 157
+static yyconst short int yy_acclist[234] =
     {   0,
-      158,  156,  157,  155,  156,  157,  155,  157,  156,  157,
-      156,  157,  156,  157,  156,  157,  156,  157,  156,  157,
-      148,  156,  157,  148,  156,  157,    1,  156,  157,  156,
-      157,  156,  157,  156,  157,  156,  157,  156,  157,  156,
-      157,  156,  157,  156,  157,  156,  157,  156,  157,  156,
-      157,  156,  157,  156,  157,  156,  157,  156,  157,  156,
-      157,  156,  157,  156,  157,  156,  157,  156,  157,  156,
-      157,  147,  145,  144,  144,  151,  149,  153,  148,    1,
-      129,   39,   87,   56,   88,   77,   23,  147,  144,  144,
-      152,  153,   20,  153,  154,   65,   76,   37,   32,   40,
-
-       68,    3,   57,   58,   59,   52,   67,   93,   98,   96,
-       97,   95,   94,   99,  107,   72,  128,   92,   90,  123,
-      124,   91,   89,   66,  101,  106,  104,  105,  103,  102,
-      100,   78,  146,  153,  153,  125,   47,  108,  109,   86,
-       71,  137,   75,   85,  138,   54,  126,   22,  150,   70,
-      112,   74,   24,    4,   64,   69,   53,   73,   46,   11,
-      111,  153,   34,    2,    5,   60,  114,   62,   48,   80,
-       84,   82,   83,   81,   79,   50,  139,  110,   49,   55,
-       21,  136,   43,   61,   28,  133,   42,  116,  115,    7,
-      131,   31,  135,   36,   63,  122,  118,  130,   25,   26,
-
-      117,  132,   51,  127,  121,   41,    6,   27,  113,   35,
-        8,   16,    9,  120,   10,  119,   33,   12,   14,   13,
-       30,   38,   15,   29,  134,  140,  142,  143,   17,   44,
-      141,   18,   45,   19
+      157,  155,  156,  154,  155,  156,  154,  156,  155,  156,
+      155,  156,  155,  156,  155,  156,  155,  156,  155,  156,
+      147,  155,  156,  147,  155,  156,    1,  155,  156,  155,
+      156,  155,  156,  155,  156,  155,  156,  155,  156,  155,
+      156,  155,  156,  155,  156,  155,  156,  155,  156,  155,
+      156,  155,  156,  155,  156,  155,  156,  155,  156,  155,
+      156,  155,  156,  155,  156,  155,  156,  155,  156,  155,
+      156,  146,  144,  143,  143,  150,  148,  152,  147,    1,
+      129,   41,   85,   86,   75,   23,  146,  143,  143,  151,
+      152,   20,  152,  153,   63,   74,   39,   34,   42,   66,
+
+        3,   52,   65,   25,   95,  100,   98,   99,   97,   96,
+      101,  105,   70,  128,   90,   88,  121,  122,   89,   87,
+       64,  103,   94,   92,   93,   91,  104,  102,   76,  145,
+      152,  152,  124,   57,  106,  107,   84,   69,  136,   73,
+       83,  137,   54,  123,   22,  149,   68,  110,   72,   26,
+        4,   61,   67,   53,   71,   56,   11,  109,  152,   36,
+        2,    5,   58,  112,   60,   48,   78,   82,   80,   81,
+       79,   77,   50,  138,  108,   49,   55,   21,  126,  135,
+       45,   59,   30,   24,   44,  114,  113,    7,  131,   33,
+      134,   38,   62,  120,  116,  130,   27,   28,  115,  132,
+
+       51,  127,  125,  119,   43,    6,   29,  111,   37,    8,
+       17,    9,  118,   10,  117,   35,   12,   14,   13,   32,
+       40,   15,   31,  133,  139,  141,  142,   16,   46,  140,
+       18,   47,   19
     } ;
 
-static yyconst short int yy_accept[609] =
+static yyconst short int yy_accept[611] =
     {   0,
         1,    1,    1,    2,    4,    7,    9,   11,   13,   15,
        17,   19,   21,   24,   27,   30,   32,   34,   36,   38,
@@ -359,65 +359,65 @@
        81,   81,   81,   81,   81,   81,   81,   81,   81,   82,
        82,   83,   83,   83,   83,   83,   83,   83,   83,   83,
        84,   84,   84,   84,   84,   84,   84,   84,   84,   84,
-       84,   84,   84,   85,   85,   85,   85,   85,   85,   85,
-       85,   85,   85,   85,   86,   86,   86,   86,   86,   86,
+       84,   84,   84,   84,   84,   84,   84,   84,   84,   84,
+       85,   85,   85,   85,   85,   85,   85,   85,   86,   86,
 
-       86,   87,   87,   87,   87,   87,   87,   87,   87,   87,
-       87,   87,   87,   87,   87,   87,   87,   87,   87,   88,
-       88,   88,   88,   88,   88,   88,   88,   88,   88,   88,
-       88,   88,   88,   88,   88,   88,   88,   89,   90,   92,
-       93,   94,   95,   95,   96,   97,   97,   97,   98,   98,
-       98,   99,   99,  100,  100,  100,  100,  100,  101,  101,
-      101,  101,  101,  101,  101,  102,  102,  102,  103,  103,
-      103,  103,  103,  103,  103,  103,  103,  103,  103,  103,
-      103,  104,  105,  106,  106,  106,  106,  107,  107,  107,
-      107,  107,  107,  107,  107,  107,  107,  108,  108,  109,
-
-      110,  111,  112,  113,  114,  114,  115,  116,  116,  116,
-      117,  118,  118,  118,  118,  118,  118,  118,  118,  119,
-      120,  121,  121,  122,  122,  122,  122,  123,  124,  124,
-      124,  125,  125,  125,  125,  125,  125,  125,  125,  125,
-      126,  127,  128,  128,  128,  129,  129,  130,  130,  131,
-      131,  132,  132,  132,  132,  132,  132,  132,  132,  132,
-      132,  133,  133,  133,  134,  135,  135,  135,  135,  136,
-      136,  136,  136,  137,  137,  137,  138,  139,  140,  140,
-      140,  140,  140,  140,  140,  140,  140,  140,  140,  140,
-      140,  140,  140,  140,  141,  142,  142,  142,  142,  142,
-
-      143,  144,  144,  144,  145,  145,  145,  145,  145,  145,
-      145,  145,  145,  146,  147,  148,  148,  148,  149,  149,
-      149,  149,  150,  150,  151,  151,  151,  151,  151,  151,
-      151,  152,  152,  152,  152,  152,  153,  153,  153,  154,
-      154,  154,  155,  155,  156,  156,  157,  158,  158,  158,
-      158,  158,  158,  158,  159,  159,  159,  160,  160,  161,
-      161,  161,  162,  163,  164,  164,  164,  165,  165,  165,
-      165,  165,  165,  165,  165,  165,  165,  165,  165,  165,
-      165,  165,  166,  166,  167,  168,  168,  168,  168,  168,
-      168,  168,  168,  168,  168,  168,  169,  169,  169,  169,
-
-      169,  169,  169,  169,  170,  170,  170,  171,  172,  173,
-      174,  175,  176,  177,  177,  177,  177,  178,  178,  178,
-      178,  179,  180,  180,  181,  182,  182,  182,  182,  182,
-      182,  182,  182,  182,  182,  183,  183,  183,  184,  184,
-      184,  184,  184,  184,  184,  184,  185,  186,  187,  187,
-      187,  188,  189,  190,  190,  190,  191,  191,  191,  191,
-      191,  192,  192,  193,  194,  195,  196,  196,  196,  196,
-      197,  197,  197,  198,  199,  200,  201,  202,  202,  202,
-      203,  204,  205,  205,  205,  205,  205,  205,  206,  206,
-      207,  207,  208,  209,  209,  209,  209,  209,  209,  210,
-
-      210,  210,  210,  210,  210,  210,  210,  210,  211,  211,
-      211,  211,  211,  211,  211,  211,  211,  211,  212,  212,
-      212,  212,  212,  213,  213,  213,  213,  213,  214,  215,
-      216,  216,  217,  217,  217,  217,  217,  218,  218,  218,
-      218,  219,  219,  220,  221,  221,  221,  221,  221,  221,
+       86,   86,   86,   86,   86,   86,   86,   86,   86,   86,
+       86,   86,   86,   86,   86,   86,   87,   87,   87,   87,
+       87,   87,   87,   87,   87,   87,   87,   87,   87,   87,
+       87,   87,   87,   87,   88,   89,   91,   92,   93,   94,
+       94,   95,   96,   96,   96,   97,   97,   97,   98,   98,
+       99,   99,   99,   99,   99,  100,  100,  100,  100,  100,
+      100,  100,  101,  101,  101,  102,  102,  102,  102,  102,
+      102,  102,  102,  102,  102,  102,  102,  102,  102,  102,
+      102,  103,  103,  103,  103,  103,  103,  103,  103,  103,
+      103,  104,  105,  105,  106,  107,  108,  109,  110,  111,
+
+      111,  112,  113,  113,  113,  114,  115,  115,  115,  115,
+      115,  115,  115,  115,  116,  117,  118,  118,  119,  119,
+      119,  119,  120,  121,  121,  121,  122,  122,  122,  122,
+      122,  122,  122,  122,  122,  123,  124,  125,  125,  125,
+      126,  126,  127,  127,  128,  128,  129,  129,  129,  129,
+      129,  129,  129,  129,  129,  129,  129,  129,  130,  130,
+      130,  131,  132,  132,  132,  132,  133,  133,  133,  133,
+      134,  134,  134,  135,  136,  137,  137,  137,  137,  137,
+      137,  137,  137,  137,  137,  137,  137,  137,  137,  137,
+      137,  138,  139,  139,  139,  139,  139,  140,  141,  141,
+
+      141,  142,  142,  142,  142,  142,  142,  142,  142,  142,
+      143,  144,  145,  145,  145,  146,  146,  146,  146,  147,
+      147,  148,  148,  148,  148,  148,  148,  148,  149,  149,
+      149,  149,  149,  150,  150,  150,  151,  151,  151,  152,
+      152,  153,  153,  154,  155,  155,  155,  155,  155,  155,
+      155,  156,  156,  156,  156,  156,  157,  157,  158,  158,
+      158,  159,  160,  161,  161,  161,  162,  162,  162,  162,
+      162,  162,  162,  162,  162,  162,  162,  162,  162,  162,
+      162,  163,  163,  164,  165,  165,  165,  165,  165,  165,
+      165,  165,  165,  165,  165,  166,  166,  166,  166,  166,
+
+      166,  166,  166,  167,  167,  167,  168,  169,  170,  171,
+      172,  173,  174,  174,  174,  174,  175,  175,  175,  175,
+      176,  177,  177,  178,  179,  179,  179,  179,  179,  179,
+      180,  180,  180,  180,  180,  180,  181,  181,  181,  182,
+      182,  182,  182,  182,  182,  182,  182,  183,  184,  185,
+      185,  185,  186,  187,  188,  188,  188,  189,  189,  189,
+      189,  189,  190,  190,  191,  192,  193,  194,  194,  194,
+      194,  195,  195,  195,  196,  197,  198,  199,  200,  200,
+      200,  201,  202,  203,  204,  204,  204,  204,  204,  204,
+      205,  205,  206,  206,  207,  208,  208,  208,  208,  208,
+
+      208,  209,  209,  209,  209,  209,  209,  209,  209,  209,
+      210,  210,  210,  210,  210,  210,  210,  210,  210,  210,
+      211,  211,  211,  211,  211,  212,  212,  212,  212,  212,
+      213,  214,  215,  215,  216,  216,  216,  216,  216,  217,
+      217,  217,  217,  218,  218,  219,  220,  220,  220,  220,
+      220,  220,  220,  220,  220,  220,  220,  220,  220,  220,
       221,  221,  221,  221,  221,  221,  221,  221,  222,  222,
-      222,  222,  222,  222,  222,  222,  223,  223,  223,  223,
-      223,  223,  224,  224,  224,  224,  224,  225,  225,  225,
-      226,  226,  226,  226,  226,  226,  226,  226,  226,  226,
-      226,  226,  226,  226,  227,  227,  228,  229,  230,  230,
+      222,  222,  222,  222,  223,  223,  223,  223,  223,  224,
+      224,  224,  225,  225,  225,  225,  225,  225,  225,  225,
+      225,  225,  225,  225,  225,  225,  226,  226,  227,  228,
 
-      231,  231,  232,  233,  234,  234,  235,  235
+      229,  229,  230,  230,  231,  232,  233,  233,  234,  234
     } ;
 
 static yyconst int yy_ec[256] =
@@ -426,16 +426,16 @@
         1,    1,    2,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    2,    1,    4,    1,    5,    6,    1,    1,    1,
-        1,    1,    7,    1,    8,    9,    1,   10,   11,   12,
-       13,   14,   15,   16,   15,   17,   15,   18,   19,    1,
-        1,    1,    1,    1,   20,   20,   20,   20,   21,   20,
+        1,    1,    7,    1,    8,    9,    1,   10,   11,   11,
+       11,   11,   11,   12,   11,   13,   11,   14,   15,    1,
+        1,    1,    1,    1,   16,   16,   16,   16,   17,   16,
         5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
         5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
-        1,    1,    1,    1,   22,    1,   23,   24,   25,   26,
+        1,    1,    1,    1,   18,    1,   19,   20,   21,   22,
 
-       27,   28,   29,   30,   31,    5,   32,   33,   34,   35,
-       36,   37,   38,   39,   40,   41,   42,   43,   44,   45,
-       46,   47,    1,    1,    1,    1,    1,    1,    1,    1,
+       23,   24,   25,   26,   27,    5,   28,   29,   30,   31,
+       32,   33,   34,   35,   36,   37,   38,   39,   40,   41,
+       42,   43,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
@@ -452,291 +452,291 @@
         1,    1,    1,    1,    1
     } ;
 
-static yyconst int yy_meta[48] =
+static yyconst int yy_meta[44] =
     {   0,
-        1,    1,    2,    1,    3,    1,    4,    5,    3,    6,
-        6,    6,    6,    6,    6,    6,    6,    7,    1,    3,
-        8,    3,    3,    3,    3,    3,    8,    3,    3,    3,
+        1,    1,    2,    1,    3,    1,    1,    3,    3,    3,
+        3,    3,    3,    4,    1,    3,    3,    3,    3,    3,
+        3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
-        3,    3,    3,    3,    3,    3,    3
+        3,    3,    3
     } ;
 
-static yyconst short int yy_base[617] =
+static yyconst short int yy_base[615] =
     {   0,
-        0,    0, 1298, 1299, 1299, 1299, 1293, 1278,   40,    0,
-       48,   58,   68, 1250,    0,   68,   71,   81,   91,   52,
-      105,   93,  134,  117,  118,   73,  137,  143,   98,  175,
-      144,  210,  159,  116,   56,  119, 1290, 1299, 1275, 1299,
-        0,  241,    0, 1283, 1282,  140,  249, 1245,  267,    0,
-       70,  163,  145,   31,  157,  160,  168,   57, 1271,  170,
-       94,  180,  182,   54,  193,  189,  194,  114,  205, 1270,
-      271,  207,  204,  211,  208,  279,  206,  228,  249,   53,
-      121,  254, 1269,  268,  280,  281,  283,  290,  291,  285,
-      286,  287,  300, 1268,  305,  292,  309,  310,  314,  293,
-
-      316,  217,  317,  321,  311,  147,  322,  325,  328,  331,
-      341,  329,  344,  336,  339,  358,  347,  348, 1267,  363,
-      349,  346,  366,  370,  371,  372,  373,  384,  377,  388,
-      253,  398,  378,  401,  385,  403, 1266,    0,    0,  372,
-     1265,    0,  442,    0, 1264,  404,  407, 1263,  408,  412,
-     1262,  409, 1261,  414,  427,  428,  423, 1260,  418,  429,
-      444,  445,  447,  448, 1259,  452,  449,  454,  457,  459,
-      456,  458,  460,  464,  469,  255,  470,  476,  473,  471,
-     1258, 1257, 1256,  475,  472,  484,  486,  483,  490,  496,
-      497,  498,  500,  502,  503,  504, 1255,  507, 1254, 1253,
-
-     1252, 1251, 1250, 1249,  505, 1248, 1247,  512,  508, 1246,
-     1245,  540,  517,  516,  521,  515,  551,  530, 1244, 1243,
-     1242,  552, 1241,  554,  556,  557, 1240, 1239,  555,  558,
-     1238,  559,  561,  563,  567,  572,  569,  570,  577, 1237,
-     1236, 1235,  580,  583, 1234,  587, 1233,  585, 1232,  588,
-     1231,  590,  513,  584,  591,  514,  598,  592,  596,  416,
-     1230,  595,  607, 1299,  605,  622,  626,  628,  630,  621,
-      622,  623, 1229,  624,  626, 1228, 1227, 1226,  625,  627,
-      628,  633,  634,  636,  635,  637,  642,  647,  644,  643,
-      654,  646,  658, 1225, 1224,  645,  656,  660,  661, 1223,
-
-     1222,  666,  667, 1221,  669,  670,  671,  675,  673,  674,
-      676,  680, 1220, 1219, 1218,  683,  688, 1217,  686,  677,
-      690,    0,  696, 1216,  698,  697,  699,  706,  707,  709,
-     1215,  702,  712,  714,  717, 1214,  724,  713, 1213,  726,
-      721, 1212,  731, 1211,  728, 1210, 1209,  732,  734,  739,
-      740,  741,  743, 1208,  744,  747, 1207,  748, 1206,  751,
-      750, 1205,    0, 1204,  752,  754, 1203,  755,  759,  764,
-      767,  770,  758,  772,  776,  780,  781,  783,  782,  784,
-      785, 1202,  786, 1201, 1200,  789,  791,  794,  787,  788,
-      797,  798,  806,  807,  808, 1199,  810,  809,  812,  815,
-
-      816,  820,  822, 1198,  814,  828, 1197, 1196, 1195, 1194,
-     1193, 1192, 1191,  830,  831,  833, 1190,  834,  836,  838,
-     1189, 1188,  837, 1187, 1186,  839,  842,  840,  843,  844,
-      850,  853,  854,  857, 1185,  860,  861, 1184,  864,  865,
-      867,  869,  868,  870,  871, 1183, 1182, 1181,  875,  876,
-     1180, 1179, 1178,  885,  882, 1177,  887,  891,  897,  883,
-     1176,  886, 1175, 1174, 1173, 1172,  894,  901,  903, 1171,
-      904,  907, 1170, 1169, 1168, 1167, 1166,  908,  910, 1165,
-     1164, 1163,  909,  905,  911,  912,  914, 1162,  916, 1161,
-      923, 1160, 1159,  926,  928,  929,  930,  933, 1158,  934,
-
-      935,  936,  938,  937,  948,  932,  940, 1157,  944,  950,
-      956,  960,  962,  964,  966,  967,  968, 1156,  946,  972,
-      974,  975, 1155,  976,  977,  978,  980, 1150, 1147, 1144,
-      983, 1136,  993,  981,  985,  986, 1133,  998,  999, 1003,
-     1130, 1006, 1124, 1113, 1007, 1008, 1009, 1010, 1011, 1013,
-     1014, 1018, 1020, 1019, 1023, 1022, 1025, 1111, 1024, 1031,
-     1026, 1035, 1039, 1040, 1036, 1109, 1043, 1044, 1046, 1050,
-     1051, 1108, 1054, 1052, 1055, 1056, 1106, 1060, 1062, 1104,
-     1064, 1067, 1057, 1069, 1076, 1077, 1080, 1081, 1082, 1084,
-     1085, 1083, 1087, 1101, 1088, 1100, 1099, 1094, 1089,  982,
+        0,    0, 1308, 1309, 1309, 1309, 1303, 1292,   36,   40,
+       44,   50,   56,   62,    0,   63,   66,   81,   89,   47,
+      108,   91,  105,   96,  119,  117,  144,  128,   68,  170,
+      169,  202,   92,  111,  131,  125, 1301, 1309, 1290, 1309,
+        0,  207,  229,  234,  239,   70,  244,  259,  264,    0,
+      139,  145,  142,   76,  136,  156,  157,   31, 1289,  162,
+      164,  192,   48,  172,  268,  175,  173,  221,  212, 1288,
+      276,  278,  138,  186,   72,  279,  277,  280,  289,  249,
+      282,  290,  216,  281,  291,  189,  294,  284,  295, 1287,
+      297,  306,   73,  305,  316,  317,  246,  311,  318,  322,
+
+      323,  324,  327,  329,  330,  338,  332,  348,  350,  333,
+      337,  334,  362,  336,  364, 1286,  367,  351,  359,  371,
+      374,  379,  375,  381,  405,  386,  389,  403,  396,  378,
+      250,  376,  400, 1285,    0,  436,  440, 1284,  454,  471,
+        0, 1283,  382,  406, 1282,  410,  425, 1281,  415, 1280,
+      422,  430,  440,  456, 1279,  458,  459,  473,  412,  447,
+      460, 1278,  474,  442,  472,  477,  480,  476,  461,  478,
+      416,  488,  490,  491,  494,  495,  496,  492,  499,  506,
+      507,  500,  513,  505,  508,  520,  521,  523,  524,  525,
+     1277, 1276,  526, 1275, 1274, 1273, 1272, 1271, 1270,  527,
+
+     1269, 1268,  529,  533, 1267, 1266,  561,  538,  537,  542,
+      534,  572,  550, 1265, 1264, 1263,  553, 1262,  535,  575,
+      536, 1261, 1260,  576,  577, 1259,  555,  579,  540,  580,
+      586,  582,  585,  588, 1258, 1257, 1256,  593,  596, 1255,
+      590, 1254,  597, 1253,  600, 1252,  601,  602,  604,  605,
+      619,  609,  612,  618,  622,  611,  214, 1251,  628,  629,
+     1309,  635,  643,  651,  657,  662,  651,  663,  664, 1250,
+      665,  666, 1249, 1248, 1247,  667,  669,  672,  673,  675,
+      676,  677,  678,  683,  679,  686,  685,  691,  690,  693,
+     1246, 1245,  687,  697,  701,  702, 1244, 1243,  703,  707,
+
+     1242,  708,  709,  711,  713,  714,  719,  715,  721, 1241,
+     1240, 1239,  722,  724, 1238,  727,  729,  735,    0,  737,
+     1237,  741,  738,  742,  747,  748,  749, 1236,  743,  635,
+      750,  755, 1235,  760,  761, 1234,  763,  764, 1233,  767,
+     1232,  773, 1231, 1230,  775,  776,  778,  777,  781,  780,
+     1229,  783,  784,  789,  791, 1228,  792, 1227,  798,  793,
+     1226,  813, 1225,  794,  795, 1224,  801,  807,  816,  817,
+      822,  813,  796,  819,  825,  826,  828,  829,  830,  832,
+     1223,  833, 1222, 1221,  836,  837,  831,  842,  841,  843,
+      846,  853,  854,  855, 1220,  857,  858,  861,  862,  863,
+
+      866,  865, 1219,  876,  860, 1218, 1217, 1216, 1215, 1214,
+     1213, 1212,  877,  879,  880, 1211,  881,  882,  886, 1210,
+     1209,  884, 1208, 1207,  885,  890,  888,  887,  891, 1206,
+      898,  900,  901,  904,  907, 1205,  909,  911, 1204,  912,
+      916,  716,  917,  914,  915,  919, 1203, 1202, 1201,  935,
+      918, 1200, 1199, 1198,  925,  928, 1197,  938,  942,  943,
+      930, 1196,  945, 1195, 1194, 1193, 1192,  946,  949,  954,
+     1191,  950,  955, 1190, 1189, 1188, 1187, 1186,  956,  958,
+     1185, 1184, 1183, 1182,  957,  960,  968,  961,  962, 1181,
+      963, 1180,  973, 1179, 1178,  964,  975,  977,  978,  980,
+
+     1177,  981,  983,  984,  987,  988,  992,  994,  995, 1176,
+      997,  998, 1005, 1006, 1004, 1008, 1012, 1014,  920, 1175,
+     1015, 1017, 1020, 1021, 1174, 1023, 1024, 1025, 1026, 1171,
+     1162, 1160, 1029, 1159, 1027, 1044, 1032, 1028, 1158, 1045,
+     1049, 1033, 1157, 1050, 1155, 1154, 1053, 1055, 1056, 1057,
+     1059, 1060, 1061, 1063, 1065, 1066, 1067, 1069, 1071, 1152,
+     1074, 1077, 1080, 1082, 1083, 1085, 1087, 1148, 1090, 1091,
+     1096, 1097, 1098, 1147, 1095, 1101, 1102, 1103, 1145, 1107,
+     1108, 1140, 1106, 1109, 1114, 1118, 1122, 1123, 1126, 1129,
+     1128, 1130, 1131, 1132, 1133, 1070, 1134,  643,  552,  548,
 
-     1098,  756,  527,  419, 1093,  326, 1299, 1132, 1138, 1144,
-      268, 1152, 1158,  123, 1161, 1166
+     1139,  444, 1144,  360,  285,  252, 1142,  133, 1309, 1177,
+     1179,  143, 1183,   57
     } ;
 
-static yyconst short int yy_def[617] =
+static yyconst short int yy_def[615] =
     {   0,
-      607,    1,  607,  607,  607,  607,  608,  609,  610,  611,
-      609,  609,   11,   13,  612,  609,  609,  609,  609,  609,
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-      609,  609,  609,  609,  609,  609,  608,  607,  609,  607,
-      613,  613,  614,  611,   11,  609,   11,   13,   11,  612,
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-      609,  609,  609,  609,  609,  609,  607,  613,   42,  615,
-      609,   47,   11,   49,  609,  609,  609,  609,  609,  609,
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-      609,   49,  609,  609,  609,  609,  609,  609,  609,  609,
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-      609,  609,  609,  607,  615,  616,  616,  143,  143,  609,
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-      609,  212,  609,  609,  609,  609,  609,  609,  609,  609,
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-      609,  609,  267,  609,  609,  609,  609,  609,  609,  609,
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
+      609,    1,  609,  609,  609,  609,  610,  611,  612,  609,
+      611,  611,  611,  611,  613,  611,  611,  611,  611,  611,
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+      611,  611,  611,  611,  611,  611,  610,  609,  611,  609,
+      614,  614,  609,  609,  611,  611,  611,  611,  611,  613,
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+      611,  611,  611,  609,  614,  614,  609,  611,  611,  611,
+       49,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+
+      611,  611,  611,  611,  611,  611,   49,  611,  611,  611,
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+      609,  609,  609,  609,  611,  611,  611,  611,  611,  611,
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+      611,  611,  611,  611,  611,  611,  611,  611,  207,  611,
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+      611,  609,  611,  611,  611,  611,  611,  611,  611,  611,
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
+      611,  611,  611,  611,  611,  611,  611,  611,  611,  611,
 
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
-
-      609,  609,  609,  609,  609,  609,    0,  607,  607,  607,
-      607,  607,  607,  607,  607,  607
+      611,  611,  611,  611,  611,  611,  611,  611,    0,  609,
+      609,  609,  609,  609
     } ;
 
-static yyconst short int yy_nxt[1347] =
+static yyconst short int yy_nxt[1353] =
     {   0,
         4,    5,    6,    7,    8,    9,   10,   11,   12,   13,
-       14,   14,   14,   14,   14,   14,   14,    4,   15,    8,
-        8,    8,   16,   17,   18,   19,   20,   21,   22,    8,
-       23,    8,   24,   25,   26,   27,   28,    8,   29,   30,
-       31,   32,   33,   34,   35,    8,   36,   42,   40,   43,
-       43,   43,   43,   43,   43,   43,   43,   45,   45,   45,
-       45,   45,   45,   45,   45,   40,   46,  149,  181,   40,
-       40,   40,  134,   40,   40,   40,   47,   48,   48,   48,
-       48,   48,   48,   48,   48,   40,   69,   40,   40,   70,
-       40,  135,  155,   51,  162,  145,   71,   56,   40,   94,
-
-       52,   57,   53,   60,   54,   61,   58,   55,   40,   59,
-       40,   40,   49,   64,   95,   40,   62,   65,  158,   78,
-       63,   66,   40,   67,  105,   79,   68,   72,   43,   73,
-       74,   40,  182,   40,   40,   40,   40,   75,   40,   87,
-       91,   76,  133,   77,   80,  136,   81,   88,  141,   82,
-       83,   40,   89,   92,   40,  167,   90,   40,   84,   93,
-       40,   40,   40,   96,   40,   97,  118,   85,   86,   98,
-      148,   99,  102,  100,   40,  101,   40,   40,  103,  119,
-       40,  131,  120,  104,  106,   40,  150,   40,  152,  121,
-      151,  212,   40,  146,  132,  147,  153,   40,  107,   40,
-
-      108,  109,  156,  110,  111,  112,   40,  113,  154,  157,
-       40,   40,  159,  114,  160,  115,  116,  163,  117,  106,
-      161,   40,   40,   40,   40,   40,  166,   40,   40,  164,
-      168,  165,  178,  122,   40,  123,  124,  173,  125,  171,
-      126,  174,  127,  175,  128,   40,  172,  207,  129,  130,
-      139,  139,  139,  139,  139,  139,  139,  139,  142,  142,
-      142,  142,  142,  142,  142,  142,   40,  183,  179,  143,
-       40,   40,   40,   44,  256,  143,  144,  144,  144,  144,
-      144,  144,  144,  144,  180,   40,  144,  144,   40,  144,
-      144,  144,  144,  144,  144,  169,   40,   40,   40,  297,
-
-       40,  184,   40,   40,   40,  176,  189,   40,   40,   40,
-       40,  170,  196,  192,  194,  205,  185,   40,  195,  177,
-      186,  187,   40,  188,  190,  193,   40,   40,   40,  199,
-      191,   40,  197,   40,   40,  200,  202,  198,   40,   40,
-      204,  206,   40,   40,  210,   40,   40,  208,   40,  201,
-      203,  211,  215,   40,  225,  214,   40,  219,   40,  209,
-      216,   40,  229,   40,   40,   40,   40,  213,  217,  226,
-      227,  220,  218,  221,  230,   40,  222,  232,  233,  223,
-       40,  231,  224,   40,  228,  237,  234,   40,   40,   40,
-       40,  238,  266,  235,   40,   40,  239,  241,  266,  245,
-
-      259,   40,   40,  254,  236,   40,  243,  240,  246,  248,
-      249,  242,  244,  247,  250,   40,  260,  255,   40,  251,
-       40,   40,  252,  261,   40,   40,   40,  253,  257,   40,
-      258,   40,  270,   40,  272,   40,   40,  360,  275,  274,
-       40,  262,  271,  279,   40,   40,   40,  263,  267,  268,
-      273,  269,  269,  269,  269,  269,  269,  269,  269,  276,
-      277,   40,   40,  278,   40,   40,   40,  282,  280,   40,
-      281,   40,  287,   40,   40,   40,   40,   40,  285,  283,
-      284,   40,  286,  289,  288,  290,   40,   40,   40,   40,
-       40,  296,   40,   40,  303,  292,  294,  291,  293,  302,
-
-       40,   40,  300,   40,  305,  298,  295,   40,  299,  301,
-      306,  304,  307,   40,   40,   40,  310,   40,  309,   40,
-       40,   40,   40,  313,   40,   40,  308,  311,  314,   40,
-       40,   40,   40,   40,   40,  316,  356,  312,   40,  318,
-      315,  326,  319,  353,   40,  317,  320,   40,  321,  322,
-      322,  322,  322,  322,  322,  322,  322,  323,  324,  322,
-      322,  325,  322,  322,  322,  322,  322,  322,   40,   40,
-      331,   40,   40,   40,   40,   40,   40,  327,   40,  328,
-       40,  333,  334,  329,   40,  330,   40,   40,  336,   40,
-      332,  340,  335,  339,   40,  344,  337,   40,  342,  338,
-
-       40,   40,   40,  341,   40,   40,  343,   40,   40,   40,
-      345,  350,   40,   40,  358,   40,  352,  354,  348,  346,
-      347,  349,  351,  357,   40,  266,  355,  359,  267,  267,
-      361,  266,  607,  607,  607,   39,  607,   39,   40,   40,
-       40,   40,   40,   40,   40,   40,  365,  362,  368,  369,
-       40,   40,   40,   40,   40,  364,  373,  366,  367,   40,
-       40,   40,   40,   40,   40,  372,  374,  370,  371,  378,
-      376,   40,  382,   40,  377,   40,  381,   40,   40,  375,
-      379,  380,  383,   40,   40,  384,   40,   40,   40,  390,
-       40,   40,   40,   40,   40,  391,  385,   40,  389,  386,
-
-       40,  387,  388,   40,  395,   40,  396,   40,  392,  393,
-      394,  397,  398,   40,   40,   40,   40,  402,  399,   40,
-      400,  406,  404,   40,   40,  403,   40,  401,  405,   40,
-       40,   40,  408,  410,   40,  412,  407,  418,   40,  414,
-      415,   40,  413,   40,  416,   40,  409,  411,   40,   40,
-      417,   40,  419,  420,  422,  421,   40,   40,   40,  423,
-       40,   40,  424,  427,   40,   40,  425,   40,   40,   40,
-      426,   40,   40,   40,  435,   40,   40,  428,  432,  436,
-      434,   40,  429,  438,   40,  430,  439,   40,  431,   40,
-      433,  440,  441,   40,  437,  443,  442,   40,   40,   40,
-
-       40,   40,   40,   40,   40,   40,   40,  446,   40,  450,
-      451,   40,  444,  455,   40,   40,  445,  447,  449,  452,
-      456,  453,  448,   40,   40,   40,   40,   40,  454,   40,
-      457,   40,   40,   40,  461,  463,  464,   40,  458,   40,
-      459,  465,  466,  460,  462,   40,  467,   40,   40,  469,
-       40,   40,  468,   40,   40,   40,   40,   40,  472,   40,
-       40,   40,  471,  474,  476,  480,  479,   40,  470,  473,
-       40,   40,  482,  477,   40,  484,  475,   40,   40,  478,
-      483,   40,   40,  481,   40,   40,   40,   40,   40,  490,
-      487,  486,   40,   40,  485,  492,  496,  497,  489,   40,
-
-       40,  488,   40,   40,   40,  494,  495,  493,   40,  499,
-      505,   40,  491,  501,   40,  500,  498,  502,   40,  503,
-       40,   40,   40,  504,   40,   40,   40,   40,   40,   40,
-      509,   40,  506,   40,  510,  507,  515,  508,  511,  512,
-       40,  513,  516,   40,  514,   40,   40,   40,  517,   40,
-       40,   40,   40,   40,   40,   40,  518,   40,  519,  524,
-      525,   40,  523,   40,  520,   40,  521,   40,  527,  526,
-      528,  531,  522,   40,  530,  529,  534,   40,  535,   40,
-      532,   40,  536,   40,   40,   40,  533,  542,  537,   40,
-      539,   40,   40,   40,   40,   40,  541,   40,   40,   40,
-
-       40,  545,   40,   40,  538,  552,  549,  540,  546,  554,
-       40,  547,  543,  550,  544,   40,   40,  553,  548,  551,
-       40,  556,  555,   40,   40,   40,   40,   40,   40,  559,
-       40,   40,  562,  557,  560,   40,   40,   40,  565,   40,
-       40,   40,   40,   40,  563,  569,  558,  571,   40,  561,
-      567,  568,   40,   40,  570,  572,   40,   40,  566,  564,
-       40,   40,  574,   40,  573,  576,  577,   40,   40,   40,
-      580,   40,   40,   40,   40,  575,  578,   40,  581,   40,
-      584,   40,  582,  583,   40,  586,   40,  592,  589,  579,
-      587,  591,  585,   40,   40,  588,  590,   40,   40,   40,
-
-       40,   40,   40,  593,   40,   40,   40,  598,  599,  600,
-       40,   40,  595,  604,  594,   40,   40,   40,   40,  597,
-      596,   40,  603,   40,  605,   40,   40,  602,   40,  601,
-       40,  606,   37,   37,   37,   37,   37,   37,   37,   37,
-       39,   40,   39,   39,   39,   39,   41,   40,   41,   41,
-       40,   41,   50,   40,   50,   50,   50,   50,   50,   50,
-      138,   40,  138,  138,   40,  138,  265,   40,  265,  363,
-      363,  363,   40,   40,   40,   40,   40,   40,   40,   40,
-       40,   40,   40,   40,   40,   40,   40,   40,   40,   40,
+       14,   14,   14,    4,   15,    8,    8,    8,   16,   17,
+       18,   19,   20,   21,   22,    8,   23,    8,   24,   25,
+       26,   27,   28,    8,   29,   30,   31,   32,   33,   34,
+       35,    8,   36,   42,   40,   43,   43,   43,   43,   44,
+       44,   44,   44,   45,   45,   45,   45,   40,   46,  135,
+       40,   40,  152,   40,   47,   48,   48,   48,   48,   40,
+       47,   48,   48,   48,   48,   40,   40,   69,  138,   40,
+       70,   40,  158,   40,   51,   40,   40,   71,   56,   40,
+      102,   52,   57,   53,   40,   54,   49,   58,   55,   60,
+
+       59,   61,   40,  172,   40,   40,  194,   64,  146,   40,
+      128,   65,   62,   78,   83,   66,   63,   67,   40,   79,
+       68,   40,   84,  129,   40,   80,   72,   85,   73,   74,
+       40,   86,   40,  130,   81,   82,   75,   87,   40,   90,
+       76,   40,   77,  131,   40,   41,   40,  133,   91,   40,
+       88,   40,   40,   99,   92,   40,   89,   40,   40,  100,
+      142,  147,  132,  145,  101,  148,   93,  170,   94,   40,
+       40,  143,   95,  144,   96,   40,   97,   40,   98,  103,
+      149,  150,   40,   40,  155,   40,   40,  115,   40,  104,
+      153,  105,  106,  151,  107,  108,  109,  154,  110,   40,
+
+      116,  163,   40,  117,  111,   40,  112,  113,  159,  114,
+      118,  103,  171,  162,  188,   40,  136,  136,  136,  136,
+      156,  119,  157,  120,  121,   40,  122,   40,  123,   40,
+      124,  359,  125,  165,   40,  183,  126,  127,   43,   43,
+       43,   43,  137,   44,   44,   44,   44,   47,   45,   45,
+       45,   45,   40,  139,  139,  139,  139,   40,  164,   40,
+      140,  257,   40,   40,  200,   40,  140,   47,   48,   48,
+       48,   48,   40,  141,  141,  141,  141,   40,  178,  141,
+      141,   40,  141,  141,  141,  141,  141,  141,  160,   40,
+       40,   40,   40,   40,   40,   40,  166,   40,   40,  175,
+
+      161,  173,   40,   40,   40,  190,  168,   40,   40,  186,
+       40,  184,  167,  169,  179,  174,  176,  185,   40,   40,
+      177,  187,  189,  191,   40,  180,  181,  195,  182,   40,
+       40,   40,  201,  192,  193,   40,   40,   40,  197,  199,
+       40,  196,   40,   40,  202,   40,   40,   40,  203,   40,
+       40,   40,  198,  205,  214,  222,  209,  204,  210,  224,
+      206,   40,  227,   40,   40,  225,  211,  207,  215,  223,
+      208,  220,   40,   40,  212,   40,  216,   40,  213,  217,
+       40,  226,  218,  232,   40,  219,  221,   40,   40,   40,
+      228,   40,   40,  230,   40,   40,  256,  234,  229,   40,
+
+      233,  236,   40,  240,  231,  238,  267,  235,  249,   40,
+      258,  239,  241,   40,  250,  237,   40,  242,   40,   40,
+      251,  252,  254,   40,  255,   40,  243,  244,   40,   40,
+      279,  245,  269,  253,  259,   40,  246,  268,   40,  247,
+      260,  271,  272,   40,  248,  136,  136,  136,  136,  262,
+      262,  262,  262,   40,  292,   40,  263,   40,  273,  270,
+       40,  284,  263,  139,  139,  139,  139,   40,  274,   40,
+      140,   40,   40,   40,   40,  280,  140,  264,  265,  276,
+      266,  266,  266,  266,   40,   40,   40,   40,  281,   40,
+       40,   40,  275,   40,  277,  278,  282,  290,  285,  286,
+
+      283,   40,  287,   40,   40,   40,  293,   40,   40,   40,
+      291,  289,   40,   40,  288,  300,  297,  299,   40,   40,
+       40,   40,  295,  298,  301,  296,   40,  302,  303,  304,
+      294,  306,  308,   40,   40,  307,   40,   40,   40,   40,
+       40,  310,   40,  305,  309,  311,   40,   40,   40,   40,
+       40,   40,  313,   40,  315,   40,  323,  312,  330,  317,
+      316,   40,  314,   40,  337,   40,   40,  332,   40,  318,
+      319,  319,  319,  319,  320,  321,  319,  319,  322,  319,
+      319,  319,  319,  319,  319,   40,  328,  329,   40,   40,
+       40,  335,   40,   40,  324,   40,  325,  331,   40,   40,
+
+      326,   40,  327,   40,  341,  333,   40,  336,  339,   40,
+       40,  334,  338,   40,   40,   40,  340,   40,   40,  347,
+      346,  342,   40,  349,   40,   40,  343,  345,  350,  344,
+      348,   40,   40,  351,  355,   40,  352,  353,  358,  356,
+      357,   40,   40,  354,  262,  262,  262,  262,   40,  264,
+      264,  263,  362,  362,  362,  362,   40,  263,  413,  360,
+      362,  362,  362,  362,   40,  361,  266,  266,  266,  266,
+       40,  266,  266,  266,  266,   40,   40,   40,   40,   40,
+       40,  363,   40,  364,  367,   40,   40,  368,   40,   40,
+       40,   40,   40,  372,  365,  366,   40,  377,   40,   40,
+
+       40,  371,  373,   40,   40,  369,   40,  375,  370,  380,
+       40,  376,  381,  382,   40,   40,   40,  374,  378,  379,
+       40,   40,   40,  383,   40,  389,   40,   40,   40,   40,
+      390,  388,   40,  384,   40,   40,  385,   40,  386,  387,
+       40,  394,   40,  391,  393,  392,  396,  395,   40,  397,
+       40,   40,  399,  398,   40,   40,   40,  493,  405,  403,
+       40,   40,   40,   40,  400,  401,  402,  404,   40,  407,
+      409,  411,  414,   40,   40,  406,   40,   40,  415,  412,
+       40,  417,  416,  408,  410,  418,   40,  420,   40,   40,
+       40,   40,  419,   40,   40,  421,   40,   40,  422,  426,
+
+      423,  424,   40,  425,   40,   40,   40,   40,   40,   40,
+      427,   40,  436,  430,   40,  444,  437,  428,  429,  435,
+       40,  433,  362,  362,  362,  362,   40,  439,  432,   40,
+       40,  431,   40,  434,  440,   40,  438,  441,   40,   40,
+      442,   40,   40,   40,   40,   40,   40,  443,  447,   40,
+       40,  445,  451,  452,   40,   40,   40,  446,  448,   40,
+      450,  455,  453,  454,  456,  449,   40,   40,   40,  457,
+       40,   40,  458,   40,   40,   40,   40,  462,   40,   40,
+      464,  465,  459,  460,  466,  467,  461,  463,  468,   40,
+       40,  469,   40,   40,   40,   40,  471,   40,   40,   40,
+
+       40,   40,  473,   40,   40,  472,  475,  470,  477,  481,
+      480,   40,  474,   40,   40,  483,  478,   40,  476,  486,
+       40,  479,   40,  482,   40,   40,  485,   40,   40,   40,
+       40,   40,   40,   40,  484,  489,  492,  488,   40,  494,
+      487,   40,  491,   40,  543,  501,  496,  490,   40,  495,
+      497,   40,  498,  499,  500,   40,   40,  502,   40,   40,
+      503,  505,   40,   40,  504,  507,  506,   40,   40,   40,
+       40,   40,  511,   40,   40,   40,   40,   40,  512,  509,
+      508,   40,  513,  514,  510,  515,   40,  518,   40,  517,
+       40,   40,  519,   40,   40,  516,   40,   40,  522,  520,
+
+       40,   40,  526,  527,  521,   40,  525,   40,   40,  523,
+       40,   40,  529,  528,  532,  530,  524,   40,   40,   40,
+      536,   40,  531,  537,  538,   40,  539,   40,   40,  533,
+       40,  534,  541,   40,   40,  535,   40,   40,   40,   40,
+       40,   40,   40,  547,  540,   40,   40,  556,  551,  553,
+      542,  548,  544,  545,  549,  552,  546,   40,   40,  559,
+      555,  550,   40,   40,  554,  557,   40,  558,   40,   40,
+       40,  561,   40,   40,   40,  564,   40,  562,   40,   40,
+       40,  567,   40,   40,   40,  571,  560,   40,  565,  573,
+       40,  569,  563,   40,  570,   40,   40,  572,   40,  568,
+
+       40,  574,  566,   40,   40,  578,  575,  579,   40,   40,
+       40,   40,  576,  582,   40,   40,   40,  586,  577,   40,
+       40,   40,   40,  580,  583,  584,  585,   40,  588,  593,
+      591,   40,  581,  589,  592,   40,   40,  587,  590,   40,
+      594,   40,   40,   40,   40,   40,   40,   40,  595,  600,
+      601,  602,   40,   40,  597,   40,  596,   40,   40,  606,
+       40,   40,  598,  599,  605,   40,  607,   40,   40,  604,
+       40,   40,   40,   40,  603,   40,  608,   37,   37,   37,
+       37,   39,   39,   50,   40,   50,   50,   40,   40,   40,
        40,   40,   40,   40,   40,   40,   40,   40,   40,   40,
 
        40,   40,   40,   40,   40,   40,   40,   40,   40,   40,
@@ -747,166 +747,168 @@
        40,   40,   40,   40,   40,   40,   40,   40,   40,   40,
        40,   40,   40,   40,   40,   40,   40,   40,   40,   40,
        40,   40,   40,   40,   40,   40,   40,   40,   40,   40,
-       40,   40,   40,  264,   40,   40,   40,   40,   40,   39,
-       47,  140,   40,  137,   39,   40,   38,  607,    3,  607,
+       40,   40,   40,   40,   40,   40,   40,   40,   40,   40,
+       40,   40,   40,   40,   40,   40,   40,   40,  261,   40,
 
-      607,  607,  607,  607,  607,  607,  607,  607,  607,  607,
-      607,  607,  607,  607,  607,  607,  607,  607,  607,  607,
-      607,  607,  607,  607,  607,  607,  607,  607,  607,  607,
-      607,  607,  607,  607,  607,  607,  607,  607,  607,  607,
-      607,  607,  607,  607,  607,  607
+       40,   40,   40,   40,  134,   40,   38,  609,    3,  609,
+      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
+      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
+      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
+      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
+      609,  609
     } ;
 
-static yyconst short int yy_chk[1347] =
+static yyconst short int yy_chk[1353] =
     {   0,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    9,   54,    9,
-        9,    9,    9,    9,    9,    9,    9,   11,   11,   11,
-       11,   11,   11,   11,   11,   11,   12,   54,   80,   20,
-       80,   64,   35,   35,   58,   12,   13,   13,   13,   13,
-       13,   13,   13,   13,   13,   16,   20,   51,   17,   20,
-       26,   35,   58,   16,   64,   51,   20,   17,   18,   26,
-
-       16,   17,   16,   18,   16,   18,   17,   16,   19,   17,
-       22,   61,   13,   19,   26,   29,   18,   19,   61,   22,
-       18,   19,   21,   19,   29,   22,   19,   21,  614,   21,
-       21,   68,   81,   34,   24,   25,   36,   21,   81,   24,
-       25,   21,   34,   21,   23,   36,   23,   24,   46,   23,
-       23,   23,   24,   25,   27,   68,   24,   46,   23,   25,
-       28,   31,   53,   27,  106,   27,   31,   23,   23,   27,
-       53,   27,   28,   27,   55,   27,   33,   56,   28,   31,
-       52,   33,   31,   28,   30,   57,   55,   60,   56,   31,
-       55,  106,   30,   52,   33,   52,   57,   62,   30,   63,
-
-       30,   30,   60,   30,   30,   30,   66,   30,   57,   60,
-       65,   67,   62,   30,   62,   30,   30,   65,   30,   32,
-       63,   73,   69,   77,   72,   75,   67,   32,   74,   65,
-       69,   66,   77,   32,  102,   32,   32,   73,   32,   72,
-       32,   74,   32,   75,   32,   78,   72,  102,   32,   32,
-       42,   42,   42,   42,   42,   42,   42,   42,   47,   47,
-       47,   47,   47,   47,   47,   47,   79,   82,   78,   47,
-      131,   82,  176,  611,  131,   47,   49,   49,   49,   49,
-       49,   49,   49,   49,   79,   84,   49,   49,   71,   49,
-       49,   49,   49,   49,   49,   71,   76,   85,   86,  176,
-
-       87,   84,   90,   91,   92,   76,   87,   88,   89,   96,
-      100,   71,   92,   89,   90,  100,   85,   93,   91,   76,
-       86,   86,   95,   86,   88,   89,   97,   98,  105,   96,
-       88,   99,   93,  101,  103,   97,   98,   95,  104,  107,
-       99,  101,  108,  606,  105,  109,  112,  103,  110,   97,
-       98,  105,  109,  114,  112,  108,  115,  110,  111,  104,
-      109,  113,  114,  122,  117,  118,  121,  107,  109,  112,
-      113,  110,  109,  111,  115,  116,  111,  117,  118,  111,
-      120,  116,  111,  123,  113,  121,  118,  124,  125,  126,
-      127,  122,  140,  120,  129,  133,  123,  125,  140,  127,
-
-      133,  128,  135,  129,  120,  130,  126,  124,  127,  128,
-      128,  125,  126,  127,  128,  132,  134,  130,  134,  128,
-      136,  146,  128,  135,  147,  149,  152,  128,  132,  150,
-      132,  154,  146,  260,  149,  159,  604,  260,  154,  152,
-      157,  136,  147,  159,  155,  156,  160,  136,  143,  143,
-      150,  143,  143,  143,  143,  143,  143,  143,  143,  155,
-      156,  161,  162,  157,  163,  164,  167,  162,  160,  166,
-      161,  168,  167,  171,  169,  172,  170,  173,  166,  163,
-      164,  174,  166,  169,  168,  170,  175,  177,  180,  185,
-      179,  175,  184,  178,  180,  171,  173,  170,  172,  179,
-
-      188,  186,  178,  187,  185,  177,  174,  189,  177,  178,
-      186,  184,  187,  190,  191,  192,  189,  193,  188,  194,
-      195,  196,  205,  192,  198,  209,  187,  190,  193,  208,
-      253,  256,  216,  214,  213,  195,  256,  191,  215,  198,
-      194,  216,  205,  253,  603,  196,  208,  218,  209,  212,
-      212,  212,  212,  212,  212,  212,  212,  213,  214,  212,
-      212,  215,  212,  212,  212,  212,  212,  212,  217,  222,
-      218,  224,  229,  225,  226,  230,  232,  217,  233,  217,
-      234,  224,  225,  217,  235,  217,  237,  238,  229,  236,
-      222,  234,  226,  233,  239,  237,  230,  243,  236,  232,
-
-      244,  254,  248,  235,  246,  250,  236,  252,  255,  258,
-      238,  248,  262,  259,  258,  257,  252,  254,  244,  239,
-      243,  246,  250,  257,  263,  265,  255,  259,  266,  266,
-      262,  265,  267,  267,  268,  268,  269,  269,  270,  271,
-      272,  274,  279,  275,  280,  281,  271,  263,  275,  279,
-      282,  283,  285,  284,  286,  270,  283,  272,  274,  287,
-      290,  289,  296,  292,  288,  282,  284,  280,  281,  288,
-      286,  291,  292,  297,  287,  293,  291,  298,  299,  285,
-      289,  290,  293,  302,  303,  296,  305,  306,  307,  303,
-      309,  310,  308,  311,  320,  305,  297,  312,  302,  298,
-
-      316,  298,  299,  319,  309,  317,  310,  321,  306,  307,
-      308,  311,  312,  323,  326,  325,  327,  320,  316,  332,
-      317,  326,  323,  328,  329,  321,  330,  319,  325,  333,
-      338,  334,  328,  329,  335,  330,  327,  338,  341,  333,
-      334,  337,  332,  340,  335,  345,  328,  329,  343,  348,
-      337,  349,  340,  341,  345,  343,  350,  351,  352,  348,
-      353,  355,  349,  352,  356,  358,  350,  361,  360,  365,
-      351,  366,  368,  602,  365,  373,  369,  353,  360,  366,
-      361,  370,  355,  369,  371,  356,  370,  372,  358,  374,
-      360,  371,  372,  375,  368,  374,  373,  376,  377,  379,
-
-      378,  380,  381,  383,  389,  390,  386,  377,  387,  381,
-      383,  388,  375,  389,  391,  392,  376,  378,  380,  386,
-      390,  387,  379,  393,  394,  395,  398,  397,  388,  399,
-      391,  405,  400,  401,  395,  398,  399,  402,  392,  403,
-      393,  400,  401,  394,  397,  406,  402,  414,  415,  405,
-      416,  418,  403,  419,  423,  420,  426,  428,  415,  427,
-      429,  430,  414,  418,  420,  428,  427,  431,  406,  416,
-      432,  433,  430,  423,  434,  432,  419,  436,  437,  426,
-      431,  439,  440,  429,  441,  443,  442,  444,  445,  440,
-      436,  434,  449,  450,  433,  442,  449,  449,  439,  455,
-
-      460,  437,  454,  462,  457,  444,  445,  443,  458,  454,
-      462,  467,  441,  457,  459,  455,  450,  458,  468,  459,
-      469,  471,  484,  460,  472,  478,  483,  479,  485,  486,
-      471,  487,  467,  489,  472,  468,  485,  469,  478,  479,
-      491,  483,  486,  494,  484,  495,  496,  497,  487,  506,
-      498,  500,  501,  502,  504,  503,  489,  507,  491,  498,
-      500,  509,  497,  519,  494,  505,  495,  510,  502,  501,
-      503,  506,  496,  511,  505,  504,  510,  512,  511,  513,
-      507,  514,  512,  515,  516,  517,  509,  519,  513,  520,
-      515,  521,  522,  524,  525,  526,  517,  527,  534,  600,
-
-      531,  522,  535,  536,  514,  534,  527,  516,  524,  536,
-      533,  525,  520,  531,  521,  538,  539,  535,  526,  533,
-      540,  539,  538,  542,  545,  546,  547,  548,  549,  545,
-      550,  551,  548,  540,  546,  552,  554,  553,  551,  556,
-      555,  559,  557,  561,  549,  555,  542,  557,  560,  547,
-      553,  554,  562,  565,  556,  559,  563,  564,  552,  550,
-      567,  568,  561,  569,  560,  563,  564,  570,  571,  574,
-      568,  573,  575,  576,  583,  562,  565,  578,  569,  579,
-      573,  581,  570,  571,  582,  575,  584,  583,  579,  567,
-      576,  582,  574,  585,  586,  578,  581,  587,  588,  589,
-
-      592,  590,  591,  584,  593,  595,  599,  589,  590,  591,
-      605,  598,  586,  599,  585,  601,  597,  596,  594,  588,
-      587,  580,  595,  577,  601,  572,  566,  593,  558,  592,
-      544,  605,  608,  608,  608,  608,  608,  608,  608,  608,
-      609,  543,  609,  609,  609,  609,  610,  541,  610,  610,
-      537,  610,  612,  532,  612,  612,  612,  612,  612,  612,
-      613,  530,  613,  613,  529,  613,  615,  528,  615,  616,
-      616,  616,  523,  518,  508,  499,  493,  492,  490,  488,
-      482,  481,  480,  477,  476,  475,  474,  473,  470,  466,
-      465,  464,  463,  461,  456,  453,  452,  451,  448,  447,
-
-      446,  438,  435,  425,  424,  422,  421,  417,  413,  412,
-      411,  410,  409,  408,  407,  404,  396,  385,  384,  382,
-      367,  364,  362,  359,  357,  354,  347,  346,  344,  342,
-      339,  336,  331,  324,  318,  315,  314,  313,  304,  301,
-      300,  295,  294,  278,  277,  276,  273,  261,  251,  249,
-      247,  245,  242,  241,  240,  231,  228,  227,  223,  221,
-      220,  219,  211,  210,  207,  206,  204,  203,  202,  201,
-      200,  199,  197,  183,  182,  181,  165,  158,  153,  151,
-      148,  145,  141,  137,  119,   94,   83,   70,   59,   48,
-       45,   44,   39,   37,   14,    8,    7,    3,  607,  607,
-
-      607,  607,  607,  607,  607,  607,  607,  607,  607,  607,
-      607,  607,  607,  607,  607,  607,  607,  607,  607,  607,
-      607,  607,  607,  607,  607,  607,  607,  607,  607,  607,
-      607,  607,  607,  607,  607,  607,  607,  607,  607,  607,
-      607,  607,  607,  607,  607,  607
+        1,    1,    1,    9,   58,    9,    9,    9,    9,   10,
+       10,   10,   10,   11,   11,   11,   11,   11,   12,  614,
+       20,   63,   58,   12,   13,   13,   13,   13,   13,   13,
+       14,   14,   14,   14,   14,   14,   16,   20,   46,   17,
+       20,   29,   63,   46,   16,   75,   93,   20,   17,   54,
+       29,   16,   17,   16,   18,   16,   13,   17,   16,   18,
+
+       17,   18,   19,   75,   22,   33,   93,   19,   54,   24,
+       33,   19,   18,   22,   24,   19,   18,   19,   23,   22,
+       19,   21,   24,   33,   34,   23,   21,   24,   21,   21,
+       26,   24,   25,   34,   23,   23,   21,   25,   36,   26,
+       21,   28,   21,   35,   35,  612,  608,   36,   26,   55,
+       25,   73,   51,   28,   26,   53,   25,   27,   52,   28,
+       51,   55,   35,   53,   28,   55,   27,   73,   27,   56,
+       57,   52,   27,   52,   27,   60,   27,   61,   27,   30,
+       56,   57,   31,   30,   61,   64,   67,   31,   66,   30,
+       60,   30,   30,   57,   30,   30,   30,   60,   30,   74,
+
+       31,   67,   86,   31,   30,   62,   30,   30,   64,   30,
+       31,   32,   74,   66,   86,   32,   42,   42,   42,   42,
+       62,   32,   62,   32,   32,   69,   32,  257,   32,   83,
+       32,  257,   32,   69,   68,   83,   32,   32,   43,   43,
+       43,   43,   44,   44,   44,   44,   44,   45,   45,   45,
+       45,   45,   45,   47,   47,   47,   47,   47,   68,   97,
+       47,  131,   80,  131,   97,  606,   47,   48,   48,   48,
+       48,   48,   48,   49,   49,   49,   49,   49,   80,   49,
+       49,   65,   49,   49,   49,   49,   49,   49,   65,   71,
+       77,   72,   76,   78,   84,   81,   71,   88,  605,   77,
+
+       65,   76,   79,   82,   85,   88,   72,   87,   89,   85,
+       91,   84,   71,   72,   81,   76,   78,   84,   94,   92,
+       79,   85,   87,   89,   98,   82,   82,   94,   82,   95,
+       96,   99,   98,   91,   92,  100,  101,  102,   95,   96,
+      103,   94,  104,  105,   99,  107,  110,  112,  100,  114,
+      111,  106,   95,  102,  107,  110,  105,  101,  106,  111,
+      102,  108,  114,  109,  118,  112,  106,  103,  107,  110,
+      104,  109,  119,  604,  106,  113,  108,  115,  106,  108,
+      117,  113,  108,  118,  120,  108,  109,  121,  123,  132,
+      115,  130,  122,  117,  124,  143,  130,  120,  115,  126,
+
+      119,  122,  127,  124,  117,  123,  143,  121,  126,  129,
+      132,  123,  124,  133,  127,  122,  128,  124,  125,  144,
+      128,  128,  129,  146,  129,  159,  125,  125,  149,  171,
+      159,  125,  146,  128,  133,  151,  125,  144,  147,  125,
+      133,  149,  151,  152,  125,  136,  136,  136,  136,  137,
+      137,  137,  137,  153,  171,  164,  137,  602,  152,  147,
+      160,  164,  137,  139,  139,  139,  139,  139,  153,  154,
+      139,  156,  157,  161,  169,  160,  139,  140,  140,  156,
+      140,  140,  140,  140,  140,  165,  158,  163,  161,  168,
+      166,  170,  154,  167,  157,  158,  163,  169,  165,  166,
+
+      163,  172,  167,  173,  174,  178,  172,  175,  176,  177,
+      170,  168,  179,  182,  167,  177,  175,  176,  184,  180,
+      181,  185,  174,  175,  178,  174,  183,  179,  180,  181,
+      173,  182,  184,  186,  187,  183,  188,  189,  190,  193,
+      200,  186,  203,  181,  185,  187,  204,  211,  219,  221,
+      209,  208,  189,  229,  193,  210,  211,  188,  219,  203,
+      200,  600,  190,  213,  229,  599,  217,  221,  227,  204,
+      207,  207,  207,  207,  208,  209,  207,  207,  210,  207,
+      207,  207,  207,  207,  207,  212,  213,  217,  220,  224,
+      225,  227,  228,  230,  212,  232,  212,  220,  233,  231,
+
+      212,  234,  212,  241,  232,  224,  238,  228,  231,  239,
+      243,  225,  230,  245,  247,  248,  231,  249,  250,  243,
+      241,  233,  252,  247,  256,  253,  234,  239,  248,  238,
+      245,  254,  251,  249,  253,  255,  250,  251,  256,  254,
+      255,  259,  260,  252,  262,  262,  262,  262,  330,  263,
+      263,  262,  263,  263,  263,  263,  598,  262,  330,  259,
+      264,  264,  264,  264,  267,  260,  265,  265,  265,  265,
+      265,  266,  266,  266,  266,  266,  268,  269,  271,  272,
+      276,  267,  277,  268,  272,  278,  279,  276,  280,  281,
+      282,  283,  285,  280,  269,  271,  284,  285,  287,  286,
+
+      293,  279,  281,  289,  288,  277,  290,  283,  278,  288,
+      294,  284,  289,  290,  295,  296,  299,  282,  286,  287,
+      300,  302,  303,  293,  304,  300,  305,  306,  308,  442,
+      302,  299,  307,  294,  309,  313,  295,  314,  295,  296,
+      316,  306,  317,  303,  305,  304,  308,  307,  318,  309,
+      320,  323,  314,  313,  322,  324,  329,  442,  323,  320,
+      325,  326,  327,  331,  316,  317,  318,  322,  332,  325,
+      326,  327,  331,  334,  335,  324,  337,  338,  332,  329,
+      340,  335,  334,  325,  326,  337,  342,  340,  345,  346,
+      348,  347,  338,  350,  349,  342,  352,  353,  345,  349,
+
+      346,  347,  354,  348,  355,  357,  360,  364,  365,  373,
+      350,  359,  364,  354,  367,  373,  365,  352,  353,  360,
+      368,  359,  362,  362,  362,  362,  372,  368,  357,  369,
+      370,  355,  374,  359,  369,  371,  367,  370,  375,  376,
+      371,  377,  378,  379,  387,  380,  382,  372,  376,  385,
+      386,  374,  380,  382,  389,  388,  390,  375,  377,  391,
+      379,  387,  385,  386,  388,  378,  392,  393,  394,  389,
+      396,  397,  390,  405,  398,  399,  400,  394,  402,  401,
+      397,  398,  391,  392,  399,  400,  393,  396,  401,  404,
+      413,  402,  414,  415,  417,  418,  405,  422,  425,  419,
+
+      428,  427,  414,  426,  429,  413,  417,  404,  419,  427,
+      426,  431,  415,  432,  433,  429,  422,  434,  418,  433,
+      435,  425,  437,  428,  438,  440,  432,  444,  445,  441,
+      443,  451,  446,  519,  431,  437,  441,  435,  455,  443,
+      434,  456,  440,  461,  519,  455,  445,  438,  450,  444,
+      446,  458,  450,  450,  451,  459,  460,  456,  463,  468,
+      458,  460,  469,  472,  459,  463,  461,  470,  473,  479,
+      485,  480,  472,  486,  488,  489,  491,  496,  473,  469,
+      468,  487,  479,  480,  470,  485,  493,  488,  497,  487,
+      498,  499,  489,  500,  502,  486,  503,  504,  496,  491,
+
+      505,  506,  500,  502,  493,  507,  499,  508,  509,  497,
+      511,  512,  504,  503,  507,  505,  498,  515,  513,  514,
+      512,  516,  506,  513,  514,  517,  515,  518,  521,  508,
+      522,  509,  517,  523,  524,  511,  526,  527,  528,  529,
+      535,  538,  533,  524,  516,  537,  542,  538,  529,  535,
+      518,  526,  521,  522,  527,  533,  523,  536,  540,  542,
+      537,  528,  541,  544,  536,  540,  547,  541,  548,  549,
+      550,  547,  551,  552,  553,  550,  554,  548,  555,  556,
+      557,  553,  558,  596,  559,  557,  544,  561,  551,  559,
+      562,  555,  549,  563,  556,  564,  565,  558,  566,  554,
+
+      567,  561,  552,  569,  570,  565,  562,  566,  575,  571,
+      572,  573,  563,  570,  576,  577,  578,  575,  564,  583,
+      580,  581,  584,  567,  571,  572,  573,  585,  577,  584,
+      581,  586,  569,  578,  583,  587,  588,  576,  580,  589,
+      585,  591,  590,  592,  593,  594,  595,  597,  586,  591,
+      592,  593,  601,  582,  588,  607,  587,  603,  579,  601,
+      574,  568,  589,  590,  597,  560,  603,  546,  545,  595,
+      543,  539,  534,  532,  594,  531,  607,  610,  610,  610,
+      610,  611,  611,  613,  530,  613,  613,  525,  520,  510,
+      501,  495,  494,  492,  490,  484,  483,  482,  481,  478,
+
+      477,  476,  475,  474,  471,  467,  466,  465,  464,  462,
+      457,  454,  453,  452,  449,  448,  447,  439,  436,  430,
+      424,  423,  421,  420,  416,  412,  411,  410,  409,  408,
+      407,  406,  403,  395,  384,  383,  381,  366,  363,  361,
+      358,  356,  351,  344,  343,  341,  339,  336,  333,  328,
+      321,  315,  312,  311,  310,  301,  298,  297,  292,  291,
+      275,  274,  273,  270,  258,  246,  244,  242,  240,  237,
+      236,  235,  226,  223,  222,  218,  216,  215,  214,  206,
+      205,  202,  201,  199,  198,  197,  196,  195,  194,  192,
+      191,  162,  155,  150,  148,  145,  142,  138,  134,  116,
+
+       90,   70,   59,   39,   37,    8,    7,    3,  609,  609,
+      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
+      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
+      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
+      609,  609,  609,  609,  609,  609,  609,  609,  609,  609,
+      609,  609
     } ;
 
 static yy_state_type yy_state_buf[YY_BUF_SIZE + 2], *yy_state_ptr;
@@ -923,7 +925,7 @@
 #define YY_MORE_ADJ 0
 #define YY_RESTORE_YY_MORE_OFFSET
 char *yytext;
-#line 1 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
+#line 1 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
 #define INITIAL 0
 /*===-- UpgradeLexer.l - Scanner for 1.9 assembly files --------*- C++ -*--===//
 //
@@ -938,9 +940,10 @@
 //
 //===----------------------------------------------------------------------===*/
 #define YY_NEVER_INTERACTIVE 1
-#line 28 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-
+#line 28 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
 #include "UpgradeInternals.h"
+#include "llvm/Module.h"
+#include 
 #include "UpgradeParser.h"
 #include 
 #include 
@@ -955,17 +958,108 @@
   } \
 }
 
+#define YY_NEVER_INTERACTIVE 1
 
 // Construct a token value for a non-obsolete token
-#define RET_TOK(sym) \
-  Upgradelval.String = new std::string(yytext); \
+#define RET_TOK(type, Enum, sym) \
+  Upgradelval.type = Enum; \
   return sym
 
-#define RET_TY(sym,OldTY,NewTY,sign) \
-  Upgradelval.Ty = getType(NewTY, OldTY); \
+#define RET_TY(sym,NewTY,sign) \
+  Upgradelval.PrimType.T = NewTY; \
+  Upgradelval.PrimType.S = sign; \
   return sym
 
-#define YY_NEVER_INTERACTIVE 1
+namespace llvm {
+
+// TODO: All of the static identifiers are figured out by the lexer,
+// these should be hashed to reduce the lexer size
+
+// UnEscapeLexed - Run through the specified buffer and change \xx codes to the
+// appropriate character.  If AllowNull is set to false, a \00 value will cause
+// an exception to be thrown.
+//
+// If AllowNull is set to true, the return value of the function points to the
+// last character of the string in memory.
+//
+char *UnEscapeLexed(char *Buffer, bool AllowNull) {
+  char *BOut = Buffer;
+  for (char *BIn = Buffer; *BIn; ) {
+    if (BIn[0] == '\\' && isxdigit(BIn[1]) && isxdigit(BIn[2])) {
+      char Tmp = BIn[3]; BIn[3] = 0;     // Terminate string
+      *BOut = (char)strtol(BIn+1, 0, 16);  // Convert to number
+      if (!AllowNull && !*BOut)
+        error("String literal cannot accept \\00 escape!");
+
+      BIn[3] = Tmp;                  // Restore character
+      BIn += 3;                      // Skip over handled chars
+      ++BOut;
+    } else {
+      *BOut++ = *BIn++;
+    }
+  }
+
+  return BOut;
+}
+
+// atoull - Convert an ascii string of decimal digits into the unsigned long
+// long representation... this does not have to do input error checking,
+// because we know that the input will be matched by a suitable regex...
+//
+static uint64_t atoull(const char *Buffer) {
+  uint64_t Result = 0;
+  for (; *Buffer; Buffer++) {
+    uint64_t OldRes = Result;
+    Result *= 10;
+    Result += *Buffer-'0';
+    if (Result < OldRes)   // Uh, oh, overflow detected!!!
+      error("constant bigger than 64 bits detected!");
+  }
+  return Result;
+}
+
+static uint64_t HexIntToVal(const char *Buffer) {
+  uint64_t Result = 0;
+  for (; *Buffer; ++Buffer) {
+    uint64_t OldRes = Result;
+    Result *= 16;
+    char C = *Buffer;
+    if (C >= '0' && C <= '9')
+      Result += C-'0';
+    else if (C >= 'A' && C <= 'F')
+      Result += C-'A'+10;
+    else if (C >= 'a' && C <= 'f')
+      Result += C-'a'+10;
+
+    if (Result < OldRes)   // Uh, oh, overflow detected!!!
+      error("constant bigger than 64 bits detected!");
+  }
+  return Result;
+}
+
+
+// HexToFP - Convert the ascii string in hexidecimal format to the floating
+// point representation of it.
+//
+static double HexToFP(const char *Buffer) {
+  // Behave nicely in the face of C TBAA rules... see:
+  // http://www.nullstone.com/htmls/category/aliastyp.htm
+  union {
+    uint64_t UI;
+    double FP;
+  } UIntToFP;
+  UIntToFP.UI = HexIntToVal(Buffer);
+
+  assert(sizeof(double) == sizeof(uint64_t) &&
+         "Data sizes incompatible on this target!");
+  return UIntToFP.FP;   // Cast Hex constant to double
+}
+
+
+} // End llvm namespace
+
+using namespace llvm;
+
 /* Comments start with a ; and go till end of line */
 /* Variable(Value) identifiers start with a % sign */
 /* Label identifiers end with a colon */
@@ -982,7 +1076,7 @@
 /* HexIntConstant - Hexadecimal constant generated by the CFE to avoid forcing
  * it to deal with 64 bit numbers.
  */
-#line 986 "UpgradeLexer.cpp"
+#line 1080 "UpgradeLexer.cpp"
 
 /* Macros after this point can all be overridden by user definitions in
  * section 1.
@@ -1133,10 +1227,10 @@
 	register char *yy_cp = NULL, *yy_bp = NULL;
 	register int yy_act;
 
-#line 97 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
+#line 189 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
 
 
-#line 1140 "UpgradeLexer.cpp"
+#line 1234 "UpgradeLexer.cpp"
 
 	if ( yy_init )
 		{
@@ -1184,14 +1278,14 @@
 			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 				{
 				yy_current_state = (int) yy_def[yy_current_state];
-				if ( yy_current_state >= 608 )
+				if ( yy_current_state >= 610 )
 					yy_c = yy_meta[(unsigned int) yy_c];
 				}
 			yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
 			*yy_state_ptr++ = yy_current_state;
 			++yy_cp;
 			}
-		while ( yy_current_state != 607 );
+		while ( yy_current_state != 609 );
 
 yy_find_action:
 		yy_current_state = *--yy_state_ptr;
@@ -1229,776 +1323,816 @@
 	{ /* beginning of action switch */
 case 1:
 YY_RULE_SETUP
-#line 99 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
+#line 191 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
 { /* Ignore comments for now */ }
 	YY_BREAK
 case 2:
 YY_RULE_SETUP
-#line 101 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( BEGINTOK); }
+#line 193 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return BEGINTOK; }
 	YY_BREAK
 case 3:
 YY_RULE_SETUP
-#line 102 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( ENDTOK); }
+#line 194 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return ENDTOK; }
 	YY_BREAK
 case 4:
 YY_RULE_SETUP
-#line 103 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( TRUETOK);  }
+#line 195 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return TRUETOK;  }
 	YY_BREAK
 case 5:
 YY_RULE_SETUP
-#line 104 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( FALSETOK); }
+#line 196 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return FALSETOK; }
 	YY_BREAK
 case 6:
 YY_RULE_SETUP
-#line 105 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( DECLARE); }
+#line 197 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return DECLARE; }
 	YY_BREAK
 case 7:
 YY_RULE_SETUP
-#line 106 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( GLOBAL); }
+#line 198 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return GLOBAL; }
 	YY_BREAK
 case 8:
 YY_RULE_SETUP
-#line 107 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( CONSTANT); }
+#line 199 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return CONSTANT; }
 	YY_BREAK
 case 9:
 YY_RULE_SETUP
-#line 108 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( INTERNAL); }
+#line 200 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return INTERNAL; }
 	YY_BREAK
 case 10:
 YY_RULE_SETUP
-#line 109 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( LINKONCE); }
+#line 201 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return LINKONCE; }
 	YY_BREAK
 case 11:
 YY_RULE_SETUP
-#line 110 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( WEAK); }
+#line 202 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return WEAK; }
 	YY_BREAK
 case 12:
 YY_RULE_SETUP
-#line 111 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( APPENDING); }
+#line 203 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return APPENDING; }
 	YY_BREAK
 case 13:
 YY_RULE_SETUP
-#line 112 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( DLLIMPORT); }
+#line 204 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return DLLIMPORT; }
 	YY_BREAK
 case 14:
 YY_RULE_SETUP
-#line 113 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( DLLEXPORT); }
+#line 205 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return DLLEXPORT; }
 	YY_BREAK
 case 15:
 YY_RULE_SETUP
-#line 114 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( EXTERN_WEAK); }
+#line 206 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return EXTERN_WEAK; }
 	YY_BREAK
 case 16:
 YY_RULE_SETUP
-#line 115 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( EXTERNAL); }
+#line 207 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return EXTERNAL; }    /* Deprecated, turn into external */
 	YY_BREAK
 case 17:
 YY_RULE_SETUP
-#line 116 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( UNINITIALIZED); }  // alias for external
+#line 208 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return EXTERNAL; }
 	YY_BREAK
 case 18:
 YY_RULE_SETUP
-#line 117 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( IMPLEMENTATION); }
+#line 209 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return IMPLEMENTATION; }
 	YY_BREAK
 case 19:
 YY_RULE_SETUP
-#line 118 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( ZEROINITIALIZER); }
+#line 210 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return ZEROINITIALIZER; }
 	YY_BREAK
 case 20:
 YY_RULE_SETUP
-#line 119 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( DOTDOTDOT); }
+#line 211 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return DOTDOTDOT; }
 	YY_BREAK
 case 21:
 YY_RULE_SETUP
-#line 120 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( UNDEF); }
+#line 212 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return UNDEF; }
 	YY_BREAK
 case 22:
 YY_RULE_SETUP
-#line 121 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( NULL_TOK); }
+#line 213 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return NULL_TOK; }
 	YY_BREAK
 case 23:
 YY_RULE_SETUP
-#line 122 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( TO); }
+#line 214 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return TO; }
 	YY_BREAK
 case 24:
 YY_RULE_SETUP
-#line 123 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( TAIL); }
+#line 215 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return EXCEPT; }
 	YY_BREAK
 case 25:
 YY_RULE_SETUP
-#line 124 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( TARGET); }
+#line 216 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return NOT; }  /* Deprecated, turned into XOR */
 	YY_BREAK
 case 26:
 YY_RULE_SETUP
-#line 125 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( TRIPLE); }
+#line 217 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return TAIL; }
 	YY_BREAK
 case 27:
 YY_RULE_SETUP
-#line 126 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( DEPLIBS); }
+#line 218 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return TARGET; }
 	YY_BREAK
 case 28:
 YY_RULE_SETUP
-#line 127 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( ENDIAN); }
+#line 219 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return TRIPLE; }
 	YY_BREAK
 case 29:
 YY_RULE_SETUP
-#line 128 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( POINTERSIZE); }
+#line 220 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return DEPLIBS; }
 	YY_BREAK
 case 30:
 YY_RULE_SETUP
-#line 129 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( DATALAYOUT); }
+#line 221 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return ENDIAN; }
 	YY_BREAK
 case 31:
 YY_RULE_SETUP
-#line 130 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( LITTLE); }
+#line 222 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return POINTERSIZE; }
 	YY_BREAK
 case 32:
 YY_RULE_SETUP
-#line 131 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( BIG); }
+#line 223 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return DATALAYOUT; }
 	YY_BREAK
 case 33:
 YY_RULE_SETUP
-#line 132 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( VOLATILE); }
+#line 224 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return LITTLE; }
 	YY_BREAK
 case 34:
 YY_RULE_SETUP
-#line 133 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( ALIGN);  }
+#line 225 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return BIG; }
 	YY_BREAK
 case 35:
 YY_RULE_SETUP
-#line 134 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( SECTION); }
+#line 226 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return VOLATILE; }
 	YY_BREAK
 case 36:
 YY_RULE_SETUP
-#line 135 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( MODULE); }
+#line 227 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return ALIGN;  }
 	YY_BREAK
 case 37:
 YY_RULE_SETUP
-#line 136 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( ASM_TOK); }
+#line 228 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return SECTION; }
 	YY_BREAK
 case 38:
 YY_RULE_SETUP
-#line 137 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( SIDEEFFECT); }
+#line 229 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return MODULE; }
 	YY_BREAK
 case 39:
 YY_RULE_SETUP
-#line 139 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( CC_TOK); }
+#line 230 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return ASM_TOK; }
 	YY_BREAK
 case 40:
 YY_RULE_SETUP
-#line 140 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( CCC_TOK); }
+#line 231 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return SIDEEFFECT; }
 	YY_BREAK
 case 41:
 YY_RULE_SETUP
-#line 141 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( CSRETCC_TOK); }
+#line 233 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return CC_TOK; }
 	YY_BREAK
 case 42:
 YY_RULE_SETUP
-#line 142 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( FASTCC_TOK); }
+#line 234 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return CCC_TOK; }
 	YY_BREAK
 case 43:
 YY_RULE_SETUP
-#line 143 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( COLDCC_TOK); }
+#line 235 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return CSRETCC_TOK; }
 	YY_BREAK
 case 44:
 YY_RULE_SETUP
-#line 144 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( X86_STDCALLCC_TOK); }
+#line 236 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return FASTCC_TOK; }
 	YY_BREAK
 case 45:
 YY_RULE_SETUP
-#line 145 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( X86_FASTCALLCC_TOK); }
+#line 237 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return COLDCC_TOK; }
 	YY_BREAK
 case 46:
 YY_RULE_SETUP
-#line 147 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TY(VOID,VoidTy,"void",false); }
+#line 238 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return X86_STDCALLCC_TOK; }
 	YY_BREAK
 case 47:
 YY_RULE_SETUP
-#line 148 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TY(BOOL,BoolTy,"i1",false); }
+#line 239 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return X86_FASTCALLCC_TOK; }
 	YY_BREAK
 case 48:
 YY_RULE_SETUP
-#line 149 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TY(SBYTE,SByteTy,"i8",true); }
+#line 241 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TY(SBYTE,  Type::Int8Ty,  Signed);  }
 	YY_BREAK
 case 49:
 YY_RULE_SETUP
-#line 150 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TY(UBYTE,UByteTy,"i8",false); }
+#line 242 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TY(UBYTE,  Type::Int8Ty,  Unsigned); }
 	YY_BREAK
 case 50:
 YY_RULE_SETUP
-#line 151 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TY(SHORT,ShortTy,"i16",true); }
+#line 243 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TY(SHORT,  Type::Int16Ty, Signed);  }
 	YY_BREAK
 case 51:
 YY_RULE_SETUP
-#line 152 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TY(USHORT,UShortTy,"i16",false); }
+#line 244 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TY(USHORT, Type::Int16Ty, Unsigned); }
 	YY_BREAK
 case 52:
 YY_RULE_SETUP
-#line 153 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TY(INT,IntTy,"i32",true);   }
+#line 245 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TY(INT,    Type::Int32Ty, Signed);  }
 	YY_BREAK
 case 53:
 YY_RULE_SETUP
-#line 154 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TY(UINT,UIntTy,"i32",false);  }
+#line 246 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TY(UINT,   Type::Int32Ty, Unsigned); }
 	YY_BREAK
 case 54:
 YY_RULE_SETUP
-#line 155 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TY(LONG,LongTy,"i64",true);  }
+#line 247 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TY(LONG,   Type::Int64Ty, Signed);  }
 	YY_BREAK
 case 55:
 YY_RULE_SETUP
-#line 156 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TY(ULONG,ULongTy,"i64",false); }
+#line 248 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TY(ULONG,  Type::Int64Ty, Unsigned); }
 	YY_BREAK
 case 56:
 YY_RULE_SETUP
-#line 157 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TY(UBYTE,UByteTy,"i8",false); }
+#line 249 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TY(VOID,   Type::VoidTy,  Signless  ); }
 	YY_BREAK
 case 57:
 YY_RULE_SETUP
-#line 158 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TY(USHORT,UShortTy,"i16",false); }
+#line 250 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TY(BOOL,   Type::Int1Ty,  Unsigned  ); }
 	YY_BREAK
 case 58:
 YY_RULE_SETUP
-#line 159 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TY(UINT,UIntTy,"i32",false); }
+#line 251 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TY(FLOAT,  Type::FloatTy, Signless ); }
 	YY_BREAK
 case 59:
 YY_RULE_SETUP
-#line 160 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TY(ULONG,ULongTy,"i64",false); }
+#line 252 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TY(DOUBLE, Type::DoubleTy,Signless); }
 	YY_BREAK
 case 60:
 YY_RULE_SETUP
-#line 161 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TY(FLOAT,FloatTy,"float",false); }
+#line 253 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TY(LABEL,  Type::LabelTy, Signless ); }
 	YY_BREAK
 case 61:
 YY_RULE_SETUP
-#line 162 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TY(DOUBLE,DoubleTy,"double",false); }
+#line 254 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return TYPE;   }
 	YY_BREAK
 case 62:
 YY_RULE_SETUP
-#line 163 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TY(LABEL,LabelTy,"label",false); }
+#line 255 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return OPAQUE; }
 	YY_BREAK
 case 63:
 YY_RULE_SETUP
-#line 164 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK(OPAQUE); }
+#line 257 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(BinaryOpVal, AddOp, ADD); }
 	YY_BREAK
 case 64:
 YY_RULE_SETUP
-#line 165 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK(TYPE);   }
+#line 258 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(BinaryOpVal, SubOp, SUB); }
 	YY_BREAK
 case 65:
 YY_RULE_SETUP
-#line 167 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( ADD); }
+#line 259 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(BinaryOpVal, MulOp, MUL); }
 	YY_BREAK
 case 66:
 YY_RULE_SETUP
-#line 168 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( SUB); }
+#line 260 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(BinaryOpVal, DivOp,  DIV); }
 	YY_BREAK
 case 67:
 YY_RULE_SETUP
-#line 169 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( MUL); }
+#line 261 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(BinaryOpVal, UDivOp, UDIV); }
 	YY_BREAK
 case 68:
 YY_RULE_SETUP
-#line 170 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( DIV); }
+#line 262 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(BinaryOpVal, SDivOp, SDIV); }
 	YY_BREAK
 case 69:
 YY_RULE_SETUP
-#line 171 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( UDIV); }
+#line 263 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(BinaryOpVal, FDivOp, FDIV); }
 	YY_BREAK
 case 70:
 YY_RULE_SETUP
-#line 172 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( SDIV); }
+#line 264 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(BinaryOpVal, RemOp,  REM); }
 	YY_BREAK
 case 71:
 YY_RULE_SETUP
-#line 173 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( FDIV); }
+#line 265 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(BinaryOpVal, URemOp, UREM); }
 	YY_BREAK
 case 72:
 YY_RULE_SETUP
-#line 174 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( REM);  }
+#line 266 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(BinaryOpVal, SRemOp, SREM); }
 	YY_BREAK
 case 73:
 YY_RULE_SETUP
-#line 175 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( UREM); }
+#line 267 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(BinaryOpVal, FRemOp, FREM); }
 	YY_BREAK
 case 74:
 YY_RULE_SETUP
-#line 176 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( SREM); }
+#line 268 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(BinaryOpVal, AndOp, AND); }
 	YY_BREAK
 case 75:
 YY_RULE_SETUP
-#line 177 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( FREM); }
+#line 269 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(BinaryOpVal, OrOp , OR ); }
 	YY_BREAK
 case 76:
 YY_RULE_SETUP
-#line 178 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( AND); }
+#line 270 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(BinaryOpVal, XorOp, XOR); }
 	YY_BREAK
 case 77:
 YY_RULE_SETUP
-#line 179 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( OR); }
+#line 271 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(BinaryOpVal, SetNE, SETNE); }
 	YY_BREAK
 case 78:
 YY_RULE_SETUP
-#line 180 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( XOR); }
+#line 272 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(BinaryOpVal, SetEQ, SETEQ); }
 	YY_BREAK
 case 79:
 YY_RULE_SETUP
-#line 181 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( SETNE); }
+#line 273 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(BinaryOpVal, SetLT, SETLT); }
 	YY_BREAK
 case 80:
 YY_RULE_SETUP
-#line 182 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( SETEQ); }
+#line 274 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(BinaryOpVal, SetGT, SETGT); }
 	YY_BREAK
 case 81:
 YY_RULE_SETUP
-#line 183 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( SETLT); }
+#line 275 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(BinaryOpVal, SetLE, SETLE); }
 	YY_BREAK
 case 82:
 YY_RULE_SETUP
-#line 184 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( SETGT); }
+#line 276 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(BinaryOpVal, SetGE, SETGE); }
 	YY_BREAK
 case 83:
 YY_RULE_SETUP
-#line 185 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( SETLE); }
+#line 277 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(OtherOpVal, ICmpOp, ICMP); }
 	YY_BREAK
 case 84:
 YY_RULE_SETUP
-#line 186 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( SETGE); }
+#line 278 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(OtherOpVal, FCmpOp, FCMP); }
 	YY_BREAK
 case 85:
 YY_RULE_SETUP
-#line 187 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK(ICMP); }
+#line 280 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return EQ; }
 	YY_BREAK
 case 86:
 YY_RULE_SETUP
-#line 188 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK(FCMP); }
+#line 281 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return NE; }
 	YY_BREAK
 case 87:
 YY_RULE_SETUP
-#line 189 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK(EQ); }
+#line 282 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return SLT; }
 	YY_BREAK
 case 88:
 YY_RULE_SETUP
-#line 190 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK(NE); }
+#line 283 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return SGT; }
 	YY_BREAK
 case 89:
 YY_RULE_SETUP
-#line 191 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK(SLT); }
+#line 284 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return SLE; }
 	YY_BREAK
 case 90:
 YY_RULE_SETUP
-#line 192 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK(SGT); }
+#line 285 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return SGE; }
 	YY_BREAK
 case 91:
 YY_RULE_SETUP
-#line 193 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK(SLE); }
+#line 286 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return ULT; }
 	YY_BREAK
 case 92:
 YY_RULE_SETUP
-#line 194 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK(SGE); }
+#line 287 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return UGT; }
 	YY_BREAK
 case 93:
 YY_RULE_SETUP
-#line 195 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK(OEQ); }
+#line 288 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return ULE; }
 	YY_BREAK
 case 94:
 YY_RULE_SETUP
-#line 196 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK(ONE); }
+#line 289 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return UGE; }
 	YY_BREAK
 case 95:
 YY_RULE_SETUP
-#line 197 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK(OLT); }
+#line 290 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return OEQ; }
 	YY_BREAK
 case 96:
 YY_RULE_SETUP
-#line 198 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK(OGT); }
+#line 291 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return ONE; }
 	YY_BREAK
 case 97:
 YY_RULE_SETUP
-#line 199 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK(OLE); }
+#line 292 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return OLT; }
 	YY_BREAK
 case 98:
 YY_RULE_SETUP
-#line 200 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK(OGE); }
+#line 293 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return OGT; }
 	YY_BREAK
 case 99:
 YY_RULE_SETUP
-#line 201 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK(ORD); }
+#line 294 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return OLE; }
 	YY_BREAK
 case 100:
 YY_RULE_SETUP
-#line 202 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK(UNO); }
+#line 295 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return OGE; }
 	YY_BREAK
 case 101:
 YY_RULE_SETUP
-#line 203 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK(UEQ); }
+#line 296 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return ORD; }
 	YY_BREAK
 case 102:
 YY_RULE_SETUP
-#line 204 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK(UNE); }
+#line 297 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return UNO; }
 	YY_BREAK
 case 103:
 YY_RULE_SETUP
-#line 205 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK(ULT); }
+#line 298 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return UEQ; }
 	YY_BREAK
 case 104:
 YY_RULE_SETUP
-#line 206 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK(UGT); }
+#line 299 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return UNE; }
 	YY_BREAK
 case 105:
 YY_RULE_SETUP
-#line 207 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK(ULE); }
+#line 301 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(OtherOpVal, PHIOp, PHI_TOK); }
 	YY_BREAK
 case 106:
 YY_RULE_SETUP
-#line 208 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK(UGE); }
+#line 302 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(OtherOpVal, CallOp, CALL); }
 	YY_BREAK
 case 107:
 YY_RULE_SETUP
-#line 210 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( PHI_TOK); }
+#line 303 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(CastOpVal, CastOp, CAST);  }
 	YY_BREAK
 case 108:
 YY_RULE_SETUP
-#line 211 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( CALL); }
+#line 304 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(CastOpVal, TruncOp, TRUNC); }
 	YY_BREAK
 case 109:
 YY_RULE_SETUP
-#line 212 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( CAST); }
+#line 305 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(CastOpVal, ZExtOp , ZEXT); }
 	YY_BREAK
 case 110:
 YY_RULE_SETUP
-#line 213 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( TRUNC); }
+#line 306 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(CastOpVal, SExtOp, SEXT); }
 	YY_BREAK
 case 111:
 YY_RULE_SETUP
-#line 214 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( ZEXT); }
+#line 307 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(CastOpVal, FPTruncOp, FPTRUNC); }
 	YY_BREAK
 case 112:
 YY_RULE_SETUP
-#line 215 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( SEXT); }
+#line 308 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(CastOpVal, FPExtOp, FPEXT); }
 	YY_BREAK
 case 113:
 YY_RULE_SETUP
-#line 216 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( FPTRUNC); }
+#line 309 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(CastOpVal, FPToUIOp, FPTOUI); }
 	YY_BREAK
 case 114:
 YY_RULE_SETUP
-#line 217 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( FPEXT); }
+#line 310 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(CastOpVal, FPToSIOp, FPTOSI); }
 	YY_BREAK
 case 115:
 YY_RULE_SETUP
-#line 218 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( FPTOUI); }
+#line 311 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(CastOpVal, UIToFPOp, UITOFP); }
 	YY_BREAK
 case 116:
 YY_RULE_SETUP
-#line 219 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( FPTOSI); }
+#line 312 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(CastOpVal, SIToFPOp, SITOFP); }
 	YY_BREAK
 case 117:
 YY_RULE_SETUP
-#line 220 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( UITOFP); }
+#line 313 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(CastOpVal, PtrToIntOp, PTRTOINT); }
 	YY_BREAK
 case 118:
 YY_RULE_SETUP
-#line 221 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( SITOFP); }
+#line 314 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(CastOpVal, IntToPtrOp, INTTOPTR); }
 	YY_BREAK
 case 119:
 YY_RULE_SETUP
-#line 222 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( PTRTOINT); }
+#line 315 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(CastOpVal, BitCastOp, BITCAST); }
 	YY_BREAK
 case 120:
 YY_RULE_SETUP
-#line 223 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( INTTOPTR); }
+#line 316 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(OtherOpVal, SelectOp, SELECT); }
 	YY_BREAK
 case 121:
 YY_RULE_SETUP
-#line 224 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( BITCAST); }
+#line 317 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(OtherOpVal, ShlOp, SHL); }
 	YY_BREAK
 case 122:
 YY_RULE_SETUP
-#line 225 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( SELECT); }
+#line 318 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(OtherOpVal, ShrOp, SHR); }
 	YY_BREAK
 case 123:
 YY_RULE_SETUP
-#line 226 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( SHL); }
+#line 319 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(OtherOpVal, LShrOp, LSHR); }
 	YY_BREAK
 case 124:
 YY_RULE_SETUP
-#line 227 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( SHR); }
+#line 320 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(OtherOpVal, AShrOp, ASHR); }
 	YY_BREAK
 case 125:
 YY_RULE_SETUP
-#line 228 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( ASHR); }
+#line 321 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return VANEXT_old; }
 	YY_BREAK
 case 126:
 YY_RULE_SETUP
-#line 229 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( LSHR); }
+#line 322 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return VAARG_old; }
 	YY_BREAK
 case 127:
 YY_RULE_SETUP
-#line 230 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( VAARG); }
+#line 323 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(OtherOpVal, VAArg , VAARG); }
 	YY_BREAK
 case 128:
 YY_RULE_SETUP
-#line 231 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( RET); }
+#line 324 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(TermOpVal, RetOp, RET); }
 	YY_BREAK
 case 129:
 YY_RULE_SETUP
-#line 232 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( BR); }
+#line 325 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(TermOpVal, BrOp, BR); }
 	YY_BREAK
 case 130:
 YY_RULE_SETUP
-#line 233 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( SWITCH); }
+#line 326 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(TermOpVal, SwitchOp, SWITCH); }
 	YY_BREAK
 case 131:
 YY_RULE_SETUP
-#line 234 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( INVOKE); }
+#line 327 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(TermOpVal, InvokeOp, INVOKE); }
 	YY_BREAK
 case 132:
 YY_RULE_SETUP
-#line 235 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( UNWIND); }
+#line 328 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ return UNWIND; }
 	YY_BREAK
 case 133:
 YY_RULE_SETUP
-#line 236 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( EXCEPT); } // alias for unwind
+#line 329 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(TermOpVal, UnreachableOp, UNREACHABLE); }
 	YY_BREAK
 case 134:
 YY_RULE_SETUP
-#line 237 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( UNREACHABLE); }
+#line 331 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(MemOpVal, MallocOp, MALLOC); }
 	YY_BREAK
 case 135:
 YY_RULE_SETUP
-#line 239 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( MALLOC); }
+#line 332 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(MemOpVal, AllocaOp, ALLOCA); }
 	YY_BREAK
 case 136:
 YY_RULE_SETUP
-#line 240 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( ALLOCA); }
+#line 333 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(MemOpVal, FreeOp, FREE); }
 	YY_BREAK
 case 137:
 YY_RULE_SETUP
-#line 241 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( FREE); }
+#line 334 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(MemOpVal, LoadOp, LOAD); }
 	YY_BREAK
 case 138:
 YY_RULE_SETUP
-#line 242 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( LOAD); }
+#line 335 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(MemOpVal, StoreOp, STORE); }
 	YY_BREAK
 case 139:
 YY_RULE_SETUP
-#line 243 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( STORE); }
+#line 336 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(MemOpVal, GetElementPtrOp, GETELEMENTPTR); }
 	YY_BREAK
 case 140:
 YY_RULE_SETUP
-#line 244 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( GETELEMENTPTR); }
+#line 338 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(OtherOpVal, ExtractElementOp, EXTRACTELEMENT); }
 	YY_BREAK
 case 141:
 YY_RULE_SETUP
-#line 246 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( EXTRACTELEMENT); }
+#line 339 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(OtherOpVal, InsertElementOp, INSERTELEMENT); }
 	YY_BREAK
 case 142:
 YY_RULE_SETUP
-#line 247 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( INSERTELEMENT); }
+#line 340 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ RET_TOK(OtherOpVal, ShuffleVectorOp, SHUFFLEVECTOR); }
 	YY_BREAK
 case 143:
 YY_RULE_SETUP
-#line 248 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( SHUFFLEVECTOR); }
+#line 343 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{
+                  UnEscapeLexed(yytext+1);
+                  Upgradelval.StrVal = strdup(yytext+1);             // Skip %
+                  return VAR_ID;
+                }
 	YY_BREAK
 case 144:
 YY_RULE_SETUP
-#line 251 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( VAR_ID); }
+#line 348 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{
+                  yytext[strlen(yytext)-1] = 0;  // nuke colon
+                  UnEscapeLexed(yytext);
+                  Upgradelval.StrVal = strdup(yytext);
+                  return LABELSTR;
+                }
 	YY_BREAK
 case 145:
 YY_RULE_SETUP
-#line 252 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( LABELSTR); }
+#line 354 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{
+                  yytext[strlen(yytext)-2] = 0;  // nuke colon, end quote
+                  UnEscapeLexed(yytext+1);
+                  Upgradelval.StrVal = strdup(yytext+1);
+                  return LABELSTR;
+                }
 	YY_BREAK
 case 146:
 YY_RULE_SETUP
-#line 253 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( LABELSTR); }
+#line 361 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ // Note that we cannot unescape a string constant here!  The
+                   // string constant might contain a \00 which would not be
+                   // understood by the string stuff.  It is valid to make a
+                   // [sbyte] c"Hello World\00" constant, for example.
+                   //
+                   yytext[strlen(yytext)-1] = 0;           // nuke end quote
+                   Upgradelval.StrVal = strdup(yytext+1);  // Nuke start quote
+                   return STRINGCONSTANT;
+                 }
 	YY_BREAK
 case 147:
 YY_RULE_SETUP
-#line 254 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( STRINGCONSTANT ); }
+#line 372 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ Upgradelval.UInt64Val = atoull(yytext); return EUINT64VAL; }
 	YY_BREAK
 case 148:
 YY_RULE_SETUP
-#line 255 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( EUINT64VAL ); }
+#line 373 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{
+                  uint64_t Val = atoull(yytext+1);
+                  // +1:  we have bigger negative range
+                  if (Val > (uint64_t)INT64_MAX+1)
+                    error("Constant too large for signed 64 bits!");
+                  Upgradelval.SInt64Val = -Val;
+                  return ESINT64VAL;
+                }
 	YY_BREAK
 case 149:
 YY_RULE_SETUP
-#line 256 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( ESINT64VAL ); }
+#line 381 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{
+                   Upgradelval.UInt64Val = HexIntToVal(yytext+3);
+                   return yytext[0] == 's' ? ESINT64VAL : EUINT64VAL;
+                 }
 	YY_BREAK
 case 150:
 YY_RULE_SETUP
-#line 257 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( yytext[0] == 's' ? ESINT64VAL : EUINT64VAL ); }
+#line 386 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{
+                  uint64_t Val = atoull(yytext+1);
+                  if ((unsigned)Val != Val)
+                    error("Invalid value number (too large)!");
+                  Upgradelval.UIntVal = unsigned(Val);
+                  return UINTVAL;
+                }
 	YY_BREAK
 case 151:
 YY_RULE_SETUP
-#line 258 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( UINTVAL); }
+#line 393 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{
+                  uint64_t Val = atoull(yytext+2);
+                  // +1:  we have bigger negative range
+                  if (Val > (uint64_t)INT32_MAX+1)
+                    error("Constant too large for signed 32 bits!");
+                  Upgradelval.SIntVal = (int)-Val;
+                  return SINTVAL;
+                }
 	YY_BREAK
 case 152:
 YY_RULE_SETUP
-#line 259 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( SINTVAL); }
+#line 402 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ Upgradelval.FPVal = atof(yytext); return FPVAL; }
 	YY_BREAK
 case 153:
 YY_RULE_SETUP
-#line 260 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( FPVAL); }
-	YY_BREAK
-case 154:
-YY_RULE_SETUP
-#line 261 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
-{ RET_TOK( FPVAL); }
+#line 403 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+{ Upgradelval.FPVal = HexToFP(yytext); return FPVAL; }
 	YY_BREAK
 case YY_STATE_EOF(INITIAL):
-#line 262 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
+#line 405 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
 {
                   /* Make sure to free the internal buffers for flex when we are
                    * done reading our input!
@@ -2007,22 +2141,22 @@
                   return EOF;
                 }
 	YY_BREAK
-case 155:
+case 154:
 YY_RULE_SETUP
-#line 270 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
+#line 413 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
 { /* Ignore whitespace */ }
 	YY_BREAK
-case 156:
+case 155:
 YY_RULE_SETUP
-#line 271 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
+#line 414 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
 { return yytext[0]; }
 	YY_BREAK
-case 157:
+case 156:
 YY_RULE_SETUP
-#line 273 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
+#line 416 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
 YY_FATAL_ERROR( "flex scanner jammed" );
 	YY_BREAK
-#line 2026 "UpgradeLexer.cpp"
+#line 2160 "UpgradeLexer.cpp"
 
 	case YY_END_OF_BUFFER:
 		{
@@ -2309,7 +2443,7 @@
 		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 			{
 			yy_current_state = (int) yy_def[yy_current_state];
-			if ( yy_current_state >= 608 )
+			if ( yy_current_state >= 610 )
 				yy_c = yy_meta[(unsigned int) yy_c];
 			}
 		yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
@@ -2339,11 +2473,11 @@
 	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 		{
 		yy_current_state = (int) yy_def[yy_current_state];
-		if ( yy_current_state >= 608 )
+		if ( yy_current_state >= 610 )
 			yy_c = yy_meta[(unsigned int) yy_c];
 		}
 	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
-	yy_is_jam = (yy_current_state == 607);
+	yy_is_jam = (yy_current_state == 609);
 	if ( ! yy_is_jam )
 		*yy_state_ptr++ = yy_current_state;
 
@@ -2900,5 +3034,5 @@
 	return 0;
 	}
 #endif
-#line 273 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeLexer.l"
+#line 416 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
 


Index: llvm/tools/llvm-upgrade/UpgradeLexer.l.cvs
diff -u llvm/tools/llvm-upgrade/UpgradeLexer.l.cvs:1.16 llvm/tools/llvm-upgrade/UpgradeLexer.l.cvs:1.17
--- llvm/tools/llvm-upgrade/UpgradeLexer.l.cvs:1.16	Sun Jan 14 20:41:46 2007
+++ llvm/tools/llvm-upgrade/UpgradeLexer.l.cvs	Fri Jan 26 02:19:09 2007
@@ -25,8 +25,9 @@
 %option noyymore
 
 %{
-
 #include "UpgradeInternals.h"
+#include "llvm/Module.h"
+#include 
 #include "UpgradeParser.h"
 #include 
 #include 
@@ -41,17 +42,108 @@
   } \
 }
 
+#define YY_NEVER_INTERACTIVE 1
 
 // Construct a token value for a non-obsolete token
-#define RET_TOK(sym) \
-  Upgradelval.String = new std::string(yytext); \
+#define RET_TOK(type, Enum, sym) \
+  Upgradelval.type = Enum; \
   return sym
 
-#define RET_TY(sym,OldTY,NewTY,sign) \
-  Upgradelval.Ty = getType(NewTY, OldTY); \
+#define RET_TY(sym,NewTY,sign) \
+  Upgradelval.PrimType.T = NewTY; \
+  Upgradelval.PrimType.S = sign; \
   return sym
 
-#define YY_NEVER_INTERACTIVE 1
+namespace llvm {
+
+// TODO: All of the static identifiers are figured out by the lexer,
+// these should be hashed to reduce the lexer size
+
+// UnEscapeLexed - Run through the specified buffer and change \xx codes to the
+// appropriate character.  If AllowNull is set to false, a \00 value will cause
+// an exception to be thrown.
+//
+// If AllowNull is set to true, the return value of the function points to the
+// last character of the string in memory.
+//
+char *UnEscapeLexed(char *Buffer, bool AllowNull) {
+  char *BOut = Buffer;
+  for (char *BIn = Buffer; *BIn; ) {
+    if (BIn[0] == '\\' && isxdigit(BIn[1]) && isxdigit(BIn[2])) {
+      char Tmp = BIn[3]; BIn[3] = 0;     // Terminate string
+      *BOut = (char)strtol(BIn+1, 0, 16);  // Convert to number
+      if (!AllowNull && !*BOut)
+        error("String literal cannot accept \\00 escape!");
+
+      BIn[3] = Tmp;                  // Restore character
+      BIn += 3;                      // Skip over handled chars
+      ++BOut;
+    } else {
+      *BOut++ = *BIn++;
+    }
+  }
+
+  return BOut;
+}
+
+// atoull - Convert an ascii string of decimal digits into the unsigned long
+// long representation... this does not have to do input error checking,
+// because we know that the input will be matched by a suitable regex...
+//
+static uint64_t atoull(const char *Buffer) {
+  uint64_t Result = 0;
+  for (; *Buffer; Buffer++) {
+    uint64_t OldRes = Result;
+    Result *= 10;
+    Result += *Buffer-'0';
+    if (Result < OldRes)   // Uh, oh, overflow detected!!!
+      error("constant bigger than 64 bits detected!");
+  }
+  return Result;
+}
+
+static uint64_t HexIntToVal(const char *Buffer) {
+  uint64_t Result = 0;
+  for (; *Buffer; ++Buffer) {
+    uint64_t OldRes = Result;
+    Result *= 16;
+    char C = *Buffer;
+    if (C >= '0' && C <= '9')
+      Result += C-'0';
+    else if (C >= 'A' && C <= 'F')
+      Result += C-'A'+10;
+    else if (C >= 'a' && C <= 'f')
+      Result += C-'a'+10;
+
+    if (Result < OldRes)   // Uh, oh, overflow detected!!!
+      error("constant bigger than 64 bits detected!");
+  }
+  return Result;
+}
+
+
+// HexToFP - Convert the ascii string in hexidecimal format to the floating
+// point representation of it.
+//
+static double HexToFP(const char *Buffer) {
+  // Behave nicely in the face of C TBAA rules... see:
+  // http://www.nullstone.com/htmls/category/aliastyp.htm
+  union {
+    uint64_t UI;
+    double FP;
+  } UIntToFP;
+  UIntToFP.UI = HexIntToVal(Buffer);
+
+  assert(sizeof(double) == sizeof(uint64_t) &&
+         "Data sizes incompatible on this target!");
+  return UIntToFP.FP;   // Cast Hex constant to double
+}
+
+
+} // End llvm namespace
+
+using namespace llvm;
+
 %}
 
 
@@ -98,168 +190,219 @@
 
 {Comment}       { /* Ignore comments for now */ }
 
-begin           { RET_TOK( BEGINTOK); }
-end             { RET_TOK( ENDTOK); }
-true            { RET_TOK( TRUETOK);  }
-false           { RET_TOK( FALSETOK); }
-declare         { RET_TOK( DECLARE); }
-global          { RET_TOK( GLOBAL); }
-constant        { RET_TOK( CONSTANT); }
-internal        { RET_TOK( INTERNAL); }
-linkonce        { RET_TOK( LINKONCE); }
-weak            { RET_TOK( WEAK); }
-appending       { RET_TOK( APPENDING); }
-dllimport       { RET_TOK( DLLIMPORT); }
-dllexport       { RET_TOK( DLLEXPORT); }
-extern_weak     { RET_TOK( EXTERN_WEAK); }
-external        { RET_TOK( EXTERNAL); }
-uninitialized   { RET_TOK( UNINITIALIZED); }  // alias for external
-implementation  { RET_TOK( IMPLEMENTATION); }
-zeroinitializer { RET_TOK( ZEROINITIALIZER); }
-\.\.\.          { RET_TOK( DOTDOTDOT); }
-undef           { RET_TOK( UNDEF); }
-null            { RET_TOK( NULL_TOK); }
-to              { RET_TOK( TO); }
-tail            { RET_TOK( TAIL); }
-target          { RET_TOK( TARGET); }
-triple          { RET_TOK( TRIPLE); }
-deplibs         { RET_TOK( DEPLIBS); }
-endian          { RET_TOK( ENDIAN); }
-pointersize     { RET_TOK( POINTERSIZE); }
-datalayout      { RET_TOK( DATALAYOUT); }
-little          { RET_TOK( LITTLE); }
-big             { RET_TOK( BIG); }
-volatile        { RET_TOK( VOLATILE); }
-align           { RET_TOK( ALIGN);  }
-section         { RET_TOK( SECTION); }
-module          { RET_TOK( MODULE); }
-asm             { RET_TOK( ASM_TOK); }
-sideeffect      { RET_TOK( SIDEEFFECT); }
-
-cc              { RET_TOK( CC_TOK); }
-ccc             { RET_TOK( CCC_TOK); }
-csretcc         { RET_TOK( CSRETCC_TOK); }
-fastcc          { RET_TOK( FASTCC_TOK); }
-coldcc          { RET_TOK( COLDCC_TOK); }
-x86_stdcallcc   { RET_TOK( X86_STDCALLCC_TOK); }
-x86_fastcallcc  { RET_TOK( X86_FASTCALLCC_TOK); }
-
-void            { RET_TY(VOID,VoidTy,"void",false); }
-bool            { RET_TY(BOOL,BoolTy,"i1",false); }
-sbyte           { RET_TY(SBYTE,SByteTy,"i8",true); }
-ubyte           { RET_TY(UBYTE,UByteTy,"i8",false); }
-short           { RET_TY(SHORT,ShortTy,"i16",true); }
-ushort          { RET_TY(USHORT,UShortTy,"i16",false); }
-int             { RET_TY(INT,IntTy,"i32",true);   }
-uint            { RET_TY(UINT,UIntTy,"i32",false);  }
-long            { RET_TY(LONG,LongTy,"i64",true);  }
-ulong           { RET_TY(ULONG,ULongTy,"i64",false); }
-i8              { RET_TY(UBYTE,UByteTy,"i8",false); }
-i16             { RET_TY(USHORT,UShortTy,"i16",false); }
-i32             { RET_TY(UINT,UIntTy,"i32",false); }
-i64             { RET_TY(ULONG,ULongTy,"i64",false); }
-float           { RET_TY(FLOAT,FloatTy,"float",false); }
-double          { RET_TY(DOUBLE,DoubleTy,"double",false); }
-label           { RET_TY(LABEL,LabelTy,"label",false); }
-opaque          { RET_TOK(OPAQUE); }
-type            { RET_TOK(TYPE);   }
-
-add             { RET_TOK( ADD); }
-sub             { RET_TOK( SUB); }
-mul             { RET_TOK( MUL); }
-div             { RET_TOK( DIV); }
-udiv            { RET_TOK( UDIV); }
-sdiv            { RET_TOK( SDIV); }
-fdiv            { RET_TOK( FDIV); }
-rem             { RET_TOK( REM);  }
-urem            { RET_TOK( UREM); }
-srem            { RET_TOK( SREM); }
-frem            { RET_TOK( FREM); }
-and             { RET_TOK( AND); }
-or              { RET_TOK( OR); }
-xor             { RET_TOK( XOR); }
-setne           { RET_TOK( SETNE); }
-seteq           { RET_TOK( SETEQ); }
-setlt           { RET_TOK( SETLT); }
-setgt           { RET_TOK( SETGT); }
-setle           { RET_TOK( SETLE); }
-setge           { RET_TOK( SETGE); }
-icmp            { RET_TOK(ICMP); }
-fcmp            { RET_TOK(FCMP); }
-eq              { RET_TOK(EQ); }
-ne              { RET_TOK(NE); }
-slt             { RET_TOK(SLT); }
-sgt             { RET_TOK(SGT); }
-sle             { RET_TOK(SLE); }
-sge             { RET_TOK(SGE); }
-oeq             { RET_TOK(OEQ); }
-one             { RET_TOK(ONE); }
-olt             { RET_TOK(OLT); }
-ogt             { RET_TOK(OGT); }
-ole             { RET_TOK(OLE); }
-oge             { RET_TOK(OGE); }
-ord             { RET_TOK(ORD); }
-uno             { RET_TOK(UNO); }
-ueq             { RET_TOK(UEQ); }
-une             { RET_TOK(UNE); }
-ult             { RET_TOK(ULT); }
-ugt             { RET_TOK(UGT); }
-ule             { RET_TOK(ULE); }
-uge             { RET_TOK(UGE); }
-
-phi             { RET_TOK( PHI_TOK); }
-call            { RET_TOK( CALL); }
-cast            { RET_TOK( CAST); }
-trunc           { RET_TOK( TRUNC); }
-zext            { RET_TOK( ZEXT); }
-sext            { RET_TOK( SEXT); }
-fptrunc         { RET_TOK( FPTRUNC); }
-fpext           { RET_TOK( FPEXT); }
-fptoui          { RET_TOK( FPTOUI); }
-fptosi          { RET_TOK( FPTOSI); }
-uitofp          { RET_TOK( UITOFP); }
-sitofp          { RET_TOK( SITOFP); }
-ptrtoint        { RET_TOK( PTRTOINT); }
-inttoptr        { RET_TOK( INTTOPTR); }
-bitcast         { RET_TOK( BITCAST); }
-select          { RET_TOK( SELECT); }
-shl             { RET_TOK( SHL); }
-shr             { RET_TOK( SHR); }
-ashr            { RET_TOK( ASHR); }
-lshr            { RET_TOK( LSHR); }
-va_arg          { RET_TOK( VAARG); }
-ret             { RET_TOK( RET); }
-br              { RET_TOK( BR); }
-switch          { RET_TOK( SWITCH); }
-invoke          { RET_TOK( INVOKE); }
-unwind          { RET_TOK( UNWIND); }
-except          { RET_TOK( EXCEPT); } // alias for unwind
-unreachable     { RET_TOK( UNREACHABLE); }
-
-malloc          { RET_TOK( MALLOC); }
-alloca          { RET_TOK( ALLOCA); }
-free            { RET_TOK( FREE); }
-load            { RET_TOK( LOAD); }
-store           { RET_TOK( STORE); }
-getelementptr   { RET_TOK( GETELEMENTPTR); }
-
-extractelement  { RET_TOK( EXTRACTELEMENT); }
-insertelement   { RET_TOK( INSERTELEMENT); }
-shufflevector   { RET_TOK( SHUFFLEVECTOR); }
-
-
-{VarID}          { RET_TOK( VAR_ID); }
-{Label}          { RET_TOK( LABELSTR); }
-{QuoteLabel}     { RET_TOK( LABELSTR); }
-{StringConstant} { RET_TOK( STRINGCONSTANT ); }
-{PInteger}       { RET_TOK( EUINT64VAL ); }
-{NInteger}       { RET_TOK( ESINT64VAL ); }
-{HexIntConstant} { RET_TOK( yytext[0] == 's' ? ESINT64VAL : EUINT64VAL ); }
-{EPInteger}      { RET_TOK( UINTVAL); }
-{ENInteger}      { RET_TOK( SINTVAL); }
-{FPConstant}     { RET_TOK( FPVAL); }
-{HexFPConstant}  { RET_TOK( FPVAL); }
-<>          {
+begin           { return BEGINTOK; }
+end             { return ENDTOK; }
+true            { return TRUETOK;  }
+false           { return FALSETOK; }
+declare         { return DECLARE; }
+global          { return GLOBAL; }
+constant        { return CONSTANT; }
+internal        { return INTERNAL; }
+linkonce        { return LINKONCE; }
+weak            { return WEAK; }
+appending       { return APPENDING; }
+dllimport       { return DLLIMPORT; }
+dllexport       { return DLLEXPORT; }
+extern_weak     { return EXTERN_WEAK; }
+uninitialized   { return EXTERNAL; }    /* Deprecated, turn into external */
+external        { return EXTERNAL; }
+implementation  { return IMPLEMENTATION; }
+zeroinitializer { return ZEROINITIALIZER; }
+\.\.\.          { return DOTDOTDOT; }
+undef           { return UNDEF; }
+null            { return NULL_TOK; }
+to              { return TO; }
+except          { return EXCEPT; }
+not             { return NOT; }  /* Deprecated, turned into XOR */
+tail            { return TAIL; }
+target          { return TARGET; }
+triple          { return TRIPLE; }
+deplibs         { return DEPLIBS; }
+endian          { return ENDIAN; }
+pointersize     { return POINTERSIZE; }
+datalayout      { return DATALAYOUT; }
+little          { return LITTLE; }
+big             { return BIG; }
+volatile        { return VOLATILE; }
+align           { return ALIGN;  }
+section         { return SECTION; }
+module          { return MODULE; }
+asm             { return ASM_TOK; }
+sideeffect      { return SIDEEFFECT; }
+
+cc              { return CC_TOK; }
+ccc             { return CCC_TOK; }
+csretcc         { return CSRETCC_TOK; }
+fastcc          { return FASTCC_TOK; }
+coldcc          { return COLDCC_TOK; }
+x86_stdcallcc   { return X86_STDCALLCC_TOK; }
+x86_fastcallcc  { return X86_FASTCALLCC_TOK; }
+
+sbyte           { RET_TY(SBYTE,  Type::Int8Ty,  Signed);  }
+ubyte           { RET_TY(UBYTE,  Type::Int8Ty,  Unsigned); }
+short           { RET_TY(SHORT,  Type::Int16Ty, Signed);  }
+ushort          { RET_TY(USHORT, Type::Int16Ty, Unsigned); }
+int             { RET_TY(INT,    Type::Int32Ty, Signed);  }
+uint            { RET_TY(UINT,   Type::Int32Ty, Unsigned); }
+long            { RET_TY(LONG,   Type::Int64Ty, Signed);  }
+ulong           { RET_TY(ULONG,  Type::Int64Ty, Unsigned); }
+void            { RET_TY(VOID,   Type::VoidTy,  Signless  ); }
+bool            { RET_TY(BOOL,   Type::Int1Ty,  Unsigned  ); }
+float           { RET_TY(FLOAT,  Type::FloatTy, Signless ); }
+double          { RET_TY(DOUBLE, Type::DoubleTy,Signless); }
+label           { RET_TY(LABEL,  Type::LabelTy, Signless ); }
+type            { return TYPE;   }
+opaque          { return OPAQUE; }
+
+add             { RET_TOK(BinaryOpVal, AddOp, ADD); }
+sub             { RET_TOK(BinaryOpVal, SubOp, SUB); }
+mul             { RET_TOK(BinaryOpVal, MulOp, MUL); }
+div             { RET_TOK(BinaryOpVal, DivOp,  DIV); }
+udiv            { RET_TOK(BinaryOpVal, UDivOp, UDIV); }
+sdiv            { RET_TOK(BinaryOpVal, SDivOp, SDIV); }
+fdiv            { RET_TOK(BinaryOpVal, FDivOp, FDIV); }
+rem             { RET_TOK(BinaryOpVal, RemOp,  REM); }
+urem            { RET_TOK(BinaryOpVal, URemOp, UREM); }
+srem            { RET_TOK(BinaryOpVal, SRemOp, SREM); }
+frem            { RET_TOK(BinaryOpVal, FRemOp, FREM); }
+and             { RET_TOK(BinaryOpVal, AndOp, AND); }
+or              { RET_TOK(BinaryOpVal, OrOp , OR ); }
+xor             { RET_TOK(BinaryOpVal, XorOp, XOR); }
+setne           { RET_TOK(BinaryOpVal, SetNE, SETNE); }
+seteq           { RET_TOK(BinaryOpVal, SetEQ, SETEQ); }
+setlt           { RET_TOK(BinaryOpVal, SetLT, SETLT); }
+setgt           { RET_TOK(BinaryOpVal, SetGT, SETGT); }
+setle           { RET_TOK(BinaryOpVal, SetLE, SETLE); }
+setge           { RET_TOK(BinaryOpVal, SetGE, SETGE); }
+icmp            { RET_TOK(OtherOpVal, ICmpOp, ICMP); }
+fcmp            { RET_TOK(OtherOpVal, FCmpOp, FCMP); }
+
+eq              { return EQ; }
+ne              { return NE; }
+slt             { return SLT; }
+sgt             { return SGT; }
+sle             { return SLE; }
+sge             { return SGE; }
+ult             { return ULT; }
+ugt             { return UGT; }
+ule             { return ULE; }
+uge             { return UGE; }
+oeq             { return OEQ; }
+one             { return ONE; }
+olt             { return OLT; }
+ogt             { return OGT; }
+ole             { return OLE; }
+oge             { return OGE; }
+ord             { return ORD; }
+uno             { return UNO; }
+ueq             { return UEQ; }
+une             { return UNE; }
+
+phi             { RET_TOK(OtherOpVal, PHIOp, PHI_TOK); }
+call            { RET_TOK(OtherOpVal, CallOp, CALL); }
+cast            { RET_TOK(CastOpVal, CastOp, CAST);  }
+trunc           { RET_TOK(CastOpVal, TruncOp, TRUNC); }
+zext            { RET_TOK(CastOpVal, ZExtOp , ZEXT); }
+sext            { RET_TOK(CastOpVal, SExtOp, SEXT); }
+fptrunc         { RET_TOK(CastOpVal, FPTruncOp, FPTRUNC); }
+fpext           { RET_TOK(CastOpVal, FPExtOp, FPEXT); }
+fptoui          { RET_TOK(CastOpVal, FPToUIOp, FPTOUI); }
+fptosi          { RET_TOK(CastOpVal, FPToSIOp, FPTOSI); }
+uitofp          { RET_TOK(CastOpVal, UIToFPOp, UITOFP); }
+sitofp          { RET_TOK(CastOpVal, SIToFPOp, SITOFP); }
+ptrtoint        { RET_TOK(CastOpVal, PtrToIntOp, PTRTOINT); }
+inttoptr        { RET_TOK(CastOpVal, IntToPtrOp, INTTOPTR); }
+bitcast         { RET_TOK(CastOpVal, BitCastOp, BITCAST); }
+select          { RET_TOK(OtherOpVal, SelectOp, SELECT); }
+shl             { RET_TOK(OtherOpVal, ShlOp, SHL); }
+shr             { RET_TOK(OtherOpVal, ShrOp, SHR); }
+lshr            { RET_TOK(OtherOpVal, LShrOp, LSHR); }
+ashr            { RET_TOK(OtherOpVal, AShrOp, ASHR); }
+vanext          { return VANEXT_old; }
+vaarg           { return VAARG_old; }
+va_arg          { RET_TOK(OtherOpVal, VAArg , VAARG); }
+ret             { RET_TOK(TermOpVal, RetOp, RET); }
+br              { RET_TOK(TermOpVal, BrOp, BR); }
+switch          { RET_TOK(TermOpVal, SwitchOp, SWITCH); }
+invoke          { RET_TOK(TermOpVal, InvokeOp, INVOKE); }
+unwind          { return UNWIND; }
+unreachable     { RET_TOK(TermOpVal, UnreachableOp, UNREACHABLE); }
+
+malloc          { RET_TOK(MemOpVal, MallocOp, MALLOC); }
+alloca          { RET_TOK(MemOpVal, AllocaOp, ALLOCA); }
+free            { RET_TOK(MemOpVal, FreeOp, FREE); }
+load            { RET_TOK(MemOpVal, LoadOp, LOAD); }
+store           { RET_TOK(MemOpVal, StoreOp, STORE); }
+getelementptr   { RET_TOK(MemOpVal, GetElementPtrOp, GETELEMENTPTR); }
+
+extractelement  { RET_TOK(OtherOpVal, ExtractElementOp, EXTRACTELEMENT); }
+insertelement   { RET_TOK(OtherOpVal, InsertElementOp, INSERTELEMENT); }
+shufflevector   { RET_TOK(OtherOpVal, ShuffleVectorOp, SHUFFLEVECTOR); }
+
+
+{VarID}         {
+                  UnEscapeLexed(yytext+1);
+                  Upgradelval.StrVal = strdup(yytext+1);             // Skip %
+                  return VAR_ID;
+                }
+{Label}         {
+                  yytext[strlen(yytext)-1] = 0;  // nuke colon
+                  UnEscapeLexed(yytext);
+                  Upgradelval.StrVal = strdup(yytext);
+                  return LABELSTR;
+                }
+{QuoteLabel}    {
+                  yytext[strlen(yytext)-2] = 0;  // nuke colon, end quote
+                  UnEscapeLexed(yytext+1);
+                  Upgradelval.StrVal = strdup(yytext+1);
+                  return LABELSTR;
+                }
+
+{StringConstant} { // Note that we cannot unescape a string constant here!  The
+                   // string constant might contain a \00 which would not be
+                   // understood by the string stuff.  It is valid to make a
+                   // [sbyte] c"Hello World\00" constant, for example.
+                   //
+                   yytext[strlen(yytext)-1] = 0;           // nuke end quote
+                   Upgradelval.StrVal = strdup(yytext+1);  // Nuke start quote
+                   return STRINGCONSTANT;
+                 }
+
+
+{PInteger}      { Upgradelval.UInt64Val = atoull(yytext); return EUINT64VAL; }
+{NInteger}      {
+                  uint64_t Val = atoull(yytext+1);
+                  // +1:  we have bigger negative range
+                  if (Val > (uint64_t)INT64_MAX+1)
+                    error("Constant too large for signed 64 bits!");
+                  Upgradelval.SInt64Val = -Val;
+                  return ESINT64VAL;
+                }
+{HexIntConstant} {
+                   Upgradelval.UInt64Val = HexIntToVal(yytext+3);
+                   return yytext[0] == 's' ? ESINT64VAL : EUINT64VAL;
+                 }
+
+{EPInteger}     {
+                  uint64_t Val = atoull(yytext+1);
+                  if ((unsigned)Val != Val)
+                    error("Invalid value number (too large)!");
+                  Upgradelval.UIntVal = unsigned(Val);
+                  return UINTVAL;
+                }
+{ENInteger}     {
+                  uint64_t Val = atoull(yytext+2);
+                  // +1:  we have bigger negative range
+                  if (Val > (uint64_t)INT32_MAX+1)
+                    error("Constant too large for signed 32 bits!");
+                  Upgradelval.SIntVal = (int)-Val;
+                  return SINTVAL;
+                }
+
+{FPConstant}    { Upgradelval.FPVal = atof(yytext); return FPVAL; }
+{HexFPConstant} { Upgradelval.FPVal = HexToFP(yytext); return FPVAL; }
+
+<>         {
                   /* Make sure to free the internal buffers for flex when we are
                    * done reading our input!
                    */


Index: llvm/tools/llvm-upgrade/UpgradeParser.cpp.cvs
diff -u llvm/tools/llvm-upgrade/UpgradeParser.cpp.cvs:1.44 llvm/tools/llvm-upgrade/UpgradeParser.cpp.cvs:1.45
--- llvm/tools/llvm-upgrade/UpgradeParser.cpp.cvs:1.44	Sun Jan 21 13:30:52 2007
+++ llvm/tools/llvm-upgrade/UpgradeParser.cpp.cvs	Fri Jan 26 02:19:09 2007
@@ -1,7 +1,7 @@
-/* A Bison parser, made from /usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y, by GNU bison 1.75.  */
+/* A Bison parser, made by GNU Bison 2.1.  */
 
 /* Skeleton parser for Yacc-like parsing with Bison,
-   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software Foundation, Inc.
+   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -15,8 +15,8 @@
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
+   Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.  */
 
 /* As a special exception, when this file is copied by Bison into a
    Bison output file, you may use that output file without restriction.
@@ -34,16 +34,21 @@
    USER NAME SPACE" below.  */
 
 /* Identify Bison output.  */
-#define YYBISON	1
+#define YYBISON 1
+
+/* Bison version.  */
+#define YYBISON_VERSION "2.1"
+
+/* Skeleton name.  */
+#define YYSKELETON_NAME "yacc.c"
 
 /* Pure parsers.  */
-#define YYPURE	0
+#define YYPURE 0
 
 /* Using locations.  */
 #define YYLSP_NEEDED 0
 
-/* If NAME_PREFIX is specified substitute the variables and functions
-   names.  */
+/* Substitute the variable and function names.  */
 #define yyparse Upgradeparse
 #define yylex   Upgradelex
 #define yyerror Upgradeerror
@@ -59,61 +64,61 @@
    /* Put the tokens into the symbol table, so that GDB and other debuggers
       know about them.  */
    enum yytokentype {
-     VOID = 258,
-     BOOL = 259,
-     SBYTE = 260,
-     UBYTE = 261,
-     SHORT = 262,
-     USHORT = 263,
-     INT = 264,
-     UINT = 265,
-     LONG = 266,
-     ULONG = 267,
-     FLOAT = 268,
-     DOUBLE = 269,
-     LABEL = 270,
-     OPAQUE = 271,
-     ESINT64VAL = 272,
-     EUINT64VAL = 273,
-     SINTVAL = 274,
-     UINTVAL = 275,
-     FPVAL = 276,
-     NULL_TOK = 277,
-     UNDEF = 278,
-     ZEROINITIALIZER = 279,
-     TRUETOK = 280,
-     FALSETOK = 281,
-     TYPE = 282,
-     VAR_ID = 283,
-     LABELSTR = 284,
-     STRINGCONSTANT = 285,
-     IMPLEMENTATION = 286,
-     BEGINTOK = 287,
-     ENDTOK = 288,
-     DECLARE = 289,
-     GLOBAL = 290,
-     CONSTANT = 291,
-     SECTION = 292,
-     VOLATILE = 293,
-     TO = 294,
-     DOTDOTDOT = 295,
-     CONST = 296,
-     INTERNAL = 297,
-     LINKONCE = 298,
-     WEAK = 299,
+     ESINT64VAL = 258,
+     EUINT64VAL = 259,
+     SINTVAL = 260,
+     UINTVAL = 261,
+     FPVAL = 262,
+     VOID = 263,
+     BOOL = 264,
+     SBYTE = 265,
+     UBYTE = 266,
+     SHORT = 267,
+     USHORT = 268,
+     INT = 269,
+     UINT = 270,
+     LONG = 271,
+     ULONG = 272,
+     FLOAT = 273,
+     DOUBLE = 274,
+     TYPE = 275,
+     LABEL = 276,
+     VAR_ID = 277,
+     LABELSTR = 278,
+     STRINGCONSTANT = 279,
+     IMPLEMENTATION = 280,
+     ZEROINITIALIZER = 281,
+     TRUETOK = 282,
+     FALSETOK = 283,
+     BEGINTOK = 284,
+     ENDTOK = 285,
+     DECLARE = 286,
+     GLOBAL = 287,
+     CONSTANT = 288,
+     SECTION = 289,
+     VOLATILE = 290,
+     TO = 291,
+     DOTDOTDOT = 292,
+     NULL_TOK = 293,
+     UNDEF = 294,
+     CONST = 295,
+     INTERNAL = 296,
+     LINKONCE = 297,
+     WEAK = 298,
+     APPENDING = 299,
      DLLIMPORT = 300,
      DLLEXPORT = 301,
      EXTERN_WEAK = 302,
-     APPENDING = 303,
-     EXTERNAL = 304,
-     TARGET = 305,
-     TRIPLE = 306,
-     ENDIAN = 307,
-     POINTERSIZE = 308,
-     LITTLE = 309,
-     BIG = 310,
-     ALIGN = 311,
-     UNINITIALIZED = 312,
+     OPAQUE = 303,
+     NOT = 304,
+     EXTERNAL = 305,
+     TARGET = 306,
+     TRIPLE = 307,
+     ENDIAN = 308,
+     POINTERSIZE = 309,
+     LITTLE = 310,
+     BIG = 311,
+     ALIGN = 312,
      DEPLIBS = 313,
      CALL = 314,
      TAIL = 315,
@@ -132,9 +137,9 @@
      BR = 328,
      SWITCH = 329,
      INVOKE = 330,
-     EXCEPT = 331,
+     UNREACHABLE = 331,
      UNWIND = 332,
-     UNREACHABLE = 333,
+     EXCEPT = 333,
      ADD = 334,
      SUB = 335,
      MUL = 336,
@@ -157,112 +162,115 @@
      SETNE = 353,
      ICMP = 354,
      FCMP = 355,
-     EQ = 356,
-     NE = 357,
-     SLT = 358,
-     SGT = 359,
-     SLE = 360,
-     SGE = 361,
-     OEQ = 362,
-     ONE = 363,
-     OLT = 364,
-     OGT = 365,
-     OLE = 366,
-     OGE = 367,
-     ORD = 368,
-     UNO = 369,
-     UEQ = 370,
-     UNE = 371,
-     ULT = 372,
-     UGT = 373,
-     ULE = 374,
-     UGE = 375,
-     MALLOC = 376,
-     ALLOCA = 377,
-     FREE = 378,
-     LOAD = 379,
-     STORE = 380,
-     GETELEMENTPTR = 381,
-     PHI_TOK = 382,
-     SELECT = 383,
-     SHL = 384,
-     SHR = 385,
-     ASHR = 386,
-     LSHR = 387,
-     VAARG = 388,
-     EXTRACTELEMENT = 389,
-     INSERTELEMENT = 390,
-     SHUFFLEVECTOR = 391,
-     CAST = 392,
-     TRUNC = 393,
-     ZEXT = 394,
-     SEXT = 395,
-     FPTRUNC = 396,
-     FPEXT = 397,
-     FPTOUI = 398,
-     FPTOSI = 399,
-     UITOFP = 400,
-     SITOFP = 401,
-     PTRTOINT = 402,
-     INTTOPTR = 403,
-     BITCAST = 404
+     MALLOC = 356,
+     ALLOCA = 357,
+     FREE = 358,
+     LOAD = 359,
+     STORE = 360,
+     GETELEMENTPTR = 361,
+     PHI_TOK = 362,
+     SELECT = 363,
+     SHL = 364,
+     SHR = 365,
+     ASHR = 366,
+     LSHR = 367,
+     VAARG = 368,
+     EXTRACTELEMENT = 369,
+     INSERTELEMENT = 370,
+     SHUFFLEVECTOR = 371,
+     VAARG_old = 372,
+     VANEXT_old = 373,
+     EQ = 374,
+     NE = 375,
+     SLT = 376,
+     SGT = 377,
+     SLE = 378,
+     SGE = 379,
+     ULT = 380,
+     UGT = 381,
+     ULE = 382,
+     UGE = 383,
+     OEQ = 384,
+     ONE = 385,
+     OLT = 386,
+     OGT = 387,
+     OLE = 388,
+     OGE = 389,
+     ORD = 390,
+     UNO = 391,
+     UEQ = 392,
+     UNE = 393,
+     CAST = 394,
+     TRUNC = 395,
+     ZEXT = 396,
+     SEXT = 397,
+     FPTRUNC = 398,
+     FPEXT = 399,
+     FPTOUI = 400,
+     FPTOSI = 401,
+     UITOFP = 402,
+     SITOFP = 403,
+     PTRTOINT = 404,
+     INTTOPTR = 405,
+     BITCAST = 406
    };
 #endif
-#define VOID 258
-#define BOOL 259
-#define SBYTE 260
-#define UBYTE 261
-#define SHORT 262
-#define USHORT 263
-#define INT 264
-#define UINT 265
-#define LONG 266
-#define ULONG 267
-#define FLOAT 268
-#define DOUBLE 269
-#define LABEL 270
-#define OPAQUE 271
-#define ESINT64VAL 272
-#define EUINT64VAL 273
-#define SINTVAL 274
-#define UINTVAL 275
-#define FPVAL 276
-#define NULL_TOK 277
-#define UNDEF 278
-#define ZEROINITIALIZER 279
-#define TRUETOK 280
-#define FALSETOK 281
-#define TYPE 282
-#define VAR_ID 283
-#define LABELSTR 284
-#define STRINGCONSTANT 285
-#define IMPLEMENTATION 286
-#define BEGINTOK 287
-#define ENDTOK 288
-#define DECLARE 289
-#define GLOBAL 290
-#define CONSTANT 291
-#define SECTION 292
-#define VOLATILE 293
-#define TO 294
-#define DOTDOTDOT 295
-#define CONST 296
-#define INTERNAL 297
-#define LINKONCE 298
-#define WEAK 299
+/* Tokens.  */
+#define ESINT64VAL 258
+#define EUINT64VAL 259
+#define SINTVAL 260
+#define UINTVAL 261
+#define FPVAL 262
+#define VOID 263
+#define BOOL 264
+#define SBYTE 265
+#define UBYTE 266
+#define SHORT 267
+#define USHORT 268
+#define INT 269
+#define UINT 270
+#define LONG 271
+#define ULONG 272
+#define FLOAT 273
+#define DOUBLE 274
+#define TYPE 275
+#define LABEL 276
+#define VAR_ID 277
+#define LABELSTR 278
+#define STRINGCONSTANT 279
+#define IMPLEMENTATION 280
+#define ZEROINITIALIZER 281
+#define TRUETOK 282
+#define FALSETOK 283
+#define BEGINTOK 284
+#define ENDTOK 285
+#define DECLARE 286
+#define GLOBAL 287
+#define CONSTANT 288
+#define SECTION 289
+#define VOLATILE 290
+#define TO 291
+#define DOTDOTDOT 292
+#define NULL_TOK 293
+#define UNDEF 294
+#define CONST 295
+#define INTERNAL 296
+#define LINKONCE 297
+#define WEAK 298
+#define APPENDING 299
 #define DLLIMPORT 300
 #define DLLEXPORT 301
 #define EXTERN_WEAK 302
-#define APPENDING 303
-#define EXTERNAL 304
-#define TARGET 305
-#define TRIPLE 306
-#define ENDIAN 307
-#define POINTERSIZE 308
-#define LITTLE 309
-#define BIG 310
-#define ALIGN 311
-#define UNINITIALIZED 312
+#define OPAQUE 303
+#define NOT 304
+#define EXTERNAL 305
+#define TARGET 306
+#define TRIPLE 307
+#define ENDIAN 308
+#define POINTERSIZE 309
+#define LITTLE 310
+#define BIG 311
+#define ALIGN 312
 #define DEPLIBS 313
 #define CALL 314
 #define TAIL 315
@@ -281,9 +289,9 @@
 #define BR 328
 #define SWITCH 329
 #define INVOKE 330
-#define EXCEPT 331
+#define UNREACHABLE 331
 #define UNWIND 332
-#define UNREACHABLE 333
+#define EXCEPT 333
 #define ADD 334
 #define SUB 335
 #define MUL 336
@@ -306,1013 +314,1515 @@
 #define SETNE 353
 #define ICMP 354
 #define FCMP 355
-#define EQ 356
-#define NE 357
-#define SLT 358
-#define SGT 359
-#define SLE 360
-#define SGE 361
-#define OEQ 362
-#define ONE 363
-#define OLT 364
-#define OGT 365
-#define OLE 366
-#define OGE 367
-#define ORD 368
-#define UNO 369
-#define UEQ 370
-#define UNE 371
-#define ULT 372
-#define UGT 373
-#define ULE 374
-#define UGE 375
-#define MALLOC 376
-#define ALLOCA 377
-#define FREE 378
-#define LOAD 379
-#define STORE 380
-#define GETELEMENTPTR 381
-#define PHI_TOK 382
-#define SELECT 383
-#define SHL 384
-#define SHR 385
-#define ASHR 386
-#define LSHR 387
-#define VAARG 388
-#define EXTRACTELEMENT 389
-#define INSERTELEMENT 390
-#define SHUFFLEVECTOR 391
-#define CAST 392
-#define TRUNC 393
-#define ZEXT 394
-#define SEXT 395
-#define FPTRUNC 396
-#define FPEXT 397
-#define FPTOUI 398
-#define FPTOSI 399
-#define UITOFP 400
-#define SITOFP 401
-#define PTRTOINT 402
-#define INTTOPTR 403
-#define BITCAST 404
+#define MALLOC 356
+#define ALLOCA 357
+#define FREE 358
+#define LOAD 359
+#define STORE 360
+#define GETELEMENTPTR 361
+#define PHI_TOK 362
+#define SELECT 363
+#define SHL 364
+#define SHR 365
+#define ASHR 366
+#define LSHR 367
+#define VAARG 368
+#define EXTRACTELEMENT 369
+#define INSERTELEMENT 370
+#define SHUFFLEVECTOR 371
+#define VAARG_old 372
+#define VANEXT_old 373
+#define EQ 374
+#define NE 375
+#define SLT 376
+#define SGT 377
+#define SLE 378
+#define SGE 379
+#define ULT 380
+#define UGT 381
+#define ULE 382
+#define UGE 383
+#define OEQ 384
+#define ONE 385
+#define OLT 386
+#define OGT 387
+#define OLE 388
+#define OGE 389
+#define ORD 390
+#define UNO 391
+#define UEQ 392
+#define UNE 393
+#define CAST 394
+#define TRUNC 395
+#define ZEXT 396
+#define SEXT 397
+#define FPTRUNC 398
+#define FPEXT 399
+#define FPTOUI 400
+#define FPTOSI 401
+#define UITOFP 402
+#define SITOFP 403
+#define PTRTOINT 404
+#define INTTOPTR 405
+#define BITCAST 406
 
 
 
 
 /* Copy the first part of user declarations.  */
-#line 14 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 14 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
 
 #include "UpgradeInternals.h"
+#include "llvm/CallingConv.h"
+#include "llvm/InlineAsm.h"
+#include "llvm/Instructions.h"
+#include "llvm/Module.h"
+#include "llvm/SymbolTable.h"
+#include "llvm/Support/GetElementPtrTypeIterator.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/Support/MathExtras.h"
 #include 
-#include 
-#include 
 #include 
+#include 
+#include 
+
+// DEBUG_UPREFS - Define this symbol if you want to enable debugging output
+// relating to upreferences in the input stream.
+//
+//#define DEBUG_UPREFS 1
+#ifdef DEBUG_UPREFS
+#define UR_OUT(X) std::cerr << X
+#else
+#define UR_OUT(X)
+#endif
 
 #define YYERROR_VERBOSE 1
 #define YYINCLUDED_STDLIB_H
 #define YYDEBUG 1
 
-int yylex();                       // declaration" of xxx warnings.
+int yylex();
 int yyparse();
-extern int yydebug;
 
-static std::string CurFilename;
-static std::ostream *O = 0;
-std::istream* LexInput = 0;
-unsigned SizeOfPointer = 32;
+int yyerror(const char*);
+static void warning(const std::string& WarningMsg);
 
+namespace llvm {
 
-// This bool controls whether attributes are ever added to function declarations
-// definitions and calls.
-static bool AddAttributes = false;
 
-static void warning(const std::string& msg);
+SignedType *SignedType::SByteTy = 0;
+SignedType *SignedType::SShortTy = 0;
+SignedType *SignedType::SIntTy = 0;
+SignedType *SignedType::SLongTy = 0;
+
+inline bool SignedType::classof(const Type *T) {
+  if (T->getTypeID() != IntegerTyID)
+    return false;
+  return (T == SByteTy || T == SShortTy || T == SIntTy || T == SLongTy );
+}
 
-void UpgradeAssembly(const std::string &infile, std::istream& in, 
-                     std::ostream &out, bool debug, bool addAttrs)
+SignedType::SignedType(const IntegerType* ITy) 
+  : IntegerType(ITy->getBitWidth()), base_type(ITy)
 {
-  Upgradelineno = 1; 
-  CurFilename = infile;
-  LexInput = ∈
-  yydebug = debug;
-  AddAttributes = addAttrs;
-  O = &out;
+}
 
-  if (yyparse()) {
-    std::cerr << "llvm-upgrade: parse failed.\n";
-    out << "llvm-upgrade: parse failed.\n";
-    exit(1);
-  }
+const SignedType *SignedType::get(const IntegerType* ITy) {
+  if (ITy == Type::Int8Ty) {
+    if (!SByteTy)
+      SByteTy = new SignedType(IntegerType::get(8));
+    return SByteTy;
+  } else if (ITy == Type::Int16Ty) {
+    if (!SShortTy)
+      SShortTy = new SignedType(IntegerType::get(16));
+    return SShortTy;
+  } else if (ITy == Type::Int32Ty) {
+    if (!SIntTy)
+      SIntTy = new SignedType(IntegerType::get(32));
+    return SIntTy;
+  } else if (ITy == Type::Int64Ty) {
+    if (!SLongTy)
+      SLongTy = new SignedType(IntegerType::get(64));
+    return SLongTy;
+  } else
+    assert(0 && "Invalid integer type for SignedType::get");
 }
 
-namespace { // Anonymous namespace to keep our implementation local
+static inline Signedness getSign(const Type *&Ty) {
+  if (const SignedType *STy = dyn_cast(Ty)) {
+    Ty = STy->getBaseType();
+    return Signed;
+  } else if (isa(Ty))
+    return Unsigned;
+  return Signless;
+}
 
+static const Type*
+resolveTypeImpl(const Type* Ty, std::vector& TyStack)
+{
+  // Nothing to resolve if it isn't a derived type
+  if (!Ty->isDerivedType())
+    return Ty;
+
+  // Prevent infinite recursion for recursive types
+  for (std::vector::const_iterator I = TyStack.begin(), 
+       E = TyStack.end(); I != E; ++I)
+    if (Ty == *I)
+      return Ty;
+
+  // Okay, haven't seen this derived type yet, push it on the stack.
+  const Type* Result = Ty;
+  TyStack.push_back(Ty);
+
+  // Process the type
+  switch (Ty->getTypeID()) {
+    default: assert(0 && "Invalid derived type");
+    case Type::IntegerTyID:
+      break;
+    case Type::FunctionTyID: {
+      const FunctionType* FTy = cast(Ty);
+      const Type* RetTy = resolveTypeImpl(FTy->getReturnType(), TyStack);
+      std::vector Types;
+      FunctionType::ParamAttrsList Attrs;
+      Attrs.push_back(FTy->getParamAttrs(0));
+      for (unsigned i = 0; i < FTy->getNumParams(); ++i) {
+        Types.push_back(resolveTypeImpl(FTy->getParamType(i), TyStack));
+        Attrs.push_back(FTy->getParamAttrs(i+1));
+      }
+      Result = FunctionType::get(RetTy, Types, FTy->isVarArg(), Attrs);
+      break;
+    }
+    case Type::StructTyID:
+    case Type::PackedStructTyID: {
+      const StructType *STy = cast(Ty);
+      std::vector FieldTypes;
+      for (unsigned i = 0; i < STy->getNumElements(); ++i)
+        FieldTypes.push_back(resolveTypeImpl(STy->getElementType(i), TyStack));
+      Result = StructType::get(FieldTypes, STy->isPacked());
+      break;
+    }
+    case Type::ArrayTyID: {
+      const ArrayType *ATy = cast(Ty);
+      uint64_t NElems = ATy->getNumElements();
+      const Type *ElemTy = resolveTypeImpl(ATy->getElementType(), TyStack);
+      Result = ArrayType::get(ElemTy, NElems);
+      break;
+    }
+    case Type::PointerTyID: {
+      const PointerType *PTy = cast(Ty);
+      const Type *ElemTy = resolveTypeImpl(PTy->getElementType(), TyStack);
+      Result = PointerType::get(ElemTy);
+      break;
+    }
+    case Type::PackedTyID: {
+      const PackedType *PTy = cast(Ty);
+      unsigned NElems = PTy->getNumElements();
+      const Type *ElemTy = resolveTypeImpl(PTy->getElementType(), TyStack);
+      Result = PackedType::get(ElemTy, NElems);
+      break;
+    }
+  }
+  // Done with it, pop it off.
+  TyStack.pop_back();
+  return Result;
+}
 
-/// This type is used to keep track of the signedness of values. Instead
-/// of creating llvm::Value directly, the parser will create Value which
-/// associates a Value* with a Signedness indication.
-struct Value {
-  std::string* val;
-  const Type* type;
-  bool constant;
-  bool isConstant() const { return constant; }
-  ~Value() { delete val; }
-};
+static inline const Type* resolveType(const Type* Ty) {
+  if (!Ty)
+    return 0;
+  if (const SignedType* STy = dyn_cast(Ty))
+    return STy->getBaseType();
+  std::vector TyStack;
+  return resolveTypeImpl(Ty, TyStack);
+}
 
+std::istream* LexInput;
+static std::string CurFilename;
 
-/// This type is used to keep track of the signedness of the obsolete
-/// integer types. Instead of creating an llvm::Type directly, the Lexer will
-/// create instances of Type which retains the signedness indication so
-/// it can be used by the parser for upgrade decisions.
-/// For example if "uint" is encountered then the "first" field will be set 
-/// to "int32" and the "second" field will be set to "isUnsigned".  If the 
-/// type is not obsolete then "second" will be set to "isSignless".
-class Type {
-public:
-  static const Type* get(const std::string &newType, TypeIDs oldType);
-  static const Type* get(const std::string& newType, TypeIDs oldType, 
-                             const Type* eTy, const Type* rTy);
-
-  static const Type* get(const std::string& newType, TypeIDs oldType, 
-                             const Type *eTy, uint64_t elems);
-
-  static const Type* get(const std::string& newType, TypeIDs oldType, 
-                             TypeList* TL);
+// This bool controls whether attributes are ever added to function declarations
+// definitions and calls.
+static bool AddAttributes = false;
 
-  static const Type* get(const std::string& newType, const Type* resTy, 
-                             TypeList* TL);
+static Module *ParserResult;
+static bool ObsoleteVarArgs;
+static bool NewVarArgs;
+static BasicBlock *CurBB;
+static GlobalVariable *CurGV;
 
-  const Type* resolve() const;
-  bool operator<(const Type& that) const;
 
-  bool sameNewTyAs(const Type* that) const {
-    return this->newTy == that->newTy;
-  }
 
-  bool sameOldTyAs(const Type* that) const;
+// This contains info used when building the body of a function.  It is
+// destroyed when the function is completed.
+//
+typedef std::vector ValueList;           // Numbered defs
+
+typedef std::pair RenameMapKey;
+typedef std::map RenameMapType;
+
+static void 
+ResolveDefinitions(std::map &LateResolvers,
+                   std::map *FutureLateResolvers = 0);
+
+static struct PerModuleInfo {
+  Module *CurrentModule;
+  std::map Values; // Module level numbered definitions
+  std::map LateResolveValues;
+  std::vector    Types;
+  std::map LateResolveTypes;
+  static Module::Endianness Endian;
+  static Module::PointerSize PointerSize;
+  RenameMapType RenameMap;
+
+  /// PlaceHolderInfo - When temporary placeholder objects are created, remember
+  /// how they were referenced and on which line of the input they came from so
+  /// that we can resolve them later and print error messages as appropriate.
+  std::map > PlaceHolderInfo;
+
+  // GlobalRefs - This maintains a mapping between 's and forward
+  // references to global values.  Global values may be referenced before they
+  // are defined, and if so, the temporary object that they represent is held
+  // here.  This is used for forward references of GlobalValues.
+  //
+  typedef std::map, GlobalValue*> 
+    GlobalRefsType;
+  GlobalRefsType GlobalRefs;
+
+  void ModuleDone() {
+    // If we could not resolve some functions at function compilation time
+    // (calls to functions before they are defined), resolve them now...  Types
+    // are resolved when the constant pool has been completely parsed.
+    //
+    ResolveDefinitions(LateResolveValues);
+
+    // Check to make sure that all global value forward references have been
+    // resolved!
+    //
+    if (!GlobalRefs.empty()) {
+      std::string UndefinedReferences = "Unresolved global references exist:\n";
+
+      for (GlobalRefsType::iterator I = GlobalRefs.begin(), E =GlobalRefs.end();
+           I != E; ++I) {
+        UndefinedReferences += "  " + I->first.first->getDescription() + " " +
+                               I->first.second.getName() + "\n";
+      }
+      error(UndefinedReferences);
+      return;
+    }
 
-  TypeIDs getElementTy() const {
-    if (elemTy) {
-      return elemTy->oldTy;
+    if (CurrentModule->getDataLayout().empty()) {
+      std::string dataLayout;
+      if (Endian != Module::AnyEndianness)
+        dataLayout.append(Endian == Module::BigEndian ? "E" : "e");
+      if (PointerSize != Module::AnyPointerSize) {
+        if (!dataLayout.empty())
+          dataLayout += "-";
+        dataLayout.append(PointerSize == Module::Pointer64 ? 
+                          "p:64:64" : "p:32:32");
+      }
+      CurrentModule->setDataLayout(dataLayout);
     }
-    return UnresolvedTy;
+
+    Values.clear();         // Clear out function local definitions
+    Types.clear();
+    CurrentModule = 0;
+  }
+
+  // GetForwardRefForGlobal - Check to see if there is a forward reference
+  // for this global.  If so, remove it from the GlobalRefs map and return it.
+  // If not, just return null.
+  GlobalValue *GetForwardRefForGlobal(const PointerType *PTy, ValID ID) {
+    // Check to see if there is a forward reference to this global variable...
+    // if there is, eliminate it and patch the reference to use the new def'n.
+    GlobalRefsType::iterator I = GlobalRefs.find(std::make_pair(PTy, ID));
+    GlobalValue *Ret = 0;
+    if (I != GlobalRefs.end()) {
+      Ret = I->second;
+      GlobalRefs.erase(I);
+    }
+    return Ret;
+  }
+  void setEndianness(Module::Endianness E) { Endian = E; }
+  void setPointerSize(Module::PointerSize sz) { PointerSize = sz; }
+} CurModule;
+
+Module::Endianness  PerModuleInfo::Endian = Module::AnyEndianness;
+Module::PointerSize PerModuleInfo::PointerSize = Module::AnyPointerSize;
+
+static struct PerFunctionInfo {
+  Function *CurrentFunction;     // Pointer to current function being created
+
+  std::map Values; // Keep track of #'d definitions
+  std::map LateResolveValues;
+  bool isDeclare;                   // Is this function a forward declararation?
+  GlobalValue::LinkageTypes Linkage;// Linkage for forward declaration.
+
+  /// BBForwardRefs - When we see forward references to basic blocks, keep
+  /// track of them here.
+  std::map > BBForwardRefs;
+  std::vector NumberedBlocks;
+  RenameMapType RenameMap;
+  std::set SignedValues;
+  unsigned NextBBNum;
+
+  inline PerFunctionInfo() {
+    CurrentFunction = 0;
+    isDeclare = false;
+    Linkage = GlobalValue::ExternalLinkage;    
   }
 
-  unsigned getUpRefNum() const {
-    assert(oldTy == UpRefTy && "Can't getUpRefNum on non upreference");
-    return atoi(&((getNewTy().c_str())[1])); // skip the slash
+  inline void FunctionStart(Function *M) {
+    CurrentFunction = M;
+    NextBBNum = 0;
   }
 
-  typedef std::vector UpRefStack;
-  void getSignedness(unsigned &sNum, unsigned &uNum, UpRefStack& stk) const;
-  std::string makeUniqueName(const std::string& BaseName) const;
-
-  const std::string& getNewTy() const { return newTy; }
-  const Type* getResultType() const { return resultTy; }
-  const Type* getElementType() const { return elemTy; }
+  void FunctionDone() {
+    NumberedBlocks.clear();
 
-  const Type* getPointerType() const {
-    return get(newTy + "*", PointerTy, this, (Type*)0);
-  }
+    // Any forward referenced blocks left?
+    if (!BBForwardRefs.empty()) {
+      error("Undefined reference to label " + 
+            BBForwardRefs.begin()->first->getName());
+      return;
+    }
 
-  bool isUnresolved() const { return oldTy == UnresolvedTy; }
-  bool isUpReference() const { return oldTy == UpRefTy; }
-  bool isVoid() const { return oldTy == VoidTy; }
-  bool isBool() const { return oldTy == BoolTy; }
-  bool isSigned() const {
-    return oldTy == SByteTy || oldTy == ShortTy || 
-           oldTy == IntTy || oldTy == LongTy;
-  }
+    // Resolve all forward references now.
+    ResolveDefinitions(LateResolveValues, &CurModule.LateResolveValues);
 
-  bool isUnsigned() const {
-    return oldTy == UByteTy || oldTy == UShortTy || 
-           oldTy == UIntTy || oldTy == ULongTy;
-  }
-  bool isSignless() const { return !isSigned() && !isUnsigned(); }
-  bool isInteger() const { return isSigned() || isUnsigned(); }
-  bool isIntegral() const { return oldTy == BoolTy || isInteger(); }
-  bool isFloatingPoint() const { return oldTy == DoubleTy || oldTy == FloatTy; }
-  bool isPacked() const { return oldTy == PackedTy; }
-  bool isPointer() const { return oldTy == PointerTy; }
-  bool isStruct() const { return oldTy == StructTy || oldTy == PackedStructTy; }
-  bool isArray() const { return oldTy == ArrayTy; }
-  bool isOther() const { 
-    return !isPacked() && !isPointer() && !isFloatingPoint() && !isIntegral(); }
-  bool isFunction() const { return oldTy == FunctionTy; }
-  bool isComposite() const {
-    return isStruct() || isPointer() || isArray() || isPacked();
+    Values.clear();         // Clear out function local definitions
+    RenameMap.clear();
+    SignedValues.clear();
+    CurrentFunction = 0;
+    isDeclare = false;
+    Linkage = GlobalValue::ExternalLinkage;
   }
+} CurFun;  // Info for the current function...
 
-  bool isAttributeCandidate() const {
-    return isIntegral() && getBitWidth() < 32;
-  }
+static bool inFunctionScope() { return CurFun.CurrentFunction != 0; }
 
-  bool isUnresolvedDeep() const;
 
-  unsigned getBitWidth() const;
+//===----------------------------------------------------------------------===//
+//               Code to handle definitions of all the types
+//===----------------------------------------------------------------------===//
 
-  const Type* getIndexedType(const Value*  V) const;
+static int InsertValue(Value *V,
+                  std::map &ValueTab = CurFun.Values) {
+  if (V->hasName()) return -1;           // Is this a numbered definition?
 
-  unsigned getNumStructElements() const { 
-    return (elements ? elements->size() : 0);
-  }
+  // Yes, insert the value into the value table...
+  ValueList &List = ValueTab[V->getType()];
+  List.push_back(V);
+  return List.size()-1;
+}
 
-  const Type* getElement(unsigned idx) const {
-    if (elements)
-      if (idx < elements->size())
-        return (*elements)[idx];
+static const Type *getTypeVal(const ValID &D, bool DoNotImprovise = false) {
+  switch (D.Type) {
+  case ValID::NumberVal:               // Is it a numbered definition?
+    // Module constants occupy the lowest numbered slots...
+    if ((unsigned)D.Num < CurModule.Types.size()) {
+      return CurModule.Types[(unsigned)D.Num];
+    }
+    break;
+  case ValID::NameVal:                 // Is it a named definition?
+    if (const Type *N = CurModule.CurrentModule->getTypeByName(D.Name)) {
+      D.destroy();  // Free old strdup'd memory...
+      return N;
+    }
+    break;
+  default:
+    error("Internal parser error: Invalid symbol type reference");
     return 0;
   }
 
-private:
-  Type() 
-    : newTy(), oldTy(UnresolvedTy), elemTy(0), resultTy(0), elements(0),
-      nelems(0) {
-  }
+  // If we reached here, we referenced either a symbol that we don't know about
+  // or an id number that hasn't been read yet.  We may be referencing something
+  // forward, so just create an entry to be resolved later and get to it...
+  //
+  if (DoNotImprovise) return 0;  // Do we just want a null to be returned?
 
-  Type(const Type& that); // do not implement
-  Type& operator=(const Type& that); // do not implement
 
-  ~Type() { delete elements; }
+  if (inFunctionScope()) {
+    if (D.Type == ValID::NameVal) {
+      error("Reference to an undefined type: '" + D.getName() + "'");
+      return 0;
+    } else {
+      error("Reference to an undefined type: #" + itostr(D.Num));
+      return 0;
+    }
+  }
 
-  struct ltfunctor
-  {
-    bool operator()(const Type* X, const Type* Y) const {
-      assert(X && "Can't compare null pointer");
-      assert(Y && "Can't compare null pointer");
-      return *X < *Y;
+  std::map::iterator I =CurModule.LateResolveTypes.find(D);
+  if (I != CurModule.LateResolveTypes.end())
+    return I->second;
+
+  Type *Typ = OpaqueType::get();
+  CurModule.LateResolveTypes.insert(std::make_pair(D, Typ));
+  return Typ;
+ }
+
+// getExistingValue - Look up the value specified by the provided type and
+// the provided ValID.  If the value exists and has already been defined, return
+// it.  Otherwise return null.
+//
+static Value *getExistingValue(const Type *Ty, const ValID &D) {
+  if (isa(Ty)) {
+    error("Functions are not values and must be referenced as pointers");
+  }
+
+  switch (D.Type) {
+  case ValID::NumberVal: {                 // Is it a numbered definition?
+    unsigned Num = (unsigned)D.Num;
+
+    // Module constants occupy the lowest numbered slots...
+    std::map::iterator VI = CurModule.Values.find(Ty);
+    if (VI != CurModule.Values.end()) {
+      if (Num < VI->second.size())
+        return VI->second[Num];
+      Num -= VI->second.size();
+    }
+
+    // Make sure that our type is within bounds
+    VI = CurFun.Values.find(Ty);
+    if (VI == CurFun.Values.end()) return 0;
+
+    // Check that the number is within bounds...
+    if (VI->second.size() <= Num) return 0;
+
+    return VI->second[Num];
+  }
+
+  case ValID::NameVal: {                // Is it a named definition?
+    // Get the name out of the ID
+    std::string Name(D.Name);
+    Value* V = 0;
+    RenameMapKey Key = std::make_pair(Name, Ty);
+    if (inFunctionScope()) {
+      // See if the name was renamed
+      RenameMapType::const_iterator I = CurFun.RenameMap.find(Key);
+      std::string LookupName;
+      if (I != CurFun.RenameMap.end())
+        LookupName = I->second;
+      else
+        LookupName = Name;
+      SymbolTable &SymTab = CurFun.CurrentFunction->getValueSymbolTable();
+      V = SymTab.lookup(Ty, LookupName);
+    }
+    if (!V) {
+      RenameMapType::const_iterator I = CurModule.RenameMap.find(Key);
+      std::string LookupName;
+      if (I != CurModule.RenameMap.end())
+        LookupName = I->second;
+      else
+        LookupName = Name;
+      V = CurModule.CurrentModule->getValueSymbolTable().lookup(Ty, LookupName);
     }
-  };
+    if (V == 0) 
+      return 0;
 
-  typedef std::set TypeRegMap;
+    D.destroy();  // Free old strdup'd memory...
+    return V;
+  }
 
-  static const Type* add_new_type(Type* existing);
+  // Check to make sure that "Ty" is an integral type, and that our
+  // value will fit into the specified type...
+  case ValID::ConstSIntVal:    // Is it a constant pool reference??
+    if (!ConstantInt::isValueValidForType(Ty, D.ConstPool64)) {
+      error("Signed integral constant '" + itostr(D.ConstPool64) + 
+            "' is invalid for type '" + Ty->getDescription() + "'");
+    }
+    return ConstantInt::get(Ty, D.ConstPool64);
+
+  case ValID::ConstUIntVal:     // Is it an unsigned const pool reference?
+    if (!ConstantInt::isValueValidForType(Ty, D.UConstPool64)) {
+      if (!ConstantInt::isValueValidForType(Ty, D.ConstPool64))
+        error("Integral constant '" + utostr(D.UConstPool64) + 
+              "' is invalid or out of range");
+      else     // This is really a signed reference.  Transmogrify.
+        return ConstantInt::get(Ty, D.ConstPool64);
+    } else
+      return ConstantInt::get(Ty, D.UConstPool64);
 
-  std::string newTy;
-  TypeIDs oldTy;
-  Type *elemTy;
-  Type *resultTy;
-  TypeList *elements;
-  uint64_t nelems;
-  static TypeRegMap registry;
-public:
-  typedef std::vector TypeVector;
-  typedef std::map TypeMap;
-  typedef std::map TypePlaneMap;
-  typedef std::map GlobalsTypeMap;
-  static TypeVector EnumeratedTypes;
-  static TypeMap NamedTypes;
-  static GlobalsTypeMap Globals;
-};
+  case ValID::ConstFPVal:        // Is it a floating point const pool reference?
+    if (!ConstantFP::isValueValidForType(Ty, D.ConstPoolFP))
+      error("FP constant invalid for type");
+    return ConstantFP::get(Ty, D.ConstPoolFP);
+
+  case ValID::ConstNullVal:      // Is it a null value?
+    if (!isa(Ty))
+      error("Cannot create a a non pointer null");
+    return ConstantPointerNull::get(cast(Ty));
+
+  case ValID::ConstUndefVal:      // Is it an undef value?
+    return UndefValue::get(Ty);
+
+  case ValID::ConstZeroVal:      // Is it a zero value?
+    return Constant::getNullValue(Ty);
+    
+  case ValID::ConstantVal:       // Fully resolved constant?
+    if (D.ConstantValue->getType() != Ty) 
+      error("Constant expression type different from required type");
+    return D.ConstantValue;
+
+  case ValID::InlineAsmVal: {    // Inline asm expression
+    const PointerType *PTy = dyn_cast(Ty);
+    const FunctionType *FTy =
+      PTy ? dyn_cast(PTy->getElementType()) : 0;
+    if (!FTy || !InlineAsm::Verify(FTy, D.IAD->Constraints))
+      error("Invalid type for asm constraint string");
+    InlineAsm *IA = InlineAsm::get(FTy, D.IAD->AsmString, D.IAD->Constraints,
+                                   D.IAD->HasSideEffects);
+    D.destroy();   // Free InlineAsmDescriptor.
+    return IA;
+  }
+  default:
+    assert(0 && "Unhandled case");
+    return 0;
+  }   // End of switch
 
-Type::TypeRegMap     Type::registry;
-Type::TypeVector     Type::EnumeratedTypes;
-Type::TypeMap        Type::NamedTypes;
-Type::GlobalsTypeMap Type::Globals;
-
-const Type* Type::get(const std::string &newType, TypeIDs oldType) {
-  Type* Ty = new Type();
-  Ty->newTy = newType;
-  Ty->oldTy = oldType;
-  return add_new_type(Ty);
+  assert(0 && "Unhandled case");
+  return 0;
 }
 
-const Type* Type::get(const std::string& newType, TypeIDs oldType, 
-                              const Type* eTy, const Type* rTy) {
-  Type* Ty= new Type();
-  Ty->newTy = newType;
-  Ty->oldTy = oldType;
-  Ty->elemTy = const_cast(eTy);
-  Ty->resultTy = const_cast(rTy);
-  return add_new_type(Ty);
-}
+// getVal - This function is identical to getExistingValue, except that if a
+// value is not already defined, it "improvises" by creating a placeholder var
+// that looks and acts just like the requested variable.  When the value is
+// defined later, all uses of the placeholder variable are replaced with the
+// real thing.
+//
+static Value *getVal(const Type *Ty, const ValID &ID) {
+  if (Ty == Type::LabelTy)
+    error("Cannot use a basic block here");
+
+  // See if the value has already been defined.
+  Value *V = getExistingValue(Ty, ID);
+  if (V) return V;
+
+  if (!Ty->isFirstClassType() && !isa(Ty))
+    error("Invalid use of a composite type");
+
+  // If we reached here, we referenced either a symbol that we don't know about
+  // or an id number that hasn't been read yet.  We may be referencing something
+  // forward, so just create an entry to be resolved later and get to it...
+  assert(!isa(Ty) && "Can't create value with SignedType");
+  V = new Argument(Ty);
+
+  // Remember where this forward reference came from.  FIXME, shouldn't we try
+  // to recycle these things??
+  CurModule.PlaceHolderInfo.insert(
+    std::make_pair(V, std::make_pair(ID, Upgradelineno-1)));
 
-const Type* Type::get(const std::string& newType, TypeIDs oldType, 
-                              const Type *eTy, uint64_t elems) {
-  Type* Ty = new Type();
-  Ty->newTy = newType;
-  Ty->oldTy = oldType;
-  Ty->elemTy = const_cast(eTy);
-  Ty->nelems = elems;
-  return  add_new_type(Ty);
+  if (inFunctionScope())
+    InsertValue(V, CurFun.LateResolveValues);
+  else
+    InsertValue(V, CurModule.LateResolveValues);
+  return V;
 }
 
-const Type* Type::get(const std::string& newType, TypeIDs oldType, 
-                              TypeList* TL) {
-  Type* Ty = new Type();
-  Ty->newTy = newType;
-  Ty->oldTy = oldType;
-  Ty->elements = TL;
-  return add_new_type(Ty);
-}
+/// getBBVal - This is used for two purposes:
+///  * If isDefinition is true, a new basic block with the specified ID is being
+///    defined.
+///  * If isDefinition is true, this is a reference to a basic block, which may
+///    or may not be a forward reference.
+///
+static BasicBlock *getBBVal(const ValID &ID, bool isDefinition = false) {
+  assert(inFunctionScope() && "Can't get basic block at global scope");
+
+  std::string Name;
+  BasicBlock *BB = 0;
+  switch (ID.Type) {
+  default: 
+    error("Illegal label reference " + ID.getName());
+    break;
+  case ValID::NumberVal:                // Is it a numbered definition?
+    if (unsigned(ID.Num) >= CurFun.NumberedBlocks.size())
+      CurFun.NumberedBlocks.resize(ID.Num+1);
+    BB = CurFun.NumberedBlocks[ID.Num];
+    break;
+  case ValID::NameVal:                  // Is it a named definition?
+    Name = ID.Name;
+    if (Value *N = CurFun.CurrentFunction->
+                   getValueSymbolTable().lookup(Type::LabelTy, Name)) {
+      if (N->getType() != Type::LabelTy)
+        error("Name '" + Name + "' does not refer to a BasicBlock");
+      BB = cast(N);
+    }
+    break;
+  }
 
-const Type* Type::get(const std::string& newType, const Type* resTy,
-                              TypeList* TL) {
-  Type* Ty = new Type();
-  Ty->newTy = newType;
-  Ty->oldTy = FunctionTy;
-  Ty->resultTy = const_cast(resTy);
-  Ty->elements = TL;
-  return add_new_type(Ty);
-}
+  // See if the block has already been defined.
+  if (BB) {
+    // If this is the definition of the block, make sure the existing value was
+    // just a forward reference.  If it was a forward reference, there will be
+    // an entry for it in the PlaceHolderInfo map.
+    if (isDefinition && !CurFun.BBForwardRefs.erase(BB))
+      // The existing value was a definition, not a forward reference.
+      error("Redefinition of label " + ID.getName());
+
+    ID.destroy();                       // Free strdup'd memory.
+    return BB;
+  }
+
+  // Otherwise this block has not been seen before.
+  BB = new BasicBlock("", CurFun.CurrentFunction);
+  if (ID.Type == ValID::NameVal) {
+    BB->setName(ID.Name);
+  } else {
+    CurFun.NumberedBlocks[ID.Num] = BB;
+  }
 
-const Type* Type::resolve() const {
-  if (isUnresolved()) {
-    if (getNewTy()[0] == '%' && isdigit(newTy[1])) {
-      unsigned ref = atoi(&((newTy.c_str())[1])); // skip the %
-      if (ref < EnumeratedTypes.size()) {
-        return EnumeratedTypes[ref];
-      } else {
-        std::string msg("Can't resolve numbered type: ");
-        msg += getNewTy();
-        yyerror(msg.c_str());
-      }
-    } else {
-      Type::TypeMap::iterator I = NamedTypes.find(newTy);
-      if (I != NamedTypes.end()) {
-        return I->second;
-      } else {
-        std::string msg("Cannot resolve type: ");
-        msg += getNewTy();
-        yyerror(msg.c_str());
-      }
-    }
+  // If this is not a definition, keep track of it so we can use it as a forward
+  // reference.
+  if (!isDefinition) {
+    // Remember where this forward reference came from.
+    CurFun.BBForwardRefs[BB] = std::make_pair(ID, Upgradelineno);
+  } else {
+    // The forward declaration could have been inserted anywhere in the
+    // function: insert it into the correct place now.
+    CurFun.CurrentFunction->getBasicBlockList().remove(BB);
+    CurFun.CurrentFunction->getBasicBlockList().push_back(BB);
   }
-  // otherwise its already resolved.
-  return this;
+  ID.destroy();
+  return BB;
 }
 
-bool Type::operator<(const Type& that) const {
-  if (this == &that)
-    return false;
-  if (oldTy != that.oldTy)
-    return oldTy < that.oldTy;
-  switch (oldTy) {
-    case UpRefTy: {
-      unsigned thisUp = this->getUpRefNum();
-      unsigned thatUp = that.getUpRefNum();
-      return thisUp < thatUp;
-    }
-    case PackedTy:
-    case ArrayTy:
-      if (this->nelems != that.nelems)
-        return nelems < that.nelems;
-    case PointerTy: {
-      const Type* thisTy = this->elemTy;
-      const Type* thatTy = that.elemTy;
-      return *thisTy < *thatTy;
-    }
-    case FunctionTy: {
-      const Type* thisTy = this->resultTy;
-      const Type* thatTy = that.resultTy;
-      if (!thisTy->sameOldTyAs(thatTy))
-        return *thisTy < *thatTy;
-      /* FALL THROUGH */
-    }
-    case StructTy:
-    case PackedStructTy: {
-      if (elements->size() != that.elements->size())
-        return elements->size() < that.elements->size();
-      for (unsigned i = 0; i < elements->size(); i++) {
-        const Type* thisTy = (*this->elements)[i];
-        const Type* thatTy = (*that.elements)[i];
-        if (!thisTy->sameOldTyAs(thatTy))
-          return *thisTy < *thatTy;
+
+//===----------------------------------------------------------------------===//
+//              Code to handle forward references in instructions
+//===----------------------------------------------------------------------===//
+//
+// This code handles the late binding needed with statements that reference
+// values not defined yet... for example, a forward branch, or the PHI node for
+// a loop body.
+//
+// This keeps a table (CurFun.LateResolveValues) of all such forward references
+// and back patchs after we are done.
+//
+
+// ResolveDefinitions - If we could not resolve some defs at parsing
+// time (forward branches, phi functions for loops, etc...) resolve the
+// defs now...
+//
+static void 
+ResolveDefinitions(std::map &LateResolvers,
+                   std::map *FutureLateResolvers) {
+  // Loop over LateResolveDefs fixing up stuff that couldn't be resolved
+  for (std::map::iterator LRI = LateResolvers.begin(),
+         E = LateResolvers.end(); LRI != E; ++LRI) {
+    ValueList &List = LRI->second;
+    while (!List.empty()) {
+      Value *V = List.back();
+      List.pop_back();
+
+      std::map >::iterator PHI =
+        CurModule.PlaceHolderInfo.find(V);
+      assert(PHI != CurModule.PlaceHolderInfo.end() && "Placeholder error");
+
+      ValID &DID = PHI->second.first;
+
+      Value *TheRealValue = getExistingValue(LRI->first, DID);
+      if (TheRealValue) {
+        V->replaceAllUsesWith(TheRealValue);
+        delete V;
+        CurModule.PlaceHolderInfo.erase(PHI);
+      } else if (FutureLateResolvers) {
+        // Functions have their unresolved items forwarded to the module late
+        // resolver table
+        InsertValue(V, *FutureLateResolvers);
+      } else {
+        if (DID.Type == ValID::NameVal) {
+          error("Reference to an invalid definition: '" +DID.getName()+
+                "' of type '" + V->getType()->getDescription() + "'",
+                PHI->second.second);
+          return;
+        } else {
+          error("Reference to an invalid definition: #" +
+                itostr(DID.Num) + " of type '" + 
+                V->getType()->getDescription() + "'", PHI->second.second);
+          return;
+        }
       }
-      break;
     }
-    case UnresolvedTy:
-      return this->newTy < that.newTy;
-    default:
-      break;
   }
-  return false; 
+
+  LateResolvers.clear();
 }
 
-bool Type::sameOldTyAs(const Type* that) const {
-  if (that == 0)
-    return false;
-  if ( this == that ) 
-    return true;
-  if (oldTy != that->oldTy)
-    return false;
-  switch (oldTy) {
-    case PackedTy:
-    case ArrayTy:
-      if (nelems != that->nelems)
-        return false;
-      /* FALL THROUGH */
-    case PointerTy: {
-      const Type* thisTy = this->elemTy;
-      const Type* thatTy = that->elemTy;
-      return thisTy->sameOldTyAs(thatTy);
-    }
-    case FunctionTy: {
-      const Type* thisTy = this->resultTy;
-      const Type* thatTy = that->resultTy;
-      if (!thisTy->sameOldTyAs(thatTy))
-        return false;
-      /* FALL THROUGH */
-    }
-    case StructTy:
-    case PackedStructTy: {
-      if (elements->size() != that->elements->size())
-        return false;
-      for (unsigned i = 0; i < elements->size(); i++) {
-        const Type* thisTy = (*this->elements)[i];
-        const Type* thatTy = (*that->elements)[i];
-        if (!thisTy->sameOldTyAs(thatTy))
-          return false;
-      }
-      return true;
-    }
-    case UnresolvedTy:
-      return this->newTy == that->newTy;
-    default:
-      return true; // for all others oldTy == that->oldTy is sufficient
+// ResolveTypeTo - A brand new type was just declared.  This means that (if
+// name is not null) things referencing Name can be resolved.  Otherwise, things
+// refering to the number can be resolved.  Do this now.
+//
+static void ResolveTypeTo(char *Name, const Type *ToTy) {
+  ValID D;
+  if (Name) D = ValID::create(Name);
+  else      D = ValID::create((int)CurModule.Types.size());
+
+  std::map::iterator I =
+    CurModule.LateResolveTypes.find(D);
+  if (I != CurModule.LateResolveTypes.end()) {
+    ((DerivedType*)I->second.get())->refineAbstractTypeTo(ToTy);
+    CurModule.LateResolveTypes.erase(I);
   }
-  return true;
 }
 
-bool Type::isUnresolvedDeep() const {
-  switch (oldTy) {
-    case UnresolvedTy: 
-      return true;
-    case PackedTy:
-    case ArrayTy:
-    case PointerTy:
-      return elemTy->isUnresolvedDeep();
-    case PackedStructTy:
-    case StructTy:
-      for (unsigned i = 0; i < elements->size(); i++)
-        if ((*elements)[i]->isUnresolvedDeep())
-          return true;
-      return false;
-    default:
-      return false;
-  }
+static std::string makeNameUnique(const std::string& Name) {
+  static unsigned UniqueNameCounter = 1;
+  std::string Result(Name);
+  Result += ".upgrd." + llvm::utostr(UniqueNameCounter++);
+  return Result;
 }
 
-unsigned Type::getBitWidth() const {
-  switch (oldTy) {
-    default:
-    case LabelTy:
-    case VoidTy : return 0;
-    case BoolTy : return 1;
-    case SByteTy: case UByteTy : return 8;
-    case ShortTy: case UShortTy : return 16;
-    case IntTy: case UIntTy: case FloatTy: return 32;
-    case LongTy: case ULongTy: case DoubleTy : return 64;
-    case PointerTy: return SizeOfPointer; // global var
-    case PackedTy: 
-    case ArrayTy: 
-      return nelems * elemTy->getBitWidth();
-    case StructTy:
-    case PackedStructTy: {
-      uint64_t size = 0;
-      for (unsigned i = 0; i < elements->size(); i++) {
-        size += (*elements)[i]->getBitWidth();
+// setValueName - Set the specified value to the name given.  The name may be
+// null potentially, in which case this is a noop.  The string passed in is
+// assumed to be a malloc'd string buffer, and is free'd by this function.
+//
+static void setValueName(Value *V, char *NameStr) {
+  if (NameStr) {
+    std::string Name(NameStr);      // Copy string
+    free(NameStr);                  // Free old string
+
+    if (V->getType() == Type::VoidTy) {
+      error("Can't assign name '" + Name + "' to value with void type");
+      return;
+    }
+
+    assert(!isa(V->getType()) && "Shouldn't have SignedType Value");
+    assert(inFunctionScope() && "Must be in function scope");
+
+    // Search the function's symbol table for an existing value of this name
+    Value* Existing = 0;
+    SymbolTable &ST = CurFun.CurrentFunction->getValueSymbolTable();
+    SymbolTable::plane_const_iterator PI = ST.plane_begin(), PE =ST.plane_end();
+    for ( ; PI != PE; ++PI) {
+      SymbolTable::value_const_iterator VI = PI->second.find(Name);
+      if (VI != PI->second.end()) {
+        Existing = VI->second;
+        break;
       }
-      return size;
     }
+    if (Existing) {
+      if (Existing->getType() == V->getType()) {
+        // The type of the Existing value and the new one are the same. This
+        // is probably a type plane collapsing error. If the types involved
+        // are both integer, just rename it. Otherwise it 
+        // is a redefinition error.
+        if (!Existing->getType()->isInteger()) {
+          error("Redefinition of value named '" + Name + "' in the '" +
+                V->getType()->getDescription() + "' type plane");
+          return;
+        }
+      } 
+      // In LLVM 2.0 we don't allow names to be re-used for any values in a 
+      // function, regardless of Type. Previously re-use of names was okay as 
+      // long as they were distinct types. With type planes collapsing because
+      // of the signedness change and because of PR411, this can no longer be
+      // supported. We must search the entire symbol table for a conflicting
+      // name and make the name unique. No warning is needed as this can't 
+      // cause a problem.
+      std::string NewName = makeNameUnique(Name);
+      // We're changing the name but it will probably be used by other 
+      // instructions as operands later on. Consequently we have to retain
+      // a mapping of the renaming that we're doing.
+      RenameMapKey Key = std::make_pair(Name,V->getType());
+      CurFun.RenameMap[Key] = NewName;
+      Name = NewName;
+    }
+
+    // Set the name.
+    V->setName(Name);
   }
 }
 
-const Type* Type::getIndexedType(const Value*  V) const {
-  if (isStruct()) {
-    if (V->isConstant() && V->type->isInteger()) {
-      size_t pos = V->val->find(' ') + 1;
-      if (pos < V->val->size()) {
-        uint64_t idx = atoi(V->val->substr(pos).c_str());
-        return (*elements)[idx];
+/// ParseGlobalVariable - Handle parsing of a global.  If Initializer is null,
+/// this is a declaration, otherwise it is a definition.
+static GlobalVariable *
+ParseGlobalVariable(char *NameStr,GlobalValue::LinkageTypes Linkage,
+                    bool isConstantGlobal, const Type *Ty,
+                    Constant *Initializer) {
+  if (isa(Ty))
+    error("Cannot declare global vars of function type");
+
+  const PointerType *PTy = PointerType::get(Ty);
+
+  std::string Name;
+  if (NameStr) {
+    Name = NameStr;      // Copy string
+    free(NameStr);       // Free old string
+  }
+
+  // See if this global value was forward referenced.  If so, recycle the
+  // object.
+  ValID ID;
+  if (!Name.empty()) {
+    ID = ValID::create((char*)Name.c_str());
+  } else {
+    ID = ValID::create((int)CurModule.Values[PTy].size());
+  }
+
+  if (GlobalValue *FWGV = CurModule.GetForwardRefForGlobal(PTy, ID)) {
+    // Move the global to the end of the list, from whereever it was
+    // previously inserted.
+    GlobalVariable *GV = cast(FWGV);
+    CurModule.CurrentModule->getGlobalList().remove(GV);
+    CurModule.CurrentModule->getGlobalList().push_back(GV);
+    GV->setInitializer(Initializer);
+    GV->setLinkage(Linkage);
+    GV->setConstant(isConstantGlobal);
+    InsertValue(GV, CurModule.Values);
+    return GV;
+  }
+
+  // If this global has a name, check to see if there is already a definition
+  // of this global in the module and emit warnings if there are conflicts.
+  if (!Name.empty()) {
+    // The global has a name. See if there's an existing one of the same name.
+    if (CurModule.CurrentModule->getNamedGlobal(Name)) {
+      // We found an existing global ov the same name. This isn't allowed 
+      // in LLVM 2.0. Consequently, we must alter the name of the global so it
+      // can at least compile. This can happen because of type planes 
+      // There is alread a global of the same name which means there is a
+      // conflict. Let's see what we can do about it.
+      std::string NewName(makeNameUnique(Name));
+      if (Linkage == GlobalValue::InternalLinkage) {
+        // The linkage type is internal so just warn about the rename without
+        // invoking "scarey language" about linkage failures. GVars with
+        // InternalLinkage can be renamed at will.
+        warning("Global variable '" + Name + "' was renamed to '"+ 
+                NewName + "'");
       } else {
-        yyerror("Invalid value for constant integer");
-        return 0;
+        // The linkage of this gval is external so we can't reliably rename 
+        // it because it could potentially create a linking problem.  
+        // However, we can't leave the name conflict in the output either or 
+        // it won't assemble with LLVM 2.0.  So, all we can do is rename 
+        // this one to something unique and emit a warning about the problem.
+        warning("Renaming global variable '" + Name + "' to '" + NewName + 
+                  "' may cause linkage errors");
       }
-    } else {
-      yyerror("Structure requires constant index");
-      return 0;
+
+      // Put the renaming in the global rename map
+      RenameMapKey Key = std::make_pair(Name,PointerType::get(Ty));
+      CurModule.RenameMap[Key] = NewName;
+
+      // Rename it
+      Name = NewName;
     }
   }
-  if (isArray() || isPacked() || isPointer())
-    return elemTy;
-  yyerror("Invalid type for getIndexedType");
-  return 0;
+
+  // Otherwise there is no existing GV to use, create one now.
+  GlobalVariable *GV =
+    new GlobalVariable(Ty, isConstantGlobal, Linkage, Initializer, Name,
+                       CurModule.CurrentModule);
+  InsertValue(GV, CurModule.Values);
+  return GV;
 }
 
-void Type::getSignedness(unsigned &sNum, unsigned &uNum, 
-                             UpRefStack& stack) const {
-  switch (oldTy) {
-    default:
-    case OpaqueTy: case LabelTy: case VoidTy: case BoolTy: 
-    case FloatTy : case DoubleTy: case UpRefTy:
-      return;
-    case SByteTy: case ShortTy: case LongTy: case IntTy: 
-      sNum++;
-      return;
-    case UByteTy: case UShortTy: case UIntTy: case ULongTy: 
-      uNum++;
-      return;
-    case PointerTy:
-    case PackedTy: 
-    case ArrayTy:
-      stack.push_back(this);
-      elemTy->getSignedness(sNum, uNum, stack);
-      return;
-    case StructTy:
-    case PackedStructTy: {
-      stack.push_back(this);
-      for (unsigned i = 0; i < elements->size(); i++) {
-        (*elements)[i]->getSignedness(sNum, uNum, stack);
-      }
-      return;
-    }
-    case UnresolvedTy: {
-      const Type* Ty = this->resolve();
-      // Let's not recurse.
-      UpRefStack::const_iterator I = stack.begin(), E = stack.end();
-      for ( ; I != E && *I != Ty; ++I) 
-        ;
-      if (I == E)
-        Ty->getSignedness(sNum, uNum, stack);
-      return;
+// setTypeName - Set the specified type to the name given.  The name may be
+// null potentially, in which case this is a noop.  The string passed in is
+// assumed to be a malloc'd string buffer, and is freed by this function.
+//
+// This function returns true if the type has already been defined, but is
+// allowed to be redefined in the specified context.  If the name is a new name
+// for the type plane, it is inserted and false is returned.
+static bool setTypeName(const Type *T, char *NameStr) {
+  assert(!inFunctionScope() && "Can't give types function-local names");
+  if (NameStr == 0) return false;
+ 
+  std::string Name(NameStr);      // Copy string
+  free(NameStr);                  // Free old string
+
+  // We don't allow assigning names to void type
+  if (T == Type::VoidTy) {
+    error("Can't assign name '" + Name + "' to the void type");
+    return false;
+  }
+
+  // Set the type name, checking for conflicts as we do so.
+  bool AlreadyExists = CurModule.CurrentModule->addTypeName(Name, T);
+
+  if (AlreadyExists) {   // Inserting a name that is already defined???
+    const Type *Existing = CurModule.CurrentModule->getTypeByName(Name);
+    assert(Existing && "Conflict but no matching type?");
+
+    // There is only one case where this is allowed: when we are refining an
+    // opaque type.  In this case, Existing will be an opaque type.
+    if (const OpaqueType *OpTy = dyn_cast(Existing)) {
+      // We ARE replacing an opaque type!
+      const_cast(OpTy)->refineAbstractTypeTo(T);
+      return true;
     }
+
+    // Otherwise, this is an attempt to redefine a type. That's okay if
+    // the redefinition is identical to the original. This will be so if
+    // Existing and T point to the same Type object. In this one case we
+    // allow the equivalent redefinition.
+    if (Existing == T) return true;  // Yes, it's equal.
+
+    // Any other kind of (non-equivalent) redefinition is an error.
+    error("Redefinition of type named '" + Name + "' in the '" +
+          T->getDescription() + "' type plane");
   }
+
+  return false;
 }
 
-std::string AddSuffix(const std::string& Name, const std::string& Suffix) {
-  if (Name[Name.size()-1] == '"') {
-    std::string Result = Name;
-    Result.insert(Result.size()-1, Suffix);
-    return Result;
-  }
-  return Name + Suffix;
+//===----------------------------------------------------------------------===//
+// Code for handling upreferences in type names...
+//
+
+// TypeContains - Returns true if Ty directly contains E in it.
+//
+static bool TypeContains(const Type *Ty, const Type *E) {
+  return std::find(Ty->subtype_begin(), Ty->subtype_end(),
+                   E) != Ty->subtype_end();
 }
 
-std::string Type::makeUniqueName(const std::string& BaseName) const {
-  if (BaseName == "\"alloca point\"")
-    return BaseName;
-  switch (oldTy) {
-    default:
-      break;
-    case OpaqueTy: case LabelTy: case VoidTy: case BoolTy: case UpRefTy:
-    case FloatTy : case DoubleTy: case UnresolvedTy:
-      return BaseName;
-    case SByteTy: case ShortTy: case LongTy: case IntTy: 
-      return AddSuffix(BaseName, ".s");
-    case UByteTy: case UShortTy: case UIntTy: case ULongTy: 
-      return AddSuffix(BaseName, ".u");
-  }
+namespace {
+  struct UpRefRecord {
+    // NestingLevel - The number of nesting levels that need to be popped before
+    // this type is resolved.
+    unsigned NestingLevel;
+
+    // LastContainedTy - This is the type at the current binding level for the
+    // type.  Every time we reduce the nesting level, this gets updated.
+    const Type *LastContainedTy;
+
+    // UpRefTy - This is the actual opaque type that the upreference is
+    // represented with.
+    OpaqueType *UpRefTy;
 
-  unsigned uNum = 0, sNum = 0;
-  std::string Suffix;
-  switch (oldTy) {
-    case PointerTy:
-    case PackedTy: 
-    case ArrayTy: {
-      Type::UpRefStack stack;
-      elemTy->resolve()->getSignedness(sNum, uNum, stack);
-      break;
-    }
-    case StructTy:
-    case PackedStructTy: {
-      for (unsigned i = 0; i < elements->size(); i++) {
-        Type::UpRefStack stack;
-        (*elements)[i]->resolve()->getSignedness(sNum, uNum, stack);
+    UpRefRecord(unsigned NL, OpaqueType *URTy)
+      : NestingLevel(NL), LastContainedTy(URTy), UpRefTy(URTy) {}
+  };
+}
+
+// UpRefs - A list of the outstanding upreferences that need to be resolved.
+static std::vector UpRefs;
+
+/// HandleUpRefs - Every time we finish a new layer of types, this function is
+/// called.  It loops through the UpRefs vector, which is a list of the
+/// currently active types.  For each type, if the up reference is contained in
+/// the newly completed type, we decrement the level count.  When the level
+/// count reaches zero, the upreferenced type is the type that is passed in:
+/// thus we can complete the cycle.
+///
+static PATypeHolder HandleUpRefs(const Type *ty) {
+  // If Ty isn't abstract, or if there are no up-references in it, then there is
+  // nothing to resolve here.
+  if (!ty->isAbstract() || UpRefs.empty()) return ty;
+  
+  PATypeHolder Ty(ty);
+  UR_OUT("Type '" << Ty->getDescription() <<
+         "' newly formed.  Resolving upreferences.\n" <<
+         UpRefs.size() << " upreferences active!\n");
+
+  // If we find any resolvable upreferences (i.e., those whose NestingLevel goes
+  // to zero), we resolve them all together before we resolve them to Ty.  At
+  // the end of the loop, if there is anything to resolve to Ty, it will be in
+  // this variable.
+  OpaqueType *TypeToResolve = 0;
+
+  for (unsigned i = 0; i != UpRefs.size(); ++i) {
+    UR_OUT("  UR#" << i << " - TypeContains(" << Ty->getDescription() << ", "
+           << UpRefs[i].second->getDescription() << ") = "
+           << (TypeContains(Ty, UpRefs[i].second) ? "true" : "false") << "\n");
+    if (TypeContains(Ty, UpRefs[i].LastContainedTy)) {
+      // Decrement level of upreference
+      unsigned Level = --UpRefs[i].NestingLevel;
+      UpRefs[i].LastContainedTy = Ty;
+      UR_OUT("  Uplevel Ref Level = " << Level << "\n");
+      if (Level == 0) {                     // Upreference should be resolved!
+        if (!TypeToResolve) {
+          TypeToResolve = UpRefs[i].UpRefTy;
+        } else {
+          UR_OUT("  * Resolving upreference for "
+                 << UpRefs[i].second->getDescription() << "\n";
+                 std::string OldName = UpRefs[i].UpRefTy->getDescription());
+          UpRefs[i].UpRefTy->refineAbstractTypeTo(TypeToResolve);
+          UR_OUT("  * Type '" << OldName << "' refined upreference to: "
+                 << (const void*)Ty << ", " << Ty->getDescription() << "\n");
+        }
+        UpRefs.erase(UpRefs.begin()+i);     // Remove from upreference list...
+        --i;                                // Do not skip the next element...
       }
-      break;
     }
-    default:
-      assert(0 && "Invalid Type");
-      break;
   }
 
-  if (sNum == 0 && uNum == 0)
-    return BaseName;
-
-  switch (oldTy) {
-    default:             Suffix += ".nada"; break;
-    case PointerTy:      Suffix += ".pntr"; break;
-    case PackedTy:       Suffix += ".pckd"; break;
-    case ArrayTy:        Suffix += ".arry"; break;
-    case StructTy:       Suffix += ".strc"; break;
-    case PackedStructTy: Suffix += ".pstr"; break;
+  if (TypeToResolve) {
+    UR_OUT("  * Resolving upreference for "
+           << UpRefs[i].second->getDescription() << "\n";
+           std::string OldName = TypeToResolve->getDescription());
+    TypeToResolve->refineAbstractTypeTo(Ty);
   }
 
-  Suffix += ".s" + llvm::utostr(sNum);
-  Suffix += ".u" + llvm::utostr(uNum);
-  return AddSuffix(BaseName, Suffix);
+  return Ty;
 }
 
-Type& Type::operator=(const Type& that) {
-  oldTy = that.oldTy;
-  nelems = that.nelems;
-  newTy = that.newTy;
-  elemTy = that.elemTy;
-  resultTy = that.resultTy;
-  if (that.elements) {
-    elements = new TypeList(that.elements->size());
-    *elements = *that.elements;
-  } else {
-    elements = 0;
+static inline Instruction::TermOps 
+getTermOp(TermOps op) {
+  switch (op) {
+    default           : assert(0 && "Invalid OldTermOp");
+    case RetOp        : return Instruction::Ret;
+    case BrOp         : return Instruction::Br;
+    case SwitchOp     : return Instruction::Switch;
+    case InvokeOp     : return Instruction::Invoke;
+    case UnwindOp     : return Instruction::Unwind;
+    case UnreachableOp: return Instruction::Unreachable;
   }
-  return *this;
 }
 
-const Type* Type::add_new_type(Type* newTy) {
-  TypeRegMap::iterator I = registry.find(newTy);
-  if (I != registry.end()) {
-    delete newTy;
-    return *I;
+static inline Instruction::BinaryOps 
+getBinaryOp(BinaryOps op, const Type *Ty, Signedness Sign) {
+  switch (op) {
+    default     : assert(0 && "Invalid OldBinaryOps");
+    case SetEQ  : 
+    case SetNE  : 
+    case SetLE  :
+    case SetGE  :
+    case SetLT  :
+    case SetGT  : assert(0 && "Should use getCompareOp");
+    case AddOp  : return Instruction::Add;
+    case SubOp  : return Instruction::Sub;
+    case MulOp  : return Instruction::Mul;
+    case DivOp  : {
+      // This is an obsolete instruction so we must upgrade it based on the
+      // types of its operands.
+      bool isFP = Ty->isFloatingPoint();
+      if (const PackedType* PTy = dyn_cast(Ty))
+        // If its a packed type we want to use the element type
+        isFP = PTy->getElementType()->isFloatingPoint();
+      if (isFP)
+        return Instruction::FDiv;
+      else if (Sign == Signed)
+        return Instruction::SDiv;
+      return Instruction::UDiv;
+    }
+    case UDivOp : return Instruction::UDiv;
+    case SDivOp : return Instruction::SDiv;
+    case FDivOp : return Instruction::FDiv;
+    case RemOp  : {
+      // This is an obsolete instruction so we must upgrade it based on the
+      // types of its operands.
+      bool isFP = Ty->isFloatingPoint();
+      if (const PackedType* PTy = dyn_cast(Ty))
+        // If its a packed type we want to use the element type
+        isFP = PTy->getElementType()->isFloatingPoint();
+      // Select correct opcode
+      if (isFP)
+        return Instruction::FRem;
+      else if (Sign == Signed)
+        return Instruction::SRem;
+      return Instruction::URem;
+    }
+    case URemOp : return Instruction::URem;
+    case SRemOp : return Instruction::SRem;
+    case FRemOp : return Instruction::FRem;
+    case AndOp  : return Instruction::And;
+    case OrOp   : return Instruction::Or;
+    case XorOp  : return Instruction::Xor;
   }
-  registry.insert(newTy);
-  return newTy;
 }
 
-class Instruction {
-};
-
-/// This type is used to keep track of the signedness of constants.
-struct Constant {
-  std::string *cnst;
-  const Type *type;
-  ~Constant() { delete cnst; }
-};
-
-/// This variable provides a counter for unique names. It is used in various
-/// productions to ensure a unique name is generated.
-static uint64_t UniqueNameCounter = 1;
-
-// This is set when a DECLARE keyword is recognized so that subsequent parsing
-// of a function prototype can know if its a declaration or definition.
-static bool isDeclare = false;
-
-// This bool is used to communicate between the InstVal and Inst rules about
-// whether or not a cast should be deleted. When the flag is set, InstVal has
-// determined that the cast is a candidate. However, it can only be deleted if
-// the value being casted is the same value name as the instruction. The Inst
-// rule makes that comparison if the flag is set and comments out the
-// instruction if they match.
-static bool deleteUselessCastFlag = false;
-static std::string* deleteUselessCastName = 0;
-
-
-
-const char* getCastOpcode(std::string& Source, const Type* SrcTy, 
-                          const Type* DstTy) {
-  unsigned SrcBits = SrcTy->getBitWidth();
-  unsigned DstBits = DstTy->getBitWidth();
-  const char* opcode = "bitcast";
-  // Run through the possibilities ...
-  if (DstTy->isIntegral()) {                        // Casting to integral
-    if (SrcTy->isIntegral()) {                      // Casting from integral
-      if (DstBits < SrcBits)
-        opcode = "trunc";
-      else if (DstBits > SrcBits) {                // its an extension
-        if (SrcTy->isSigned())
-          opcode ="sext";                          // signed -> SEXT
+static inline Instruction::OtherOps 
+getCompareOp(BinaryOps op, unsigned short &predicate, const Type* &Ty,
+             Signedness Sign) {
+  bool isSigned = Sign == Signed;
+  bool isFP = Ty->isFloatingPoint();
+  switch (op) {
+    default     : assert(0 && "Invalid OldSetCC");
+    case SetEQ  : 
+      if (isFP) {
+        predicate = FCmpInst::FCMP_OEQ;
+        return Instruction::FCmp;
+      } else {
+        predicate = ICmpInst::ICMP_EQ;
+        return Instruction::ICmp;
+      }
+    case SetNE  : 
+      if (isFP) {
+        predicate = FCmpInst::FCMP_UNE;
+        return Instruction::FCmp;
+      } else {
+        predicate = ICmpInst::ICMP_NE;
+        return Instruction::ICmp;
+      }
+    case SetLE  : 
+      if (isFP) {
+        predicate = FCmpInst::FCMP_OLE;
+        return Instruction::FCmp;
+      } else {
+        if (isSigned)
+          predicate = ICmpInst::ICMP_SLE;
         else
-          opcode = "zext";                         // unsigned -> ZEXT
+          predicate = ICmpInst::ICMP_ULE;
+        return Instruction::ICmp;
+      }
+    case SetGE  : 
+      if (isFP) {
+        predicate = FCmpInst::FCMP_OGE;
+        return Instruction::FCmp;
       } else {
-        opcode = "bitcast";                        // Same size, No-op cast
+        if (isSigned)
+          predicate = ICmpInst::ICMP_SGE;
+        else
+          predicate = ICmpInst::ICMP_UGE;
+        return Instruction::ICmp;
       }
-    } else if (SrcTy->isFloatingPoint()) {          // Casting from floating pt
-      if (DstTy->isSigned()) 
-        opcode = "fptosi";                         // FP -> sint
-      else
-        opcode = "fptoui";                         // FP -> uint 
-    } else if (SrcTy->isPacked()) {
-      assert(DstBits == SrcTy->getBitWidth() &&
-               "Casting packed to integer of different width");
-        opcode = "bitcast";                        // same size, no-op cast
-    } else {
-      assert(SrcTy->isPointer() &&
-             "Casting from a value that is not first-class type");
-      opcode = "ptrtoint";                         // ptr -> int
-    }
-  } else if (DstTy->isFloatingPoint()) {           // Casting to floating pt
-    if (SrcTy->isIntegral()) {                     // Casting from integral
-      if (SrcTy->isSigned())
-        opcode = "sitofp";                         // sint -> FP
-      else
-        opcode = "uitofp";                         // uint -> FP
-    } else if (SrcTy->isFloatingPoint()) {         // Casting from floating pt
-      if (DstBits < SrcBits) {
-        opcode = "fptrunc";                        // FP -> smaller FP
-      } else if (DstBits > SrcBits) {
-        opcode = "fpext";                          // FP -> larger FP
-      } else  {
-        opcode ="bitcast";                         // same size, no-op cast
+    case SetLT  : 
+      if (isFP) {
+        predicate = FCmpInst::FCMP_OLT;
+        return Instruction::FCmp;
+      } else {
+        if (isSigned)
+          predicate = ICmpInst::ICMP_SLT;
+        else
+          predicate = ICmpInst::ICMP_ULT;
+        return Instruction::ICmp;
+      }
+    case SetGT  : 
+      if (isFP) {
+        predicate = FCmpInst::FCMP_OGT;
+        return Instruction::FCmp;
+      } else {
+        if (isSigned)
+          predicate = ICmpInst::ICMP_SGT;
+        else
+          predicate = ICmpInst::ICMP_UGT;
+        return Instruction::ICmp;
       }
-    } else if (SrcTy->isPacked()) {
-      assert(DstBits == SrcTy->getBitWidth() &&
-             "Casting packed to floating point of different width");
-        opcode = "bitcast";                        // same size, no-op cast
-    } else {
-      assert(0 && "Casting pointer or non-first class to float");
-    }
-  } else if (DstTy->isPacked()) {
-    if (SrcTy->isPacked()) {
-      assert(DstTy->getBitWidth() == SrcTy->getBitWidth() &&
-             "Casting packed to packed of different widths");
-      opcode = "bitcast";                          // packed -> packed
-    } else if (DstTy->getBitWidth() == SrcBits) {
-      opcode = "bitcast";                          // float/int -> packed
-    } else {
-      assert(!"Illegal cast to packed (wrong type or size)");
-    }
-  } else if (DstTy->isPointer()) {
-    if (SrcTy->isPointer()) {
-      opcode = "bitcast";                          // ptr -> ptr
-    } else if (SrcTy->isIntegral()) {
-      opcode = "inttoptr";                         // int -> ptr
-    } else {
-      assert(!"Casting invalid type to pointer");
-    }
-  } else {
-    assert(!"Casting to type that is not first-class");
   }
-  return opcode;
 }
 
-std::string getCastUpgrade(const std::string& Src, const Type* SrcTy,
-                           const Type* DstTy, bool isConst) {
-  std::string Result;
-  std::string Source = Src;
-  if (SrcTy->isFloatingPoint() && DstTy->isPointer()) {
-    // fp -> ptr cast is no longer supported but we must upgrade this
-    // by doing a double cast: fp -> int -> ptr
-    if (isConst)
-      Source = "i64 fptoui(" + Source + " to i64)";
-    else {
-      *O << "    %cast_upgrade" << UniqueNameCounter << " = fptoui " 
-         << Source << " to i64\n";
-      Source = "i64 %cast_upgrade" + llvm::utostr(UniqueNameCounter++);
-    }
-    // Update the SrcTy for the getCastOpcode call below
-    SrcTy = Type::get("i64", ULongTy);
-  } else if (DstTy->isBool()) {
-    // cast type %x to bool was previously defined as setne type %x, null
-    // The cast semantic is now to truncate, not compare so we must retain
-    // the original intent by replacing the cast with a setne
-    const char* comparator = SrcTy->isPointer() ? ", null" : 
-      (SrcTy->isFloatingPoint() ? ", 0.0" : 
-       (SrcTy->isBool() ? ", false" : ", 0"));
-    const char* compareOp = SrcTy->isFloatingPoint() ? "fcmp one " : "icmp ne ";
-    if (isConst) { 
-      Result = "(" + Source + comparator + ")";
-      Result = compareOp + Result;
-    } else
-      Result = compareOp + Source + comparator;
-    return Result; // skip cast processing below
+static inline Instruction::MemoryOps getMemoryOp(MemoryOps op) {
+  switch (op) {
+    default              : assert(0 && "Invalid OldMemoryOps");
+    case MallocOp        : return Instruction::Malloc;
+    case FreeOp          : return Instruction::Free;
+    case AllocaOp        : return Instruction::Alloca;
+    case LoadOp          : return Instruction::Load;
+    case StoreOp         : return Instruction::Store;
+    case GetElementPtrOp : return Instruction::GetElementPtr;
   }
-  SrcTy = SrcTy->resolve();
-  DstTy = DstTy->resolve();
-  std::string Opcode(getCastOpcode(Source, SrcTy, DstTy));
-  if (isConst)
-    Result += Opcode + "( " + Source + " to " + DstTy->getNewTy() + ")";
-  else
-    Result += Opcode + " " + Source + " to " + DstTy->getNewTy();
-  return Result;
 }
 
-const char* getDivRemOpcode(const std::string& opcode, const Type* TI) {
-  const char* op = opcode.c_str();
-  const Type* Ty = TI->resolve();
-  if (Ty->isPacked())
-    Ty = Ty->getElementType();
-  if (opcode == "div")
-    if (Ty->isFloatingPoint())
-      op = "fdiv";
-    else if (Ty->isUnsigned())
-      op = "udiv";
-    else if (Ty->isSigned())
-      op = "sdiv";
-    else
-      yyerror("Invalid type for div instruction");
-  else if (opcode == "rem")
-    if (Ty->isFloatingPoint())
-      op = "frem";
-    else if (Ty->isUnsigned())
-      op = "urem";
-    else if (Ty->isSigned())
-      op = "srem";
-    else
-      yyerror("Invalid type for rem instruction");
-  return op;
+static inline Instruction::OtherOps 
+getOtherOp(OtherOps op, Signedness Sign) {
+  switch (op) {
+    default               : assert(0 && "Invalid OldOtherOps");
+    case PHIOp            : return Instruction::PHI;
+    case CallOp           : return Instruction::Call;
+    case ShlOp            : return Instruction::Shl;
+    case ShrOp            : 
+      if (Sign == Signed)
+        return Instruction::AShr;
+      return Instruction::LShr;
+    case SelectOp         : return Instruction::Select;
+    case UserOp1          : return Instruction::UserOp1;
+    case UserOp2          : return Instruction::UserOp2;
+    case VAArg            : return Instruction::VAArg;
+    case ExtractElementOp : return Instruction::ExtractElement;
+    case InsertElementOp  : return Instruction::InsertElement;
+    case ShuffleVectorOp  : return Instruction::ShuffleVector;
+    case ICmpOp           : return Instruction::ICmp;
+    case FCmpOp           : return Instruction::FCmp;
+    case LShrOp           : return Instruction::LShr;
+    case AShrOp           : return Instruction::AShr;
+  };
 }
 
-std::string getCompareOp(const std::string& setcc, const Type* TI) {
-  assert(setcc.length() == 5);
-  char cc1 = setcc[3];
-  char cc2 = setcc[4];
-  assert(cc1 == 'e' || cc1 == 'n' || cc1 == 'l' || cc1 == 'g');
-  assert(cc2 == 'q' || cc2 == 'e' || cc2 == 'e' || cc2 == 't');
-  std::string result("xcmp xxx");
-  result[6] = cc1;
-  result[7] = cc2;
-  if (TI->isFloatingPoint()) {
-    result[0] = 'f';
-    result[5] = 'o';
-    if (cc1 == 'n')
-      result[5] = 'u'; // NE maps to unordered
-    else
-      result[5] = 'o'; // everything else maps to ordered
-  } else if (TI->isIntegral() || TI->isPointer()) {
-    result[0] = 'i';
-    if ((cc1 == 'e' && cc2 == 'q') || (cc1 == 'n' && cc2 == 'e'))
-      result.erase(5,1);
-    else if (TI->isSigned())
-      result[5] = 's';
-    else if (TI->isUnsigned() || TI->isPointer() || TI->isBool())
-      result[5] = 'u';
-    else
-      yyerror("Invalid integral type for setcc");
-  }
-  return result;
+static inline Value*
+getCast(CastOps op, Value *Src, Signedness SrcSign, const Type *DstTy, 
+        Signedness DstSign, bool ForceInstruction = false) {
+  Instruction::CastOps Opcode;
+  const Type* SrcTy = Src->getType();
+  if (op == CastOp) {
+    if (SrcTy->isFloatingPoint() && isa(DstTy)) {
+      // fp -> ptr cast is no longer supported but we must upgrade this
+      // by doing a double cast: fp -> int -> ptr
+      SrcTy = Type::Int64Ty;
+      Opcode = Instruction::IntToPtr;
+      if (isa(Src)) {
+        Src = ConstantExpr::getCast(Instruction::FPToUI, 
+                                     cast(Src), SrcTy);
+      } else {
+        std::string NewName(makeNameUnique(Src->getName()));
+        Src = new FPToUIInst(Src, SrcTy, NewName, CurBB);
+      }
+    } else if (isa(DstTy) &&
+               cast(DstTy)->getBitWidth() == 1) {
+      // cast type %x to bool was previously defined as setne type %x, null
+      // The cast semantic is now to truncate, not compare so we must retain
+      // the original intent by replacing the cast with a setne
+      Constant* Null = Constant::getNullValue(SrcTy);
+      Instruction::OtherOps Opcode = Instruction::ICmp;
+      unsigned short predicate = ICmpInst::ICMP_NE;
+      if (SrcTy->isFloatingPoint()) {
+        Opcode = Instruction::FCmp;
+        predicate = FCmpInst::FCMP_ONE;
+      } else if (!SrcTy->isInteger() && !isa(SrcTy)) {
+        error("Invalid cast to bool");
+      }
+      if (isa(Src) && !ForceInstruction)
+        return ConstantExpr::getCompare(predicate, cast(Src), Null);
+      else
+        return CmpInst::create(Opcode, predicate, Src, Null);
+    }
+    // Determine the opcode to use by calling CastInst::getCastOpcode
+    Opcode = 
+      CastInst::getCastOpcode(Src, SrcSign == Signed, DstTy, DstSign == Signed);
+
+  } else switch (op) {
+    default: assert(0 && "Invalid cast token");
+    case TruncOp:    Opcode = Instruction::Trunc; break;
+    case ZExtOp:     Opcode = Instruction::ZExt; break;
+    case SExtOp:     Opcode = Instruction::SExt; break;
+    case FPTruncOp:  Opcode = Instruction::FPTrunc; break;
+    case FPExtOp:    Opcode = Instruction::FPExt; break;
+    case FPToUIOp:   Opcode = Instruction::FPToUI; break;
+    case FPToSIOp:   Opcode = Instruction::FPToSI; break;
+    case UIToFPOp:   Opcode = Instruction::UIToFP; break;
+    case SIToFPOp:   Opcode = Instruction::SIToFP; break;
+    case PtrToIntOp: Opcode = Instruction::PtrToInt; break;
+    case IntToPtrOp: Opcode = Instruction::IntToPtr; break;
+    case BitCastOp:  Opcode = Instruction::BitCast; break;
+  }
+
+  if (isa(Src) && !ForceInstruction)
+    return ConstantExpr::getCast(Opcode, cast(Src), DstTy);
+  return CastInst::create(Opcode, Src, DstTy);
 }
 
-const Type* getFunctionReturnType(const Type* PFTy) {
-  PFTy = PFTy->resolve();
-  if (PFTy->isPointer()) {
-    const Type* ElemTy = PFTy->getElementType();
-    ElemTy = ElemTy->resolve();
-    if (ElemTy->isFunction())
-      return ElemTy->getResultType();
-  } else if (PFTy->isFunction()) {
-    return PFTy->getResultType();
+static Instruction *
+upgradeIntrinsicCall(const Type* RetTy, const ValID &ID, 
+                     std::vector& Args) {
+
+  std::string Name = ID.Type == ValID::NameVal ? ID.Name : "";
+  if (Name == "llvm.isunordered.f32" || Name == "llvm.isunordered.f64") {
+    if (Args.size() != 2)
+      error("Invalid prototype for " + Name + " prototype");
+    return new FCmpInst(FCmpInst::FCMP_UNO, Args[0], Args[1]);
+  } else {
+    static unsigned upgradeCount = 1;
+    const Type* PtrTy = PointerType::get(Type::Int8Ty);
+    std::vector Params;
+    if (Name == "llvm.va_start" || Name == "llvm.va_end") {
+      if (Args.size() != 1)
+        error("Invalid prototype for " + Name + " prototype");
+      Params.push_back(PtrTy);
+      const FunctionType *FTy = FunctionType::get(Type::VoidTy, Params, false);
+      const PointerType *PFTy = PointerType::get(FTy);
+      Value* Func = getVal(PFTy, ID);
+      std::string InstName("va_upgrade");
+      InstName += llvm::utostr(upgradeCount++);
+      Args[0] = new BitCastInst(Args[0], PtrTy, InstName, CurBB);
+      return new CallInst(Func, Args);
+    } else if (Name == "llvm.va_copy") {
+      if (Args.size() != 2)
+        error("Invalid prototype for " + Name + " prototype");
+      Params.push_back(PtrTy);
+      Params.push_back(PtrTy);
+      const FunctionType *FTy = FunctionType::get(Type::VoidTy, Params, false);
+      const PointerType *PFTy = PointerType::get(FTy);
+      Value* Func = getVal(PFTy, ID);
+      std::string InstName0("va_upgrade");
+      InstName0 += llvm::utostr(upgradeCount++);
+      std::string InstName1("va_upgrade");
+      InstName1 += llvm::utostr(upgradeCount++);
+      Args[0] = new BitCastInst(Args[0], PtrTy, InstName0, CurBB);
+      Args[1] = new BitCastInst(Args[1], PtrTy, InstName1, CurBB);
+      return new CallInst(Func, Args);
+    }
   }
-  return PFTy;
+  return 0;
 }
 
-const Type* ResolveUpReference(const Type* Ty, 
-                                   Type::UpRefStack* stack) {
-  assert(Ty->isUpReference() && "Can't resolve a non-upreference");
-  unsigned upref = Ty->getUpRefNum();
-  assert(upref < stack->size() && "Invalid up reference");
-  return (*stack)[upref - stack->size() - 1];
+const Type* upgradeGEPIndices(const Type* PTy, 
+                       std::vector *Indices, 
+                       std::vector    &VIndices, 
+                       std::vector *CIndices = 0) {
+  // Traverse the indices with a gep_type_iterator so we can build the list
+  // of constant and value indices for use later. Also perform upgrades
+  VIndices.clear();
+  if (CIndices) CIndices->clear();
+  for (unsigned i = 0, e = Indices->size(); i != e; ++i)
+    VIndices.push_back((*Indices)[i].V);
+  generic_gep_type_iterator::iterator>
+    GTI = gep_type_begin(PTy, VIndices.begin(),  VIndices.end()),
+    GTE = gep_type_end(PTy,  VIndices.begin(),  VIndices.end());
+  for (unsigned i = 0, e = Indices->size(); i != e && GTI != GTE; ++i, ++GTI) {
+    Value *Index = VIndices[i];
+    if (CIndices && !isa(Index))
+      error("Indices to constant getelementptr must be constants");
+    // LLVM 1.2 and earlier used ubyte struct indices.  Convert any ubyte 
+    // struct indices to i32 struct indices with ZExt for compatibility.
+    else if (isa(*GTI)) {        // Only change struct indices
+      if (ConstantInt *CUI = dyn_cast(Index))
+        if (CUI->getType()->getBitWidth() == 8)
+          Index = 
+            ConstantExpr::getCast(Instruction::ZExt, CUI, Type::Int32Ty);
+    } else {
+      // Make sure that unsigned SequentialType indices are zext'd to 
+      // 64-bits if they were smaller than that because LLVM 2.0 will sext 
+      // all indices for SequentialType elements. We must retain the same 
+      // semantic (zext) for unsigned types.
+      if (const IntegerType *Ity = dyn_cast(Index->getType()))
+        if (Ity->getBitWidth() < 64 && (*Indices)[i].S == Unsigned)
+          if (CIndices)
+            Index = ConstantExpr::getCast(Instruction::ZExt, 
+              cast(Index), Type::Int64Ty);
+          else
+            Index = CastInst::create(Instruction::ZExt, Index, Type::Int64Ty,
+              "gep_upgrade", CurBB);
+    }
+    // Add to the CIndices list, if requested.
+    if (CIndices)
+      CIndices->push_back(cast(Index));
+  }
+
+  const Type *IdxTy =
+    GetElementPtrInst::getIndexedType(PTy, VIndices, true);
+    if (!IdxTy)
+      error("Index list invalid for constant getelementptr");
+  return IdxTy;
 }
 
-const Type* getGEPIndexedType(const Type* PTy, ValueList* idxs) {
-  const Type* Result = PTy = PTy->resolve();
-  assert(PTy->isPointer() && "GEP Operand is not a pointer?");
-  Type::UpRefStack stack;
-  for (unsigned i = 0; i < idxs->size(); ++i) {
-    if (Result->isComposite()) {
-      Result = Result->getIndexedType((*idxs)[i]);
-      Result = Result->resolve();
-      stack.push_back(Result);
-    } else
-      yyerror("Invalid type for index");
-  }
-  // Resolve upreferences so we can return a more natural type
-  if (Result->isPointer()) {
-    if (Result->getElementType()->isUpReference()) {
-      stack.push_back(Result);
-      Result = ResolveUpReference(Result->getElementType(), &stack);
-    }
-  } else if (Result->isUpReference()) {
-    Result = ResolveUpReference(Result->getElementType(), &stack);
+Module* UpgradeAssembly(const std::string &infile, std::istream& in, 
+                              bool debug, bool addAttrs)
+{
+  Upgradelineno = 1; 
+  CurFilename = infile;
+  LexInput = ∈
+  yydebug = debug;
+  AddAttributes = addAttrs;
+  ObsoleteVarArgs = false;
+  NewVarArgs = false;
+
+  CurModule.CurrentModule = new Module(CurFilename);
+
+  // Check to make sure the parser succeeded
+  if (yyparse()) {
+    if (ParserResult)
+      delete ParserResult;
+    std::cerr << "llvm-upgrade: parse failed.\n";
+    return 0;
   }
-  return Result->getPointerType();
-}
 
-// This function handles appending .u or .s to integer value names that
-// were previously unsigned or signed, respectively. This avoids name
-// collisions since the unsigned and signed type planes have collapsed
-// into a single signless type plane.
-std::string getUniqueName(const std::string *Name, const Type* Ty,
-                          bool isGlobal = false, bool isDef = false) {
-
-  // If its not a symbolic name, don't modify it, probably a constant val.
-  if ((*Name)[0] != '%' && (*Name)[0] != '"')
-    return *Name;
-
-  // If its a numeric reference, just leave it alone.
-  if (isdigit((*Name)[1]))
-    return *Name;
-
-  // Resolve the type
-  Ty = Ty->resolve(); 
-
-  // If its a global name, get its uniquified name, if any
-  Type::GlobalsTypeMap::iterator GI = Type::Globals.find(*Name);
-  if (GI != Type::Globals.end()) {
-    Type::TypePlaneMap::iterator TPI = GI->second.begin();
-    Type::TypePlaneMap::iterator TPE = GI->second.end();
-    for ( ; TPI != TPE ; ++TPI) {
-      if (TPI->first->sameNewTyAs(Ty)) 
-        return TPI->second;
-    }
+  // Check to make sure that parsing produced a result
+  if (!ParserResult) {
+    std::cerr << "llvm-upgrade: no parse result.\n";
+    return 0;
   }
 
-  if (isGlobal) {
-    // We didn't find a global name, but if its supposed to be global then all 
-    // we can do is return the name. This is probably a forward reference of a 
-    // global value that hasn't been defined yet. Since we have no definition
-    // we don't know its linkage class. Just assume its an external and the name
-    // shouldn't change.
-    return *Name;
+  // Reset ParserResult variable while saving its value for the result.
+  Module *Result = ParserResult;
+  ParserResult = 0;
+
+  //Not all functions use vaarg, so make a second check for ObsoleteVarArgs
+  {
+    Function* F;
+    if ((F = Result->getNamedFunction("llvm.va_start"))
+        && F->getFunctionType()->getNumParams() == 0)
+      ObsoleteVarArgs = true;
+    if((F = Result->getNamedFunction("llvm.va_copy"))
+       && F->getFunctionType()->getNumParams() == 1)
+      ObsoleteVarArgs = true;
   }
 
-  // Default the result to the current name
-  std::string Result = Ty->makeUniqueName(*Name);
+  if (ObsoleteVarArgs && NewVarArgs) {
+    error("This file is corrupt: it uses both new and old style varargs");
+    return 0;
+  }
 
-  return Result;
-}
+  if(ObsoleteVarArgs) {
+    if(Function* F = Result->getNamedFunction("llvm.va_start")) {
+      if (F->arg_size() != 0) {
+        error("Obsolete va_start takes 0 argument");
+        return 0;
+      }
+      
+      //foo = va_start()
+      // ->
+      //bar = alloca typeof(foo)
+      //va_start(bar)
+      //foo = load bar
+
+      const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID);
+      const Type* ArgTy = F->getFunctionType()->getReturnType();
+      const Type* ArgTyPtr = PointerType::get(ArgTy);
+      Function* NF = cast(Result->getOrInsertFunction(
+        "llvm.va_start", RetTy, ArgTyPtr, (Type *)0));
+
+      while (!F->use_empty()) {
+        CallInst* CI = cast(F->use_back());
+        AllocaInst* bar = new AllocaInst(ArgTy, 0, "vastart.fix.1", CI);
+        new CallInst(NF, bar, "", CI);
+        Value* foo = new LoadInst(bar, "vastart.fix.2", CI);
+        CI->replaceAllUsesWith(foo);
+        CI->getParent()->getInstList().erase(CI);
+      }
+      Result->getFunctionList().erase(F);
+    }
+    
+    if(Function* F = Result->getNamedFunction("llvm.va_end")) {
+      if(F->arg_size() != 1) {
+        error("Obsolete va_end takes 1 argument");
+        return 0;
+      }
 
-std::string getGlobalName(const std::string* Name, const std::string Linkage,
-                          const Type* Ty, bool isConstant) {
-  // Default to given name
-  std::string Result = *Name; 
-  // Look up the name in the Globals Map
-  Type::GlobalsTypeMap::iterator GI = Type::Globals.find(*Name);
-  // Did we see this global name before?
-  if (GI != Type::Globals.end()) {
-    if (Ty->isUnresolvedDeep()) {
-      // The Gval's type is unresolved. Consequently, we can't disambiguate it
-      // by type. We'll just change its name and emit a warning.
-      warning("Cannot disambiguate global value '" + *Name + 
-              "' because type '" + Ty->getNewTy() + "'is unresolved.\n");
-      Result = *Name + ".unique";
-      UniqueNameCounter++;
-      Result += llvm::utostr(UniqueNameCounter);
-      return Result;
-    } else {
-      Type::TypePlaneMap::iterator TPI = GI->second.find(Ty);
-      if (TPI != GI->second.end()) {
-        // We found an existing name of the same old type. This isn't allowed 
-        // in LLVM 2.0. Consequently, we must alter the name of the global so it
-        // can at least compile. References to the global will yield the first
-        // definition, which is okay. We also must warn about this.
-        Result = *Name + ".unique";
-        UniqueNameCounter++;
-        Result += llvm::utostr(UniqueNameCounter);
-        warning(std::string("Global variable '") + *Name + "' was renamed to '"+
-                Result + "'");
-      } else { 
-        // There isn't an existing definition for this name according to the
-        // old types. Now search the TypePlanMap for types with the same new
-        // name. 
-        Type::TypePlaneMap::iterator TPI = GI->second.begin();
-        Type::TypePlaneMap::iterator TPE = GI->second.end();
-        for ( ; TPI != TPE; ++TPI) {
-          if (TPI->first->sameNewTyAs(Ty)) {
-            // The new types are the same but the old types are different so 
-            // this is a global name collision resulting from type planes 
-            // collapsing. 
-            if (Linkage == "external" || Linkage == "dllimport" || 
-                Linkage == "extern_weak" || Linkage == "") {
-              // The linkage of this gval is external so we can't reliably 
-              // rename it because it could potentially create a linking 
-              // problem.  However, we can't leave the name conflict in the 
-              // output either or it won't assemble with LLVM 2.0.  So, all we 
-              // can do is rename this one to something unique and emit a 
-              // warning about the problem.
-              Result = *Name + ".unique";
-              UniqueNameCounter++;
-              Result += llvm::utostr(UniqueNameCounter);
-              warning("Renaming global value '" + *Name + "' to '" + Result + 
-                      "' may cause linkage errors.");
-              return Result;
-            } else {
-              // Its linkage is internal and its type is known so we can 
-              // disambiguate the name collision successfully based on the type.
-              Result = getUniqueName(Name, Ty);
-              TPI->second = Result;
-              return Result;
-            }
-          }
-        }
-        // We didn't find an entry in the type plane with the same new type and
-        // the old types differ so this is a new type plane for this global 
-        // variable. We just fall through to the logic below which inserts
-        // the global.
+      //vaend foo
+      // ->
+      //bar = alloca 1 of typeof(foo)
+      //vaend bar
+      const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID);
+      const Type* ArgTy = F->getFunctionType()->getParamType(0);
+      const Type* ArgTyPtr = PointerType::get(ArgTy);
+      Function* NF = cast(Result->getOrInsertFunction(
+        "llvm.va_end", RetTy, ArgTyPtr, (Type *)0));
+
+      while (!F->use_empty()) {
+        CallInst* CI = cast(F->use_back());
+        AllocaInst* bar = new AllocaInst(ArgTy, 0, "vaend.fix.1", CI);
+        new StoreInst(CI->getOperand(1), bar, CI);
+        new CallInst(NF, bar, "", CI);
+        CI->getParent()->getInstList().erase(CI);
       }
+      Result->getFunctionList().erase(F);
     }
-  }
 
-  // Its a new global name, if it is external we can't change it
-  if (isConstant || Linkage == "external" || Linkage == "dllimport" || 
-      Linkage == "extern_weak" || Linkage == "") {
-    Type::Globals[Result][Ty] = Result;
-    return Result;
+    if(Function* F = Result->getNamedFunction("llvm.va_copy")) {
+      if(F->arg_size() != 1) {
+        error("Obsolete va_copy takes 1 argument");
+        return 0;
+      }
+      //foo = vacopy(bar)
+      // ->
+      //a = alloca 1 of typeof(foo)
+      //b = alloca 1 of typeof(foo)
+      //store bar -> b
+      //vacopy(a, b)
+      //foo = load a
+      
+      const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID);
+      const Type* ArgTy = F->getFunctionType()->getReturnType();
+      const Type* ArgTyPtr = PointerType::get(ArgTy);
+      Function* NF = cast(Result->getOrInsertFunction(
+        "llvm.va_copy", RetTy, ArgTyPtr, ArgTyPtr, (Type *)0));
+
+      while (!F->use_empty()) {
+        CallInst* CI = cast(F->use_back());
+        AllocaInst* a = new AllocaInst(ArgTy, 0, "vacopy.fix.1", CI);
+        AllocaInst* b = new AllocaInst(ArgTy, 0, "vacopy.fix.2", CI);
+        new StoreInst(CI->getOperand(1), b, CI);
+        new CallInst(NF, a, b, "", CI);
+        Value* foo = new LoadInst(a, "vacopy.fix.3", CI);
+        CI->replaceAllUsesWith(foo);
+        CI->getParent()->getInstList().erase(CI);
+      }
+      Result->getFunctionList().erase(F);
+    }
   }
 
-  // Its a new global name, and it is internal, change the name to make it
-  // unique for its type.
-  // Result = getUniqueName(Name, Ty);
-  Type::Globals[*Name][Ty] = Result;
   return Result;
 }
 
-} // End anonymous namespace
+} // end llvm namespace
 
-// This function is used by the Lexer to create a Type. It can't be
-// in the anonymous namespace.
-const Type* getType(const std::string& newTy, TypeIDs oldTy) {
-  return Type::get(newTy, oldTy);
-}
+using namespace llvm;
 
 
 
@@ -1329,53 +1839,108 @@
 # define YYERROR_VERBOSE 0
 #endif
 
-#ifndef YYSTYPE
-#line 971 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-typedef union {
-  std::string*    String;
-  const Type*     Ty;
-  Value*          Val;
-  Constant*       Const;
-  ValueList*      ValList;
-  TypeList*       TypeVec;
-} yystype;
-/* Line 188 of /usr/local/share/bison/yacc.c.  */
-#line 1344 "UpgradeParser.tab.c"
-# define YYSTYPE yystype
-# define YYSTYPE_IS_TRIVIAL 1
+/* Enabling the token table.  */
+#ifndef YYTOKEN_TABLE
+# define YYTOKEN_TABLE 0
 #endif
 
-#ifndef YYLTYPE
-typedef struct yyltype
-{
-  int first_line;
-  int first_column;
-  int last_line;
-  int last_column;
-} yyltype;
-# define YYLTYPE yyltype
-# define YYLTYPE_IS_TRIVIAL 1
+#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
+#line 1469 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+typedef union YYSTYPE {
+  llvm::Module                           *ModuleVal;
+  llvm::Function                         *FunctionVal;
+  std::pair     *ArgVal;
+  llvm::BasicBlock                       *BasicBlockVal;
+  llvm::TerminatorInst                   *TermInstVal;
+  llvm::InstrInfo                        InstVal;
+  llvm::ConstInfo                        ConstVal;
+  llvm::ValueInfo                        ValueVal;
+  llvm::PATypeInfo                       TypeVal;
+  llvm::TypeInfo                         PrimType;
+  llvm::PHIListInfo                      PHIList;
+  std::list            *TypeList;
+  std::vector           *ValueList;
+  std::vector           *ConstVector;
+
+
+  std::vector > *ArgList;
+  // Represent the RHS of PHI node
+  std::vector > *JumpTable;
+
+  llvm::GlobalValue::LinkageTypes         Linkage;
+  int64_t                           SInt64Val;
+  uint64_t                          UInt64Val;
+  int                               SIntVal;
+  unsigned                          UIntVal;
+  double                            FPVal;
+  bool                              BoolVal;
+
+  char                             *StrVal;   // This memory is strdup'd!
+  llvm::ValID                       ValIDVal; // strdup'd memory maybe!
+
+  llvm::BinaryOps                   BinaryOpVal;
+  llvm::TermOps                     TermOpVal;
+  llvm::MemoryOps                   MemOpVal;
+  llvm::OtherOps                    OtherOpVal;
+  llvm::CastOps                     CastOpVal;
+  llvm::ICmpInst::Predicate         IPred;
+  llvm::FCmpInst::Predicate         FPred;
+  llvm::Module::Endianness          Endianness;
+} YYSTYPE;
+/* Line 196 of yacc.c.  */
+#line 1892 "UpgradeParser.tab.c"
+# define yystype YYSTYPE /* obsolescent; will be withdrawn */
+# define YYSTYPE_IS_DECLARED 1
+# define YYSTYPE_IS_TRIVIAL 1
 #endif
 
+
+
 /* Copy the second part of user declarations.  */
 
 
-/* Line 213 of /usr/local/share/bison/yacc.c.  */
-#line 1365 "UpgradeParser.tab.c"
+/* Line 219 of yacc.c.  */
+#line 1904 "UpgradeParser.tab.c"
+
+#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
+# define YYSIZE_T __SIZE_TYPE__
+#endif
+#if ! defined (YYSIZE_T) && defined (size_t)
+# define YYSIZE_T size_t
+#endif
+#if ! defined (YYSIZE_T) && (defined (__STDC__) || defined (__cplusplus))
+# include  /* INFRINGES ON USER NAME SPACE */
+# define YYSIZE_T size_t
+#endif
+#if ! defined (YYSIZE_T)
+# define YYSIZE_T unsigned int
+#endif
+
+#ifndef YY_
+# if YYENABLE_NLS
+#  if ENABLE_NLS
+#   include  /* INFRINGES ON USER NAME SPACE */
+#   define YY_(msgid) dgettext ("bison-runtime", msgid)
+#  endif
+# endif
+# ifndef YY_
+#  define YY_(msgid) msgid
+# endif
+#endif
 
 #if ! defined (yyoverflow) || YYERROR_VERBOSE
 
 /* The parser invokes alloca or malloc; define the necessary symbols.  */
 
-# if YYSTACK_USE_ALLOCA
-#  define YYSTACK_ALLOC alloca
-# else
-#  ifndef YYSTACK_USE_ALLOCA
-#   if defined (alloca) || defined (_ALLOCA_H)
-#    define YYSTACK_ALLOC alloca
+# ifdef YYSTACK_USE_ALLOCA
+#  if YYSTACK_USE_ALLOCA
+#   ifdef __GNUC__
+#    define YYSTACK_ALLOC __builtin_alloca
 #   else
-#    ifdef __GNUC__
-#     define YYSTACK_ALLOC __builtin_alloca
+#    define YYSTACK_ALLOC alloca
+#    if defined (__STDC__) || defined (__cplusplus)
+#     include  /* INFRINGES ON USER NAME SPACE */
+#     define YYINCLUDED_STDLIB_H
 #    endif
 #   endif
 #  endif
@@ -1384,50 +1949,76 @@
 # ifdef YYSTACK_ALLOC
    /* Pacify GCC's `empty if-body' warning. */
 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
+#  ifndef YYSTACK_ALLOC_MAXIMUM
+    /* The OS might guarantee only one guard page at the bottom of the stack,
+       and a page size can be as small as 4096 bytes.  So we cannot safely
+       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
+       to allow for a few compiler-allocated temporary stack slots.  */
+#   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2005 */
+#  endif
 # else
-#  if defined (__STDC__) || defined (__cplusplus)
-#   include  /* INFRINGES ON USER NAME SPACE */
-#   define YYSIZE_T size_t
+#  define YYSTACK_ALLOC YYMALLOC
+#  define YYSTACK_FREE YYFREE
+#  ifndef YYSTACK_ALLOC_MAXIMUM
+#   define YYSTACK_ALLOC_MAXIMUM ((YYSIZE_T) -1)
+#  endif
+#  ifdef __cplusplus
+extern "C" {
+#  endif
+#  ifndef YYMALLOC
+#   define YYMALLOC malloc
+#   if (! defined (malloc) && ! defined (YYINCLUDED_STDLIB_H) \
+	&& (defined (__STDC__) || defined (__cplusplus)))
+void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
+#   endif
+#  endif
+#  ifndef YYFREE
+#   define YYFREE free
+#   if (! defined (free) && ! defined (YYINCLUDED_STDLIB_H) \
+	&& (defined (__STDC__) || defined (__cplusplus)))
+void free (void *); /* INFRINGES ON USER NAME SPACE */
+#   endif
+#  endif
+#  ifdef __cplusplus
+}
 #  endif
-#  define YYSTACK_ALLOC malloc
-#  define YYSTACK_FREE free
 # endif
 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
 
 
 #if (! defined (yyoverflow) \
      && (! defined (__cplusplus) \
-	 || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
+	 || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
 
 /* A type that is properly aligned for any stack member.  */
 union yyalloc
 {
-  short yyss;
+  short int yyss;
   YYSTYPE yyvs;
   };
 
 /* The size of the maximum gap between one aligned stack and the next.  */
-# define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1)
+# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
 
 /* The size of an array large to enough to hold all stacks, each with
    N elements.  */
 # define YYSTACK_BYTES(N) \
-     ((N) * (sizeof (short) + sizeof (YYSTYPE))				\
-      + YYSTACK_GAP_MAX)
+     ((N) * (sizeof (short int) + sizeof (YYSTYPE))			\
+      + YYSTACK_GAP_MAXIMUM)
 
 /* Copy COUNT objects from FROM to TO.  The source and destination do
    not overlap.  */
 # ifndef YYCOPY
-#  if 1 < __GNUC__
+#  if defined (__GNUC__) && 1 < __GNUC__
 #   define YYCOPY(To, From, Count) \
       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
 #  else
 #   define YYCOPY(To, From, Count)		\
       do					\
 	{					\
-	  register YYSIZE_T yyi;		\
+	  YYSIZE_T yyi;				\
 	  for (yyi = 0; yyi < (Count); yyi++)	\
-	    (To)[yyi] = (From)[yyi];	\
+	    (To)[yyi] = (From)[yyi];		\
 	}					\
       while (0)
 #  endif
@@ -1444,7 +2035,7 @@
 	YYSIZE_T yynewbytes;						\
 	YYCOPY (&yyptr->Stack, Stack, yysize);				\
 	Stack = &yyptr->Stack;						\
-	yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAX;	\
+	yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
 	yyptr += yynewbytes / sizeof (*yyptr);				\
       }									\
     while (0)
@@ -1454,28 +2045,29 @@
 #if defined (__STDC__) || defined (__cplusplus)
    typedef signed char yysigned_char;
 #else
-   typedef short yysigned_char;
+   typedef short int yysigned_char;
 #endif
 
 /* YYFINAL -- State number of the termination state. */
 #define YYFINAL  4
-#define YYLAST   1473
+/* YYLAST -- Last index in YYTABLE.  */
+#define YYLAST   1712
 
 /* YYNTOKENS -- Number of terminals. */
-#define YYNTOKENS  164
+#define YYNTOKENS  166
 /* YYNNTS -- Number of nonterminals. */
-#define YYNNTS  76
+#define YYNNTS  79
 /* YYNRULES -- Number of rules. */
-#define YYNRULES  301
+#define YYNRULES  308
 /* YYNRULES -- Number of states. */
-#define YYNSTATES  585
+#define YYNSTATES  604
 
 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 #define YYUNDEFTOK  2
-#define YYMAXUTOK   404
+#define YYMAXUTOK   406
 
-#define YYTRANSLATE(X) \
-  ((unsigned)(X) <= YYMAXUTOK ? yytranslate[X] : YYUNDEFTOK)
+#define YYTRANSLATE(YYX)						\
+  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
 
 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
 static const unsigned char yytranslate[] =
@@ -1484,15 +2076,15 @@
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     153,   154,   162,     2,   151,     2,     2,     2,     2,     2,
+     155,   156,   164,     2,   153,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     158,   150,   159,     2,     2,     2,     2,     2,     2,     2,
+     160,   152,   161,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,   155,   152,   157,     2,     2,     2,     2,     2,   163,
+       2,   157,   154,   159,     2,     2,     2,     2,     2,   165,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     156,     2,     2,   160,     2,   161,     2,     2,     2,     2,
+     158,     2,     2,   162,     2,   163,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
@@ -1520,13 +2112,13 @@
      115,   116,   117,   118,   119,   120,   121,   122,   123,   124,
      125,   126,   127,   128,   129,   130,   131,   132,   133,   134,
      135,   136,   137,   138,   139,   140,   141,   142,   143,   144,
-     145,   146,   147,   148,   149
+     145,   146,   147,   148,   149,   150,   151
 };
 
 #if YYDEBUG
 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
    YYRHS.  */
-static const unsigned short yyprhs[] =
+static const unsigned short int yyprhs[] =
 {
        0,     0,     3,     5,     7,     9,    11,    13,    15,    17,
       19,    21,    23,    25,    27,    29,    31,    33,    35,    37,
@@ -1537,210 +2129,213 @@
      119,   121,   123,   125,   127,   129,   131,   133,   135,   137,
      139,   141,   143,   145,   147,   149,   151,   153,   155,   157,
      159,   161,   164,   165,   167,   169,   171,   173,   175,   177,
-     179,   180,   182,   184,   186,   188,   190,   192,   195,   196,
+     179,   180,   181,   183,   185,   187,   189,   191,   193,   196,
      197,   200,   201,   205,   208,   209,   211,   212,   216,   218,
      221,   223,   225,   227,   229,   231,   233,   235,   237,   239,
      241,   243,   245,   247,   249,   251,   253,   255,   257,   259,
      261,   264,   269,   275,   281,   285,   288,   294,   299,   302,
      304,   308,   310,   314,   316,   317,   322,   326,   330,   335,
-     340,   344,   347,   350,   353,   356,   359,   362,   365,   368,
-     371,   374,   381,   387,   396,   403,   410,   417,   425,   433,
-     440,   447,   456,   465,   469,   471,   473,   475,   477,   480,
-     483,   488,   491,   493,   495,   497,   502,   505,   510,   517,
-     524,   531,   538,   542,   547,   548,   550,   552,   554,   558,
-     562,   566,   570,   574,   578,   580,   581,   583,   585,   587,
-     588,   591,   595,   597,   599,   603,   605,   606,   615,   617,
-     619,   623,   625,   627,   631,   632,   634,   636,   637,   642,
-     643,   645,   647,   649,   651,   653,   655,   657,   659,   661,
-     665,   667,   673,   675,   677,   679,   681,   684,   687,   689,
-     692,   695,   696,   698,   700,   702,   705,   708,   712,   722,
-     732,   741,   756,   758,   760,   767,   773,   776,   783,   791,
-     793,   797,   799,   800,   803,   805,   811,   817,   823,   830,
-     837,   842,   847,   854,   859,   864,   871,   878,   881,   889,
-     891,   894,   895,   897,   898,   902,   909,   913,   920,   923,
-     928,   935
+     340,   344,   351,   357,   360,   363,   366,   369,   372,   375,
+     378,   381,   384,   387,   394,   400,   409,   416,   423,   430,
+     438,   446,   453,   460,   469,   478,   482,   484,   486,   488,
+     490,   493,   496,   501,   504,   506,   511,   514,   519,   520,
+     528,   529,   537,   538,   546,   547,   555,   559,   564,   565,
+     567,   569,   571,   575,   579,   583,   587,   591,   595,   597,
+     598,   600,   602,   604,   605,   608,   612,   614,   616,   620,
+     622,   623,   632,   634,   636,   640,   642,   644,   647,   648,
+     650,   652,   653,   658,   659,   661,   663,   665,   667,   669,
+     671,   673,   675,   677,   681,   683,   689,   691,   693,   695,
+     697,   700,   703,   706,   710,   713,   714,   716,   718,   720,
+     723,   726,   730,   740,   750,   759,   773,   775,   777,   784,
+     790,   793,   800,   808,   810,   814,   816,   817,   820,   822,
+     828,   834,   840,   847,   854,   857,   862,   867,   874,   879,
+     884,   889,   894,   901,   908,   911,   919,   921,   924,   925,
+     927,   928,   932,   939,   943,   950,   953,   958,   965
 };
 
 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
-static const short yyrhs[] =
+static const short int yyrhs[] =
 {
-     198,     0,    -1,    19,    -1,    20,    -1,    17,    -1,    18,
+     200,     0,    -1,     5,    -1,     6,    -1,     3,    -1,     4,
       -1,    79,    -1,    80,    -1,    81,    -1,    82,    -1,    83,
       -1,    84,    -1,    85,    -1,    86,    -1,    87,    -1,    88,
       -1,    89,    -1,    90,    -1,    91,    -1,    92,    -1,    93,
       -1,    94,    -1,    95,    -1,    96,    -1,    97,    -1,    98,
-      -1,   101,    -1,   102,    -1,   103,    -1,   104,    -1,   105,
-      -1,   106,    -1,   117,    -1,   118,    -1,   119,    -1,   120,
-      -1,   107,    -1,   108,    -1,   109,    -1,   110,    -1,   111,
-      -1,   112,    -1,   113,    -1,   114,    -1,   115,    -1,   116,
-      -1,   117,    -1,   118,    -1,   119,    -1,   120,    -1,    25,
-      -1,    26,    -1,   129,    -1,   130,    -1,   131,    -1,   132,
-      -1,   138,    -1,   139,    -1,   140,    -1,   141,    -1,   142,
-      -1,   143,    -1,   144,    -1,   145,    -1,   146,    -1,   147,
-      -1,   148,    -1,   149,    -1,   137,    -1,    11,    -1,     9,
-      -1,     7,    -1,     5,    -1,    12,    -1,    10,    -1,     8,
-      -1,     6,    -1,   174,    -1,   175,    -1,    13,    -1,    14,
-      -1,   207,   150,    -1,    -1,    42,    -1,    43,    -1,    44,
-      -1,    48,    -1,    45,    -1,    46,    -1,    47,    -1,    -1,
-      65,    -1,    66,    -1,    67,    -1,    68,    -1,    69,    -1,
-      70,    -1,    64,    18,    -1,    -1,    -1,    56,    18,    -1,
-      -1,   151,    56,    18,    -1,    37,    30,    -1,    -1,   183,
-      -1,    -1,   151,   186,   185,    -1,   183,    -1,    56,    18,
-      -1,   189,    -1,     3,    -1,   191,    -1,     3,    -1,   191,
-      -1,     4,    -1,     5,    -1,     6,    -1,     7,    -1,     8,
+      -1,   119,    -1,   120,    -1,   121,    -1,   122,    -1,   123,
+      -1,   124,    -1,   125,    -1,   126,    -1,   127,    -1,   128,
+      -1,   129,    -1,   130,    -1,   131,    -1,   132,    -1,   133,
+      -1,   134,    -1,   135,    -1,   136,    -1,   137,    -1,   138,
+      -1,   125,    -1,   126,    -1,   127,    -1,   128,    -1,    27,
+      -1,    28,    -1,   109,    -1,   110,    -1,   111,    -1,   112,
+      -1,   140,    -1,   141,    -1,   142,    -1,   143,    -1,   144,
+      -1,   145,    -1,   146,    -1,   147,    -1,   148,    -1,   149,
+      -1,   150,    -1,   151,    -1,   139,    -1,    16,    -1,    14,
+      -1,    12,    -1,    10,    -1,    17,    -1,    15,    -1,    13,
+      -1,    11,    -1,   176,    -1,   177,    -1,    18,    -1,    19,
+      -1,   212,   152,    -1,    -1,    41,    -1,    42,    -1,    43,
+      -1,    44,    -1,    45,    -1,    46,    -1,    47,    -1,    -1,
+      -1,    65,    -1,    66,    -1,    67,    -1,    68,    -1,    69,
+      -1,    70,    -1,    64,     4,    -1,    -1,    57,     4,    -1,
+      -1,   153,    57,     4,    -1,    34,    24,    -1,    -1,   185,
+      -1,    -1,   153,   188,   187,    -1,   185,    -1,    57,     4,
+      -1,   191,    -1,     8,    -1,   193,    -1,     8,    -1,   193,
       -1,     9,    -1,    10,    -1,    11,    -1,    12,    -1,    13,
-      -1,    14,    -1,    15,    -1,    16,    -1,   222,    -1,   190,
-      -1,   152,    18,    -1,   188,   153,   193,   154,    -1,   155,
-      18,   156,   191,   157,    -1,   158,    18,   156,   191,   159,
-      -1,   160,   192,   161,    -1,   160,   161,    -1,   158,   160,
-     192,   161,   159,    -1,   158,   160,   161,   159,    -1,   191,
-     162,    -1,   191,    -1,   192,   151,   191,    -1,   192,    -1,
-     192,   151,    40,    -1,    40,    -1,    -1,   189,   155,   196,
-     157,    -1,   189,   155,   157,    -1,   189,   163,    30,    -1,
-     189,   158,   196,   159,    -1,   189,   160,   196,   161,    -1,
-     189,   160,   161,    -1,   189,    22,    -1,   189,    23,    -1,
-     189,   222,    -1,   189,   195,    -1,   189,    24,    -1,   174,
-     166,    -1,   175,   166,    -1,     4,    25,    -1,     4,    26,
-      -1,   177,    21,    -1,   173,   153,   194,    39,   189,   154,
-      -1,   126,   153,   194,   237,   154,    -1,   128,   153,   194,
-     151,   194,   151,   194,   154,    -1,   167,   153,   194,   151,
-     194,   154,    -1,   168,   153,   194,   151,   194,   154,    -1,
-     169,   153,   194,   151,   194,   154,    -1,    99,   170,   153,
-     194,   151,   194,   154,    -1,   100,   171,   153,   194,   151,
-     194,   154,    -1,   172,   153,   194,   151,   194,   154,    -1,
-     134,   153,   194,   151,   194,   154,    -1,   135,   153,   194,
-     151,   194,   151,   194,   154,    -1,   136,   153,   194,   151,
-     194,   151,   194,   154,    -1,   196,   151,   194,    -1,   194,
-      -1,    35,    -1,    36,    -1,   199,    -1,   199,   216,    -1,
-     199,   218,    -1,   199,    62,    61,   202,    -1,   199,    31,
-      -1,   201,    -1,    49,    -1,    57,    -1,   201,   178,    27,
-     187,    -1,   201,   218,    -1,   201,    62,    61,   202,    -1,
-     201,   178,   179,   197,   194,   185,    -1,   201,   178,   200,
-     197,   189,   185,    -1,   201,   178,    45,   197,   189,   185,
-      -1,   201,   178,    47,   197,   189,   185,    -1,   201,    50,
-     204,    -1,   201,    58,   150,   205,    -1,    -1,    30,    -1,
-      55,    -1,    54,    -1,    52,   150,   203,    -1,    53,   150,
-      18,    -1,    51,   150,    30,    -1,    71,   150,    30,    -1,
-     155,   206,   157,    -1,   206,   151,    30,    -1,    30,    -1,
-      -1,    28,    -1,    30,    -1,   207,    -1,    -1,   189,   208,
-      -1,   210,   151,   209,    -1,   209,    -1,   210,    -1,   210,
-     151,    40,    -1,    40,    -1,    -1,   180,   187,   207,   153,
-     211,   154,   184,   181,    -1,    32,    -1,   160,    -1,   179,
-     212,   213,    -1,    33,    -1,   161,    -1,   214,   225,   215,
-      -1,    -1,    45,    -1,    47,    -1,    -1,    34,   219,   217,
-     212,    -1,    -1,    63,    -1,    17,    -1,    18,    -1,    21,
-      -1,    25,    -1,    26,    -1,    22,    -1,    23,    -1,    24,
-      -1,   158,   196,   159,    -1,   195,    -1,    61,   220,    30,
-     151,    30,    -1,   165,    -1,   207,    -1,   222,    -1,   221,
-      -1,   189,   223,    -1,   225,   226,    -1,   226,    -1,   227,
-     229,    -1,   227,   231,    -1,    -1,    29,    -1,    77,    -1,
-      76,    -1,    72,   224,    -1,    72,     3,    -1,    73,    15,
-     223,    -1,    73,     4,   223,   151,    15,   223,   151,    15,
-     223,    -1,    74,   176,   223,   151,    15,   223,   155,   230,
-     157,    -1,    74,   176,   223,   151,    15,   223,   155,   157,
-      -1,   178,    75,   180,   187,   223,   153,   234,   154,    39,
-      15,   223,   228,    15,   223,    -1,   228,    -1,    78,    -1,
-     230,   176,   221,   151,    15,   223,    -1,   176,   221,   151,
-      15,   223,    -1,   178,   236,    -1,   189,   155,   223,   151,
-     223,   157,    -1,   232,   151,   155,   223,   151,   223,   157,
-      -1,   224,    -1,   233,   151,   224,    -1,   233,    -1,    -1,
-      60,    59,    -1,    59,    -1,   167,   189,   223,   151,   223,
-      -1,   168,   189,   223,   151,   223,    -1,   169,   189,   223,
-     151,   223,    -1,    99,   170,   189,   223,   151,   223,    -1,
-     100,   171,   189,   223,   151,   223,    -1,   172,   224,   151,
-     224,    -1,   173,   224,    39,   189,    -1,   128,   224,   151,
-     224,   151,   224,    -1,   133,   224,   151,   189,    -1,   134,
-     224,   151,   224,    -1,   135,   224,   151,   224,   151,   224,
-      -1,   136,   224,   151,   224,   151,   224,    -1,   127,   232,
-      -1,   235,   180,   187,   223,   153,   234,   154,    -1,   239,
-      -1,   151,   233,    -1,    -1,    38,    -1,    -1,   121,   189,
-     182,    -1,   121,   189,   151,    10,   223,   182,    -1,   122,
-     189,   182,    -1,   122,   189,   151,    10,   223,   182,    -1,
-     123,   224,    -1,   238,   124,   189,   223,    -1,   238,   125,
-     224,   151,   189,   223,    -1,   126,   189,   223,   237,    -1
+      -1,    14,    -1,    15,    -1,    16,    -1,    17,    -1,    18,
+      -1,    19,    -1,    21,    -1,   192,    -1,    48,    -1,   227,
+      -1,   154,     4,    -1,   190,   155,   195,   156,    -1,   157,
+       4,   158,   193,   159,    -1,   160,     4,   158,   193,   161,
+      -1,   162,   194,   163,    -1,   162,   163,    -1,   160,   162,
+     194,   163,   161,    -1,   160,   162,   163,   161,    -1,   193,
+     164,    -1,   193,    -1,   194,   153,   193,    -1,   194,    -1,
+     194,   153,    37,    -1,    37,    -1,    -1,   191,   157,   198,
+     159,    -1,   191,   157,   159,    -1,   191,   165,    24,    -1,
+     191,   160,   198,   161,    -1,   191,   162,   198,   163,    -1,
+     191,   162,   163,    -1,   191,   160,   162,   198,   163,   161,
+      -1,   191,   160,   162,   163,   161,    -1,   191,    38,    -1,
+     191,    39,    -1,   191,   227,    -1,   191,   197,    -1,   191,
+      26,    -1,   176,   168,    -1,   177,     4,    -1,     9,    27,
+      -1,     9,    28,    -1,   179,     7,    -1,   175,   155,   196,
+      36,   191,   156,    -1,   106,   155,   196,   242,   156,    -1,
+     108,   155,   196,   153,   196,   153,   196,   156,    -1,   169,
+     155,   196,   153,   196,   156,    -1,   170,   155,   196,   153,
+     196,   156,    -1,   171,   155,   196,   153,   196,   156,    -1,
+      99,   172,   155,   196,   153,   196,   156,    -1,   100,   173,
+     155,   196,   153,   196,   156,    -1,   174,   155,   196,   153,
+     196,   156,    -1,   114,   155,   196,   153,   196,   156,    -1,
+     115,   155,   196,   153,   196,   153,   196,   156,    -1,   116,
+     155,   196,   153,   196,   153,   196,   156,    -1,   198,   153,
+     196,    -1,   196,    -1,    32,    -1,    33,    -1,   201,    -1,
+     201,   221,    -1,   201,   223,    -1,   201,    62,    61,   207,
+      -1,   201,    25,    -1,   202,    -1,   202,   180,    20,   189,
+      -1,   202,   223,    -1,   202,    62,    61,   207,    -1,    -1,
+     202,   180,   181,   199,   196,   203,   187,    -1,    -1,   202,
+     180,    50,   199,   191,   204,   187,    -1,    -1,   202,   180,
+      45,   199,   191,   205,   187,    -1,    -1,   202,   180,    47,
+     199,   191,   206,   187,    -1,   202,    51,   209,    -1,   202,
+      58,   152,   210,    -1,    -1,    24,    -1,    56,    -1,    55,
+      -1,    53,   152,   208,    -1,    54,   152,     4,    -1,    52,
+     152,    24,    -1,    71,   152,    24,    -1,   157,   211,   159,
+      -1,   211,   153,    24,    -1,    24,    -1,    -1,    22,    -1,
+      24,    -1,   212,    -1,    -1,   191,   213,    -1,   215,   153,
+     214,    -1,   214,    -1,   215,    -1,   215,   153,    37,    -1,
+      37,    -1,    -1,   182,   189,   212,   155,   216,   156,   186,
+     183,    -1,    29,    -1,   162,    -1,   181,   217,   218,    -1,
+      30,    -1,   163,    -1,   230,   220,    -1,    -1,    45,    -1,
+      47,    -1,    -1,    31,   224,   222,   217,    -1,    -1,    63,
+      -1,     3,    -1,     4,    -1,     7,    -1,    27,    -1,    28,
+      -1,    38,    -1,    39,    -1,    26,    -1,   160,   198,   161,
+      -1,   197,    -1,    61,   225,    24,   153,    24,    -1,   167,
+      -1,   212,    -1,   227,    -1,   226,    -1,   191,   228,    -1,
+     230,   231,    -1,   219,   231,    -1,   232,   180,   234,    -1,
+     232,   236,    -1,    -1,    23,    -1,    77,    -1,    78,    -1,
+      72,   229,    -1,    72,     8,    -1,    73,    21,   228,    -1,
+      73,     9,   228,   153,    21,   228,   153,    21,   228,    -1,
+      74,   178,   228,   153,    21,   228,   157,   235,   159,    -1,
+      74,   178,   228,   153,    21,   228,   157,   159,    -1,    75,
+     182,   189,   228,   155,   239,   156,    36,    21,   228,   233,
+      21,   228,    -1,   233,    -1,    76,    -1,   235,   178,   226,
+     153,    21,   228,    -1,   178,   226,   153,    21,   228,    -1,
+     180,   241,    -1,   191,   157,   228,   153,   228,   159,    -1,
+     237,   153,   157,   228,   153,   228,   159,    -1,   229,    -1,
+     238,   153,   229,    -1,   238,    -1,    -1,    60,    59,    -1,
+      59,    -1,   169,   191,   228,   153,   228,    -1,   170,   191,
+     228,   153,   228,    -1,   171,   191,   228,   153,   228,    -1,
+      99,   172,   191,   228,   153,   228,    -1,   100,   173,   191,
+     228,   153,   228,    -1,    49,   229,    -1,   174,   229,   153,
+     229,    -1,   175,   229,    36,   191,    -1,   108,   229,   153,
+     229,   153,   229,    -1,   113,   229,   153,   191,    -1,   117,
+     229,   153,   191,    -1,   118,   229,   153,   191,    -1,   114,
+     229,   153,   229,    -1,   115,   229,   153,   229,   153,   229,
+      -1,   116,   229,   153,   229,   153,   229,    -1,   107,   237,
+      -1,   240,   182,   189,   228,   155,   239,   156,    -1,   244,
+      -1,   153,   238,    -1,    -1,    35,    -1,    -1,   101,   191,
+     184,    -1,   101,   191,   153,    15,   228,   184,    -1,   102,
+     191,   184,    -1,   102,   191,   153,    15,   228,   184,    -1,
+     103,   229,    -1,   243,   104,   191,   228,    -1,   243,   105,
+     229,   153,   191,   228,    -1,   106,   191,   228,   242,    -1
 };
 
 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
-static const unsigned short yyrline[] =
+static const unsigned short int yyrline[] =
 {
-       0,  1036,  1036,  1036,  1037,  1037,  1041,  1041,  1041,  1041,
-    1041,  1041,  1041,  1042,  1042,  1042,  1042,  1043,  1043,  1043,
-    1044,  1044,  1044,  1044,  1044,  1044,  1045,  1045,  1045,  1045,
-    1045,  1045,  1045,  1045,  1045,  1045,  1046,  1046,  1046,  1046,
-    1046,  1046,  1046,  1046,  1046,  1046,  1047,  1047,  1047,  1047,
-    1047,  1047,  1048,  1048,  1048,  1048,  1049,  1049,  1049,  1049,
-    1049,  1049,  1049,  1049,  1050,  1050,  1050,  1050,  1050,  1055,
-    1055,  1055,  1055,  1056,  1056,  1056,  1056,  1057,  1057,  1058,
-    1058,  1061,  1064,  1069,  1069,  1069,  1069,  1069,  1069,  1070,
-    1071,  1074,  1074,  1074,  1074,  1074,  1075,  1076,  1081,  1086,
-    1087,  1090,  1091,  1099,  1105,  1106,  1109,  1110,  1119,  1120,
-    1133,  1133,  1134,  1134,  1135,  1139,  1139,  1139,  1139,  1139,
-    1139,  1139,  1140,  1140,  1140,  1140,  1140,  1142,  1145,  1148,
-    1151,  1155,  1168,  1174,  1180,  1190,  1193,  1203,  1206,  1214,
-    1218,  1225,  1226,  1231,  1236,  1246,  1253,  1259,  1266,  1273,
-    1280,  1286,  1293,  1300,  1308,  1315,  1322,  1329,  1336,  1343,
-    1350,  1358,  1372,  1384,  1389,  1395,  1400,  1406,  1411,  1416,
-    1424,  1429,  1434,  1444,  1449,  1454,  1454,  1464,  1469,  1472,
-    1477,  1481,  1485,  1488,  1488,  1491,  1501,  1506,  1511,  1521,
-    1531,  1541,  1551,  1556,  1561,  1566,  1568,  1568,  1571,  1576,
-    1583,  1588,  1595,  1602,  1607,  1608,  1616,  1616,  1617,  1617,
-    1619,  1628,  1632,  1636,  1639,  1644,  1647,  1650,  1673,  1674,
-    1678,  1689,  1690,  1692,  1701,  1702,  1703,  1707,  1707,  1721,
-    1722,  1725,  1725,  1725,  1725,  1725,  1725,  1725,  1726,  1727,
-    1732,  1733,  1742,  1742,  1746,  1752,  1763,  1772,  1775,  1783,
-    1787,  1792,  1795,  1801,  1801,  1803,  1808,  1813,  1818,  1826,
-    1836,  1845,  1867,  1872,  1878,  1884,  1892,  1910,  1919,  1929,
-    1933,  1940,  1941,  1945,  1950,  1953,  1964,  1974,  1985,  1995,
-    2005,  2016,  2046,  2055,  2062,  2071,  2078,  2085,  2091,  2142,
-    2147,  2148,  2152,  2153,  2156,  2165,  2175,  2184,  2195,  2202,
-    2213,  2224
+       0,  1607,  1607,  1608,  1616,  1617,  1627,  1627,  1627,  1627,
+    1627,  1627,  1627,  1627,  1627,  1627,  1627,  1631,  1631,  1631,
+    1635,  1635,  1635,  1635,  1635,  1635,  1639,  1639,  1640,  1640,
+    1641,  1641,  1642,  1642,  1643,  1643,  1647,  1647,  1648,  1648,
+    1649,  1649,  1650,  1650,  1651,  1651,  1652,  1652,  1653,  1653,
+    1654,  1655,  1658,  1658,  1658,  1658,  1662,  1662,  1662,  1662,
+    1662,  1662,  1662,  1663,  1663,  1663,  1663,  1663,  1663,  1669,
+    1669,  1669,  1669,  1673,  1673,  1673,  1673,  1677,  1677,  1681,
+    1681,  1686,  1689,  1694,  1695,  1696,  1697,  1698,  1699,  1700,
+    1701,  1705,  1706,  1707,  1708,  1709,  1710,  1711,  1712,  1722,
+    1723,  1731,  1732,  1740,  1749,  1750,  1757,  1758,  1762,  1766,
+    1782,  1783,  1790,  1791,  1798,  1806,  1806,  1806,  1806,  1806,
+    1806,  1806,  1807,  1807,  1807,  1807,  1807,  1812,  1816,  1820,
+    1825,  1834,  1850,  1856,  1869,  1878,  1882,  1893,  1897,  1910,
+    1914,  1921,  1922,  1928,  1935,  1947,  1977,  1990,  2013,  2041,
+    2063,  2074,  2096,  2107,  2116,  2121,  2179,  2186,  2194,  2201,
+    2208,  2212,  2216,  2225,  2240,  2253,  2262,  2290,  2303,  2312,
+    2318,  2324,  2333,  2339,  2345,  2356,  2357,  2366,  2367,  2379,
+    2388,  2389,  2390,  2391,  2392,  2408,  2428,  2430,  2432,  2432,
+    2439,  2439,  2446,  2446,  2453,  2453,  2461,  2463,  2465,  2470,
+    2484,  2485,  2489,  2492,  2500,  2504,  2511,  2515,  2519,  2523,
+    2531,  2531,  2535,  2536,  2540,  2548,  2553,  2561,  2562,  2569,
+    2576,  2580,  2686,  2686,  2690,  2700,  2700,  2704,  2708,  2710,
+    2711,  2715,  2715,  2727,  2728,  2733,  2734,  2735,  2736,  2737,
+    2738,  2739,  2740,  2741,  2762,  2765,  2780,  2781,  2786,  2786,
+    2794,  2803,  2806,  2815,  2825,  2830,  2839,  2850,  2850,  2853,
+    2856,  2859,  2863,  2869,  2884,  2890,  2941,  2944,  2950,  2960,
+    2973,  3002,  3010,  3018,  3022,  3029,  3030,  3034,  3037,  3043,
+    3060,  3076,  3090,  3102,  3114,  3125,  3134,  3143,  3152,  3159,
+    3180,  3204,  3210,  3216,  3222,  3238,  3311,  3319,  3320,  3324,
+    3325,  3329,  3335,  3341,  3347,  3353,  3360,  3372,  3386
 };
 #endif
 
-#if YYDEBUG || YYERROR_VERBOSE
-/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
+#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
+/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
    First, the terminals, then, starting at YYNTOKENS, nonterminals. */
 static const char *const yytname[] =
 {
-  "$end", "error", "$undefined", "VOID", "BOOL", "SBYTE", "UBYTE", "SHORT", 
-  "USHORT", "INT", "UINT", "LONG", "ULONG", "FLOAT", "DOUBLE", "LABEL", 
-  "OPAQUE", "ESINT64VAL", "EUINT64VAL", "SINTVAL", "UINTVAL", "FPVAL", 
-  "NULL_TOK", "UNDEF", "ZEROINITIALIZER", "TRUETOK", "FALSETOK", "TYPE", 
-  "VAR_ID", "LABELSTR", "STRINGCONSTANT", "IMPLEMENTATION", "BEGINTOK", 
-  "ENDTOK", "DECLARE", "GLOBAL", "CONSTANT", "SECTION", "VOLATILE", "TO", 
-  "DOTDOTDOT", "CONST", "INTERNAL", "LINKONCE", "WEAK", "DLLIMPORT", 
-  "DLLEXPORT", "EXTERN_WEAK", "APPENDING", "EXTERNAL", "TARGET", "TRIPLE", 
-  "ENDIAN", "POINTERSIZE", "LITTLE", "BIG", "ALIGN", "UNINITIALIZED", 
-  "DEPLIBS", "CALL", "TAIL", "ASM_TOK", "MODULE", "SIDEEFFECT", "CC_TOK", 
-  "CCC_TOK", "CSRETCC_TOK", "FASTCC_TOK", "COLDCC_TOK", 
-  "X86_STDCALLCC_TOK", "X86_FASTCALLCC_TOK", "DATALAYOUT", "RET", "BR", 
-  "SWITCH", "INVOKE", "EXCEPT", "UNWIND", "UNREACHABLE", "ADD", "SUB", 
-  "MUL", "DIV", "UDIV", "SDIV", "FDIV", "REM", "UREM", "SREM", "FREM", 
-  "AND", "OR", "XOR", "SETLE", "SETGE", "SETLT", "SETGT", "SETEQ", 
-  "SETNE", "ICMP", "FCMP", "EQ", "NE", "SLT", "SGT", "SLE", "SGE", "OEQ", 
-  "ONE", "OLT", "OGT", "OLE", "OGE", "ORD", "UNO", "UEQ", "UNE", "ULT", 
-  "UGT", "ULE", "UGE", "MALLOC", "ALLOCA", "FREE", "LOAD", "STORE", 
-  "GETELEMENTPTR", "PHI_TOK", "SELECT", "SHL", "SHR", "ASHR", "LSHR", 
-  "VAARG", "EXTRACTELEMENT", "INSERTELEMENT", "SHUFFLEVECTOR", "CAST", 
-  "TRUNC", "ZEXT", "SEXT", "FPTRUNC", "FPEXT", "FPTOUI", "FPTOSI", 
-  "UITOFP", "SITOFP", "PTRTOINT", "INTTOPTR", "BITCAST", "'='", "','", 
-  "'\\\\'", "'('", "')'", "'['", "'x'", "']'", "'<'", "'>'", "'{'", "'}'", 
-  "'*'", "'c'", "$accept", "IntVal", "EInt64Val", "ArithmeticOps", 
-  "LogicalOps", "SetCondOps", "IPredicates", "FPredicates", "ShiftOps", 
-  "CastOps", "SIntType", "UIntType", "IntType", "FPType", "OptAssign", 
-  "OptLinkage", "OptCallingConv", "OptAlign", "OptCAlign", 
-  "SectionString", "OptSection", "GlobalVarAttributes", 
-  "GlobalVarAttribute", "TypesV", "UpRTypesV", "Types", "PrimType", 
-  "UpRTypes", "TypeListI", "ArgTypeListI", "ConstVal", "ConstExpr", 
-  "ConstVector", "GlobalType", "Module", "DefinitionList", "External", 
-  "ConstPool", "AsmBlock", "BigOrLittle", "TargetDefinition", 
-  "LibrariesDefinition", "LibList", "Name", "OptName", "ArgVal", 
-  "ArgListH", "ArgList", "FunctionHeaderH", "BEGIN", "FunctionHeader", 
-  "END", "Function", "FnDeclareLinkage", "FunctionProto", "@1", 
-  "OptSideEffect", "ConstValueRef", "SymbolicValueRef", "ValueRef", 
-  "ResolvedVal", "BasicBlockList", "BasicBlock", "InstructionList", 
-  "Unwind", "BBTerminatorInst", "JumpTable", "Inst", "PHIList", 
-  "ValueRefList", "ValueRefListE", "OptTailCall", "InstVal", "IndexList", 
+  "$end", "error", "$undefined", "ESINT64VAL", "EUINT64VAL", "SINTVAL",
+  "UINTVAL", "FPVAL", "VOID", "BOOL", "SBYTE", "UBYTE", "SHORT", "USHORT",
+  "INT", "UINT", "LONG", "ULONG", "FLOAT", "DOUBLE", "TYPE", "LABEL",
+  "VAR_ID", "LABELSTR", "STRINGCONSTANT", "IMPLEMENTATION",
+  "ZEROINITIALIZER", "TRUETOK", "FALSETOK", "BEGINTOK", "ENDTOK",
+  "DECLARE", "GLOBAL", "CONSTANT", "SECTION", "VOLATILE", "TO",
+  "DOTDOTDOT", "NULL_TOK", "UNDEF", "CONST", "INTERNAL", "LINKONCE",
+  "WEAK", "APPENDING", "DLLIMPORT", "DLLEXPORT", "EXTERN_WEAK", "OPAQUE",
+  "NOT", "EXTERNAL", "TARGET", "TRIPLE", "ENDIAN", "POINTERSIZE", "LITTLE",
+  "BIG", "ALIGN", "DEPLIBS", "CALL", "TAIL", "ASM_TOK", "MODULE",
+  "SIDEEFFECT", "CC_TOK", "CCC_TOK", "CSRETCC_TOK", "FASTCC_TOK",
+  "COLDCC_TOK", "X86_STDCALLCC_TOK", "X86_FASTCALLCC_TOK", "DATALAYOUT",
+  "RET", "BR", "SWITCH", "INVOKE", "UNREACHABLE", "UNWIND", "EXCEPT",
+  "ADD", "SUB", "MUL", "DIV", "UDIV", "SDIV", "FDIV", "REM", "UREM",
+  "SREM", "FREM", "AND", "OR", "XOR", "SETLE", "SETGE", "SETLT", "SETGT",
+  "SETEQ", "SETNE", "ICMP", "FCMP", "MALLOC", "ALLOCA", "FREE", "LOAD",
+  "STORE", "GETELEMENTPTR", "PHI_TOK", "SELECT", "SHL", "SHR", "ASHR",
+  "LSHR", "VAARG", "EXTRACTELEMENT", "INSERTELEMENT", "SHUFFLEVECTOR",
+  "VAARG_old", "VANEXT_old", "EQ", "NE", "SLT", "SGT", "SLE", "SGE", "ULT",
+  "UGT", "ULE", "UGE", "OEQ", "ONE", "OLT", "OGT", "OLE", "OGE", "ORD",
+  "UNO", "UEQ", "UNE", "CAST", "TRUNC", "ZEXT", "SEXT", "FPTRUNC", "FPEXT",
+  "FPTOUI", "FPTOSI", "UITOFP", "SITOFP", "PTRTOINT", "INTTOPTR",
+  "BITCAST", "'='", "','", "'\\\\'", "'('", "')'", "'['", "'x'", "']'",
+  "'<'", "'>'", "'{'", "'}'", "'*'", "'c'", "$accept", "INTVAL",
+  "EINT64VAL", "ArithmeticOps", "LogicalOps", "SetCondOps", "IPredicates",
+  "FPredicates", "ShiftOps", "CastOps", "SIntType", "UIntType", "IntType",
+  "FPType", "OptAssign", "OptLinkage", "OptCallingConv", "OptAlign",
+  "OptCAlign", "SectionString", "OptSection", "GlobalVarAttributes",
+  "GlobalVarAttribute", "TypesV", "UpRTypesV", "Types", "PrimType",
+  "UpRTypes", "TypeListI", "ArgTypeListI", "ConstVal", "ConstExpr",
+  "ConstVector", "GlobalType", "Module", "FunctionList", "ConstPool", "@1",
+  "@2", "@3", "@4", "AsmBlock", "BigOrLittle", "TargetDefinition",
+  "LibrariesDefinition", "LibList", "Name", "OptName", "ArgVal",
+  "ArgListH", "ArgList", "FunctionHeaderH", "BEGIN", "FunctionHeader",
+  "END", "Function", "FnDeclareLinkage", "FunctionProto", "@5",
+  "OptSideEffect", "ConstValueRef", "SymbolicValueRef", "ValueRef",
+  "ResolvedVal", "BasicBlockList", "BasicBlock", "InstructionList",
+  "Unwind", "BBTerminatorInst", "JumpTable", "Inst", "PHIList",
+  "ValueRefList", "ValueRefListE", "OptTailCall", "InstVal", "IndexList",
   "OptVolatile", "MemoryInst", 0
 };
 #endif
@@ -1748,7 +2343,7 @@
 # ifdef YYPRINT
 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
    token YYLEX-NUM.  */
-static const unsigned short yytoknum[] =
+static const unsigned short int yytoknum[] =
 {
        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
@@ -1765,45 +2360,45 @@
      375,   376,   377,   378,   379,   380,   381,   382,   383,   384,
      385,   386,   387,   388,   389,   390,   391,   392,   393,   394,
      395,   396,   397,   398,   399,   400,   401,   402,   403,   404,
-      61,    44,    92,    40,    41,    91,   120,    93,    60,    62,
-     123,   125,    42,    99
+     405,   406,    61,    44,    92,    40,    41,    91,   120,    93,
+      60,    62,   123,   125,    42,    99
 };
 # endif
 
 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
 static const unsigned char yyr1[] =
 {
-       0,   164,   165,   165,   166,   166,   167,   167,   167,   167,
-     167,   167,   167,   167,   167,   167,   167,   168,   168,   168,
-     169,   169,   169,   169,   169,   169,   170,   170,   170,   170,
-     170,   170,   170,   170,   170,   170,   171,   171,   171,   171,
-     171,   171,   171,   171,   171,   171,   171,   171,   171,   171,
-     171,   171,   172,   172,   172,   172,   173,   173,   173,   173,
-     173,   173,   173,   173,   173,   173,   173,   173,   173,   174,
-     174,   174,   174,   175,   175,   175,   175,   176,   176,   177,
-     177,   178,   178,   179,   179,   179,   179,   179,   179,   179,
-     179,   180,   180,   180,   180,   180,   180,   180,   180,   181,
-     181,   182,   182,   183,   184,   184,   185,   185,   186,   186,
-     187,   187,   188,   188,   189,   190,   190,   190,   190,   190,
-     190,   190,   190,   190,   190,   190,   190,   191,   191,   191,
-     191,   191,   191,   191,   191,   191,   191,   191,   191,   192,
-     192,   193,   193,   193,   193,   194,   194,   194,   194,   194,
-     194,   194,   194,   194,   194,   194,   194,   194,   194,   194,
-     194,   195,   195,   195,   195,   195,   195,   195,   195,   195,
-     195,   195,   195,   196,   196,   197,   197,   198,   199,   199,
-     199,   199,   199,   200,   200,   201,   201,   201,   201,   201,
-     201,   201,   201,   201,   201,   202,   203,   203,   204,   204,
-     204,   204,   205,   206,   206,   206,   207,   207,   208,   208,
-     209,   210,   210,   211,   211,   211,   211,   212,   213,   213,
-     214,   215,   215,   216,   217,   217,   217,   219,   218,   220,
-     220,   221,   221,   221,   221,   221,   221,   221,   221,   221,
-     221,   221,   222,   222,   223,   223,   224,   225,   225,   226,
-     227,   227,   227,   228,   228,   229,   229,   229,   229,   229,
-     229,   229,   229,   229,   230,   230,   231,   232,   232,   233,
-     233,   234,   234,   235,   235,   236,   236,   236,   236,   236,
-     236,   236,   236,   236,   236,   236,   236,   236,   236,   236,
-     237,   237,   238,   238,   239,   239,   239,   239,   239,   239,
-     239,   239
+       0,   166,   167,   167,   168,   168,   169,   169,   169,   169,
+     169,   169,   169,   169,   169,   169,   169,   170,   170,   170,
+     171,   171,   171,   171,   171,   171,   172,   172,   172,   172,
+     172,   172,   172,   172,   172,   172,   173,   173,   173,   173,
+     173,   173,   173,   173,   173,   173,   173,   173,   173,   173,
+     173,   173,   174,   174,   174,   174,   175,   175,   175,   175,
+     175,   175,   175,   175,   175,   175,   175,   175,   175,   176,
+     176,   176,   176,   177,   177,   177,   177,   178,   178,   179,
+     179,   180,   180,   181,   181,   181,   181,   181,   181,   181,
+     181,   182,   182,   182,   182,   182,   182,   182,   182,   183,
+     183,   184,   184,   185,   186,   186,   187,   187,   188,   188,
+     189,   189,   190,   190,   191,   192,   192,   192,   192,   192,
+     192,   192,   192,   192,   192,   192,   192,   193,   193,   193,
+     193,   193,   193,   193,   193,   193,   193,   193,   193,   194,
+     194,   195,   195,   195,   195,   196,   196,   196,   196,   196,
+     196,   196,   196,   196,   196,   196,   196,   196,   196,   196,
+     196,   196,   196,   197,   197,   197,   197,   197,   197,   197,
+     197,   197,   197,   197,   197,   198,   198,   199,   199,   200,
+     201,   201,   201,   201,   201,   202,   202,   202,   203,   202,
+     204,   202,   205,   202,   206,   202,   202,   202,   202,   207,
+     208,   208,   209,   209,   209,   209,   210,   211,   211,   211,
+     212,   212,   213,   213,   214,   215,   215,   216,   216,   216,
+     216,   217,   218,   218,   219,   220,   220,   221,   222,   222,
+     222,   224,   223,   225,   225,   226,   226,   226,   226,   226,
+     226,   226,   226,   226,   226,   226,   227,   227,   228,   228,
+     229,   230,   230,   231,   232,   232,   232,   233,   233,   234,
+     234,   234,   234,   234,   234,   234,   234,   234,   235,   235,
+     236,   237,   237,   238,   238,   239,   239,   240,   240,   241,
+     241,   241,   241,   241,   241,   241,   241,   241,   241,   241,
+     241,   241,   241,   241,   241,   241,   241,   242,   242,   243,
+     243,   244,   244,   244,   244,   244,   244,   244,   244
 };
 
 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
@@ -1818,586 +2413,625 @@
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
        1,     2,     0,     1,     1,     1,     1,     1,     1,     1,
-       0,     1,     1,     1,     1,     1,     1,     2,     0,     0,
+       0,     0,     1,     1,     1,     1,     1,     1,     2,     0,
        2,     0,     3,     2,     0,     1,     0,     3,     1,     2,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
        2,     4,     5,     5,     3,     2,     5,     4,     2,     1,
        3,     1,     3,     1,     0,     4,     3,     3,     4,     4,
-       3,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     6,     5,     8,     6,     6,     6,     7,     7,     6,
-       6,     8,     8,     3,     1,     1,     1,     1,     2,     2,
-       4,     2,     1,     1,     1,     4,     2,     4,     6,     6,
-       6,     6,     3,     4,     0,     1,     1,     1,     3,     3,
-       3,     3,     3,     3,     1,     0,     1,     1,     1,     0,
-       2,     3,     1,     1,     3,     1,     0,     8,     1,     1,
-       3,     1,     1,     3,     0,     1,     1,     0,     4,     0,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     3,
-       1,     5,     1,     1,     1,     1,     2,     2,     1,     2,
-       2,     0,     1,     1,     1,     2,     2,     3,     9,     9,
-       8,    14,     1,     1,     6,     5,     2,     6,     7,     1,
-       3,     1,     0,     2,     1,     5,     5,     5,     6,     6,
-       4,     4,     6,     4,     4,     6,     6,     2,     7,     1,
-       2,     0,     1,     0,     3,     6,     3,     6,     2,     4,
-       6,     4
+       3,     6,     5,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     6,     5,     8,     6,     6,     6,     7,
+       7,     6,     6,     8,     8,     3,     1,     1,     1,     1,
+       2,     2,     4,     2,     1,     4,     2,     4,     0,     7,
+       0,     7,     0,     7,     0,     7,     3,     4,     0,     1,
+       1,     1,     3,     3,     3,     3,     3,     3,     1,     0,
+       1,     1,     1,     0,     2,     3,     1,     1,     3,     1,
+       0,     8,     1,     1,     3,     1,     1,     2,     0,     1,
+       1,     0,     4,     0,     1,     1,     1,     1,     1,     1,
+       1,     1,     1,     3,     1,     5,     1,     1,     1,     1,
+       2,     2,     2,     3,     2,     0,     1,     1,     1,     2,
+       2,     3,     9,     9,     8,    13,     1,     1,     6,     5,
+       2,     6,     7,     1,     3,     1,     0,     2,     1,     5,
+       5,     5,     6,     6,     2,     4,     4,     6,     4,     4,
+       4,     4,     6,     6,     2,     7,     1,     2,     0,     1,
+       0,     3,     6,     3,     6,     2,     4,     6,     4
 };
 
 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
    means the default is an error.  */
-static const unsigned short yydefact[] =
+static const unsigned short int yydefact[] =
 {
-     194,     0,    90,   182,     1,   181,   227,    83,    84,    85,
-      87,    88,    89,    86,     0,    98,   251,   178,   179,   206,
-     207,     0,     0,     0,    90,     0,   186,   224,     0,     0,
-      91,    92,    93,    94,    95,    96,     0,     0,   252,   251,
-     248,    82,     0,     0,     0,     0,   192,     0,     0,     0,
-       0,     0,   183,   184,     0,     0,    81,   225,   226,    98,
-     195,   180,    97,   111,   115,   116,   117,   118,   119,   120,
-     121,   122,   123,   124,   125,   126,   127,     2,     3,     0,
-       0,     0,     0,   242,     0,     0,   110,   129,   114,   243,
-     128,   218,   219,   220,   221,   222,   223,   247,     0,     0,
-       0,   254,   253,   263,   293,   262,   249,   250,     0,     0,
-       0,     0,   205,   193,   187,   185,   175,   176,     0,     0,
-       0,     0,   228,   130,     0,     0,     0,   113,   135,   139,
-       0,     0,   144,   138,   256,     0,   255,     0,     0,    72,
-      76,    71,    75,    70,    74,    69,    73,    77,    78,     0,
-     292,   274,     0,    98,     6,     7,     8,     9,    10,    11,
-      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
-      22,    23,    24,    25,     0,     0,     0,     0,     0,     0,
-       0,     0,    52,    53,    54,    55,     0,     0,     0,     0,
-      68,    56,    57,    58,    59,    60,    61,    62,    63,    64,
-      65,    66,    67,     0,     0,     0,     0,     0,    98,   266,
-       0,   289,   200,   197,   196,   198,   199,   201,   204,     0,
-     106,   106,   115,   116,   117,   118,   119,   120,   121,   122,
-     123,   124,   125,     0,     0,     0,     0,   106,   106,     0,
-       0,     0,     0,     0,   134,   216,   143,   141,     0,   231,
-     232,   233,   236,   237,   238,   234,   235,   229,     0,     0,
+     198,     0,    90,   184,     1,   183,   231,    83,    84,    85,
+      86,    87,    88,    89,     0,    91,   255,   180,   181,   255,
+     210,   211,     0,     0,     0,    90,     0,   186,   228,     0,
+       0,    92,    93,    94,    95,    96,    97,     0,     0,   256,
+     252,    82,   225,   226,   227,   251,     0,     0,     0,     0,
+     196,     0,     0,     0,     0,     0,     0,     0,    81,   229,
+     230,    91,   199,   182,    98,     2,     3,   111,   115,   116,
+     117,   118,   119,   120,   121,   122,   123,   124,   125,   126,
+     128,     0,     0,     0,     0,   246,     0,     0,   110,   127,
+     114,   247,   129,   222,   223,   224,   300,   254,     0,     0,
+       0,     0,   209,   197,   187,   185,   177,   178,     0,     0,
+       0,     0,   232,   130,     0,     0,     0,   113,   135,   139,
+       0,     0,   144,   138,   299,     0,   278,     0,     0,     0,
+       0,    91,   267,   257,   258,     6,     7,     8,     9,    10,
+      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
+      21,    22,    23,    24,    25,     0,     0,     0,     0,     0,
+       0,     0,     0,    52,    53,    54,    55,     0,     0,     0,
+       0,     0,     0,    68,    56,    57,    58,    59,    60,    61,
+      62,    63,    64,    65,    66,    67,     0,     0,     0,     0,
+       0,   266,   253,    91,   270,     0,   296,   204,   201,   200,
+     202,   203,   205,   208,     0,   192,   194,   190,   115,   116,
+     117,   118,   119,   120,   121,   122,   123,   124,   125,     0,
+       0,     0,     0,   188,     0,     0,     0,     0,     0,   134,
+     220,   143,   141,     0,     0,   284,   277,   260,   259,     0,
+       0,    72,    76,    71,    75,    70,    74,    69,    73,    77,
+      78,     0,     0,    26,    27,    28,    29,    30,    31,    32,
+      33,    34,    35,     0,    50,    51,    46,    47,    48,    49,
+      36,    37,    38,    39,    40,    41,    42,    43,    44,    45,
+       0,   101,   101,   305,     0,     0,   294,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   206,   106,   106,   106,   160,   161,     4,
+       5,   158,   159,   162,   157,   153,   154,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   240,   245,   244,   246,     0,   257,     0,   273,     0,
-      26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
-       0,    50,    51,    36,    37,    38,    39,    40,    41,    42,
-      43,    44,    45,    46,    47,    48,    49,     0,   101,   101,
-     298,     0,     0,   287,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   202,     0,
-     190,   191,   158,   159,     4,     5,   156,   157,   160,   151,
-     152,   155,     0,     0,     0,     0,   154,   153,   188,   189,
-     112,   112,   137,     0,   140,   215,   209,   212,   213,     0,
-       0,   131,   230,     0,     0,     0,     0,     0,     0,     0,
-       0,   174,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   294,     0,   296,   291,     0,     0,
+       0,     0,     0,   156,   155,   106,   112,   112,   137,     0,
+     140,   219,   213,   216,   217,     0,     0,   131,   235,   236,
+     237,   242,   238,   239,   240,   241,   233,     0,   244,   249,
+     248,   250,     0,   261,     0,     0,     0,     0,     0,   301,
+       0,   303,   298,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   203,     0,     0,   108,   106,   146,     0,
-       0,   150,     0,   147,   132,   133,   136,   208,   210,     0,
-     104,   142,     0,     0,     0,   291,     0,     0,     0,     0,
-       0,   239,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   301,     0,     0,     0,
-     283,   284,     0,     0,     0,     0,     0,   280,   281,     0,
-     299,     0,   103,   109,   107,   145,   148,   149,   214,   211,
-     105,    99,     0,     0,     0,     0,     0,     0,     0,     0,
-     173,     0,     0,     0,     0,     0,     0,     0,   272,     0,
-       0,   101,   102,   101,   269,   290,     0,     0,     0,     0,
-       0,   275,   276,   277,   272,     0,     0,   217,   241,     0,
-       0,   162,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   271,     0,   278,   279,     0,   295,   297,
-       0,     0,     0,   282,   285,   286,     0,   300,   100,     0,
-       0,     0,   170,     0,     0,   164,   165,   166,   169,   161,
-       0,   260,     0,     0,     0,   270,   267,     0,   288,   167,
-     168,     0,     0,     0,   258,     0,   259,     0,     0,   268,
-     163,   171,   172,     0,     0,     0,     0,     0,     0,   265,
-       0,     0,   264,     0,   261
+     207,     0,   193,   195,   191,     0,     0,     0,     0,     0,
+       0,     0,   146,   176,     0,     0,     0,   150,     0,   147,
+       0,     0,     0,     0,     0,   189,   132,   133,   136,   212,
+     214,     0,   104,   142,   234,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   308,     0,     0,     0,
+     288,   291,     0,     0,   289,   290,     0,     0,     0,   285,
+     286,     0,   306,     0,     0,     0,   108,   106,     0,     0,
+     298,     0,     0,     0,     0,     0,   145,   135,   114,     0,
+     148,   149,     0,     0,     0,     0,     0,   218,   215,   105,
+      99,     0,   243,     0,     0,   276,     0,     0,   101,   102,
+     101,   273,   297,     0,     0,     0,     0,     0,   279,   280,
+     281,   276,     0,   103,   109,   107,     0,     0,     0,     0,
+       0,     0,     0,   175,   152,     0,     0,     0,     0,     0,
+       0,     0,   221,     0,     0,     0,   275,     0,   282,   283,
+       0,   302,   304,     0,     0,     0,   287,   292,   293,     0,
+     307,     0,     0,   164,     0,     0,     0,     0,   151,     0,
+       0,     0,     0,     0,   100,   245,     0,     0,     0,   274,
+     271,     0,   295,     0,     0,     0,   172,     0,     0,   166,
+     167,   168,   171,   163,     0,   264,     0,     0,     0,   272,
+     169,   170,     0,     0,     0,   262,     0,   263,     0,     0,
+     165,   173,   174,     0,     0,     0,     0,     0,     0,   269,
+       0,     0,   268,   265
 };
 
 /* YYDEFGOTO[NTERM-NUM]. */
-static const short yydefgoto[] =
+static const short int yydefgoto[] =
 {
-      -1,    83,   336,   266,   267,   268,   290,   307,   269,   270,
-     233,   234,   149,   235,    24,    15,    36,   507,   384,   406,
-     471,   330,   407,    84,    85,   236,    87,    88,   130,   248,
-     371,   271,   372,   118,     1,     2,    55,     3,    61,   215,
-      46,   113,   219,    89,   418,   357,   358,   359,    37,    93,
-      16,    96,    17,    59,    18,    27,   363,   272,    90,   274,
-     494,    39,    40,    41,   105,   106,   553,   107,   313,   523,
-     524,   208,   209,   446,   210,   211
+      -1,    85,   311,   328,   329,   330,   263,   280,   331,   332,
+     219,   220,   251,   221,    25,    15,    37,   522,   369,   456,
+     480,   392,   457,    86,    87,   222,    89,    90,   120,   233,
+     403,   358,   404,   108,     1,     2,     3,   335,   306,   304,
+     305,    63,   200,    50,   103,   204,    91,   420,   343,   344,
+     345,    38,    95,    16,    44,    17,    61,    18,    28,   425,
+     359,    92,   361,   491,    19,    40,    41,   191,   192,   577,
+      97,   286,   526,   527,   193,   194,   436,   195,   196
 };
 
 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
    STATE-NUM.  */
-#define YYPACT_NINF -537
-static const short yypact[] =
+#define YYPACT_NINF -508
+static const short int yypact[] =
 {
-    -537,    75,    61,  1145,  -537,  -537,  -537,  -537,  -537,  -537,
-    -537,  -537,  -537,  -537,    18,   180,    55,  -537,  -537,  -537,
-    -537,   -28,   -61,    33,   130,   -40,  -537,   102,    87,   117,
-    -537,  -537,  -537,  -537,  -537,  -537,   838,   -24,  -537,   -15,
-    -537,    48,   -11,    -2,     6,    12,  -537,    11,    87,   838,
-      -9,    -9,  -537,  -537,    -9,    -9,  -537,  -537,  -537,   180,
-    -537,  -537,  -537,    32,  -537,  -537,  -537,  -537,  -537,  -537,
-    -537,  -537,  -537,  -537,  -537,  -537,  -537,  -537,  -537,   164,
-     171,    -6,   512,  -537,   135,    41,  -537,  -537,  -103,  -537,
-    -537,  -537,  -537,  -537,  -537,  -537,  -537,  -537,   883,    45,
-     192,  -537,  -537,  -537,  1324,  -537,  -537,  -537,   175,   126,
-     190,   188,   203,  -537,  -537,  -537,  -537,  -537,   911,   911,
-     957,   911,  -537,  -537,    81,    97,   561,  -537,  -537,  -103,
-    -109,   121,   641,  -537,    32,  1140,  -537,  1140,  1140,  -537,
-    -537,  -537,  -537,  -537,  -537,  -537,  -537,  -537,  -537,  1140,
-    -537,  -537,   219,   180,  -537,  -537,  -537,  -537,  -537,  -537,
-    -537,  -537,  -537,  -537,  -537,  -537,  -537,  -537,  -537,  -537,
-    -537,  -537,  -537,  -537,    10,   112,   911,   911,   911,   911,
-     911,   911,  -537,  -537,  -537,  -537,   911,   911,   911,   911,
-    -537,  -537,  -537,  -537,  -537,  -537,  -537,  -537,  -537,  -537,
-    -537,  -537,  -537,   911,   911,   911,   911,   911,   180,  -537,
-      59,  -537,  -537,  -537,  -537,  -537,  -537,  -537,  -537,   -71,
-     129,   129,   167,   193,   195,   218,   222,   224,   234,   243,
-     250,   261,   263,   252,   252,   264,   993,   129,   129,   911,
-     911,   127,   -97,   911,  -537,   680,  -537,   136,   137,  -537,
-    -537,  -537,  -537,  -537,  -537,  -537,  -537,   229,    10,   112,
-     140,   141,   144,   145,   146,   957,   147,   148,   150,   154,
-     155,  -537,  -537,  -537,  -537,   158,  -537,   160,  -537,   838,
-    -537,  -537,  -537,  -537,  -537,  -537,  -537,  -537,  -537,  -537,
-     911,  -537,  -537,  -537,  -537,  -537,  -537,  -537,  -537,  -537,
-    -537,  -537,  -537,  -537,  -537,  -537,  -537,   911,   163,   165,
-    -537,  1140,   162,   169,   170,   172,   173,   174,   176,  1140,
-    1140,  1140,   177,   276,   838,   911,   911,   288,  -537,    -8,
-    -537,  -537,  -537,  -537,  -537,  -537,  -537,  -537,  -537,  -537,
-    -537,  -537,   724,   957,   590,   292,  -537,  -537,  -537,  -537,
-    -106,  -104,  -537,   179,  -103,  -537,   135,  -537,   178,   181,
-     752,  -537,  -537,   296,   183,   187,   957,   957,   957,   957,
-     957,  -537,  -131,   957,   957,   957,   957,   957,   315,   316,
-    1140,  1140,  1140,     1,  -537,     7,  -537,   191,  1140,   186,
-     911,   911,   911,   911,   911,   194,   197,   201,   911,   911,
-    1140,  1140,   202,  -537,   304,   326,  -537,   129,  -537,   -60,
-     -78,  -537,   -74,  -537,  -537,  -537,  -537,  -537,  -537,   799,
-     309,  -537,   208,   957,   957,   191,   210,   213,   223,   225,
-     957,  -537,   230,   231,   235,   236,   308,  1140,  1140,   227,
-     237,   238,  1140,   357,  1140,   911,  -537,   239,  1140,   241,
-    -537,  -537,   242,   244,  1140,  1140,  1140,  -537,  -537,   248,
-    -537,   911,  -537,  -537,  -537,  -537,  -537,  -537,  -537,  -537,
-    -537,   338,   366,   246,   251,   249,   957,   957,   957,   957,
-    -537,   957,   957,   957,   957,   911,   253,   258,   911,  1140,
-    1140,   254,  -537,   254,  -537,   255,  1140,   256,   911,   911,
-     911,  -537,  -537,  -537,   911,  1140,   390,  -537,  -537,   957,
-     957,  -537,   265,   260,   266,   267,   268,   272,   274,   275,
-     277,   400,    29,   255,   280,  -537,  -537,   363,  -537,  -537,
-     911,   278,  1140,  -537,  -537,  -537,   282,  -537,  -537,   283,
-     287,   957,  -537,   957,   957,  -537,  -537,  -537,  -537,  -537,
-    1140,  -537,  1229,    60,   381,  -537,  -537,   286,  -537,  -537,
-    -537,   290,   293,   294,  -537,   270,  -537,  1229,   435,  -537,
-    -537,  -537,  -537,   436,   302,  1140,  1140,   441,   196,  -537,
-    1140,   442,  -537,  1140,  -537
+    -508,    18,   144,   546,  -508,  -508,  -508,  -508,  -508,  -508,
+    -508,  -508,  -508,  -508,     2,   152,    47,  -508,  -508,   -15,
+    -508,  -508,   -30,   -75,    29,    69,   -10,  -508,    98,   104,
+     151,  -508,  -508,  -508,  -508,  -508,  -508,  1307,    -8,  -508,
+    -508,   149,  -508,  -508,  -508,  -508,    11,    20,    22,    24,
+    -508,    27,   104,  1307,     0,     0,     0,     0,  -508,  -508,
+    -508,   152,  -508,  -508,  -508,  -508,  -508,    37,  -508,  -508,
+    -508,  -508,  -508,  -508,  -508,  -508,  -508,  -508,  -508,  -508,
+    -508,   194,   200,     3,   695,  -508,   149,    54,  -508,  -508,
+     -81,  -508,  -508,  -508,  -508,  -508,  1561,  -508,   186,   -19,
+     210,   188,   203,  -508,  -508,  -508,  -508,  -508,  1368,  1368,
+    1368,  1409,  -508,  -508,    66,    70,   715,  -508,  -508,   -81,
+     -85,    75,   781,  -508,  -508,  1368,  -508,   172,  1429,    58,
+     255,   152,  -508,  -508,  -508,  -508,  -508,  -508,  -508,  -508,
+    -508,  -508,  -508,  -508,  -508,  -508,  -508,  -508,  -508,  -508,
+    -508,  -508,  -508,  -508,  -508,   208,   394,  1368,  1368,  1368,
+    1368,  1368,  1368,  -508,  -508,  -508,  -508,  1368,  1368,  1368,
+    1368,  1368,  1368,  -508,  -508,  -508,  -508,  -508,  -508,  -508,
+    -508,  -508,  -508,  -508,  -508,  -508,  1368,  1368,  1368,  1368,
+    1368,  -508,  -508,   152,  -508,    55,  -508,  -508,  -508,  -508,
+    -508,  -508,  -508,  -508,   -50,  -508,  -508,  -508,   153,   179,
+     228,   191,   229,   193,   230,   197,   231,   233,   234,   199,
+     232,   235,   537,  -508,  1368,  1368,    84,   -45,  1368,  -508,
+    1149,  -508,    93,    91,   898,  -508,  -508,    37,  -508,   898,
+     898,  -508,  -508,  -508,  -508,  -508,  -508,  -508,  -508,  -508,
+    -508,   898,  1307,  -508,  -508,  -508,  -508,  -508,  -508,  -508,
+    -508,  -508,  -508,  1368,  -508,  -508,  -508,  -508,  -508,  -508,
+    -508,  -508,  -508,  -508,  -508,  -508,  -508,  -508,  -508,  -508,
+    1368,    95,    96,  -508,   898,    99,    97,   105,   106,   107,
+     120,   123,   126,   127,   898,   898,   898,   128,   221,  1307,
+    1368,  1368,   258,  -508,   132,   132,   132,  -508,  -508,  -508,
+    -508,  -508,  -508,  -508,  -508,  -508,  -508,   208,   394,   131,
+     134,   135,   136,   137,  1190,  1470,   736,   259,   139,   140,
+     141,   142,   148,  -508,  -508,   132,  -130,   -23,  -508,   143,
+     -81,  -508,   149,  -508,   155,   154,  1210,  -508,  -508,  -508,
+    -508,  -508,  -508,  -508,  -508,  -508,   224,  1409,  -508,  -508,
+    -508,  -508,   156,  -508,   163,   898,   898,   898,     4,  -508,
+       5,  -508,   164,   898,   162,  1368,  1368,  1368,  1368,  1368,
+    1368,  1368,   167,   168,   169,  1368,  1368,   898,   898,   170,
+    -508,   -17,  -508,  -508,  -508,   150,   182,  1409,  1409,  1409,
+    1409,  1409,  -508,  -508,   -13,   756,   -24,  -508,   -36,  -508,
+    1409,  1409,  1409,  1409,  1409,  -508,  -508,  -508,  -508,  -508,
+    -508,  1251,   290,  -508,  -508,   301,   -14,   324,   325,   198,
+     201,   202,   898,   348,   898,  1368,  -508,   204,   898,   205,
+    -508,  -508,   211,   214,  -508,  -508,   898,   898,   898,  -508,
+    -508,   213,  -508,  1368,   332,   365,  -508,   132,  1409,  1409,
+     164,   217,   222,   223,   225,  1409,  -508,   216,   -71,   -27,
+    -508,  -508,   226,   236,   237,   240,   338,  -508,  -508,  -508,
+     326,   241,  -508,   898,   898,  1368,   898,   898,   242,  -508,
+     242,  -508,   243,   898,   244,  1368,  1368,  1368,  -508,  -508,
+    -508,  1368,   898,  -508,  -508,  -508,   246,   247,   245,  1409,
+    1409,  1409,  1409,  -508,  -508,   220,  1409,  1409,  1409,  1409,
+    1368,   378,  -508,   361,   249,   248,   243,   250,  -508,  -508,
+     329,  -508,  -508,  1368,   256,   898,  -508,  -508,  -508,   251,
+    -508,  1409,  1409,  -508,   261,   252,   270,   271,  -508,   269,
+     272,   275,   279,   280,  -508,  -508,   367,    40,   368,  -508,
+    -508,   267,  -508,   281,   282,  1409,  -508,  1409,  1409,  -508,
+    -508,  -508,  -508,  -508,   898,  -508,   996,    85,   382,  -508,
+    -508,  -508,   283,   285,   288,  -508,   274,  -508,   996,   898,
+    -508,  -508,  -508,   424,   293,   130,   898,   426,   430,  -508,
+     898,   898,  -508,  -508
 };
 
 /* YYPGOTO[NTERM-NUM].  */
-static const short yypgoto[] =
+static const short int yypgoto[] =
 {
-    -537,  -537,   226,   361,   362,   365,   209,   214,   368,   370,
-     -99,   -98,  -507,  -537,   420,   452,  -134,  -537,  -303,    57,
-    -537,  -216,  -537,   -45,  -537,   -36,  -537,   -79,   -30,  -537,
-    -111,   245,  -210,   104,  -537,  -537,  -537,  -537,   431,  -537,
-    -537,  -537,  -537,     4,  -537,    63,  -537,  -537,   421,  -537,
-    -537,  -537,  -537,  -537,   480,  -537,  -537,  -536,  -105,    58,
-     -88,  -537,   445,  -537,   -93,  -537,  -537,  -537,  -537,    42,
-     -18,  -537,  -537,    64,  -537,  -537
+    -508,  -508,  -508,   356,   357,   360,   145,   147,   371,   374,
+    -128,  -127,  -497,  -508,   416,   436,  -117,  -508,  -277,    41,
+    -508,  -296,  -508,   -47,  -508,   -37,  -508,   -58,    46,  -508,
+     -99,   253,  -298,    49,  -508,  -508,  -508,  -508,  -508,  -508,
+    -508,   419,  -508,  -508,  -508,  -508,     8,  -508,    51,  -508,
+    -508,   412,  -508,  -508,  -508,  -508,  -508,   471,  -508,  -508,
+    -507,  -209,    67,  -124,  -508,   457,  -508,  -118,  -508,  -508,
+    -508,  -508,    43,   -22,  -508,  -508,    21,  -508,  -508
 };
 
 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
    positive, shift that token.  If negative, reduce the rule which
    number is the opposite.  If zero, do what YYDEFACT says.
-   If YYTABLE_NINF, parse error.  */
-#define YYTABLE_NINF -178
-static const short yytable[] =
+   If YYTABLE_NINF, syntax error.  */
+#define YYTABLE_NINF -180
+static const short int yytable[] =
 {
-      86,   147,   148,   129,   115,   331,   386,    25,    91,   237,
-     136,   442,   125,    86,    38,   552,   565,   444,    94,   279,
-     430,   348,   349,    42,    43,    44,   116,   117,   431,   404,
-     273,   574,   273,   273,   139,   140,   141,   142,   143,   144,
-     145,   146,   243,    45,   273,    25,   567,   129,   405,   137,
-    -112,   414,   244,   129,   243,   415,   133,   443,   133,   133,
-     138,  -177,   135,   443,   353,   139,   140,   141,   142,   143,
-     144,   145,   146,   430,   324,     4,    19,   430,    20,    28,
-     327,   466,   220,   221,    38,   238,   328,   467,   131,    47,
-     310,   430,     5,   314,    48,     6,   242,   465,   315,   316,
-     317,   318,   247,     7,     8,     9,    10,    11,    12,    13,
-      56,   280,   281,   282,   283,   284,   285,    60,   322,   323,
-      98,    99,   100,    14,   101,   102,   103,   286,   287,   288,
-     289,   347,   409,   410,   412,    62,    92,   291,   292,   108,
-     308,   309,   135,   311,   312,   135,    95,    57,   109,    58,
-     135,   135,   135,   135,   126,   119,   110,    49,   120,   121,
-     350,   351,   111,    19,   354,    20,   112,   319,   320,   321,
-     135,   135,     7,     8,     9,    50,    11,    51,    13,    52,
-     213,   214,   123,   325,   326,  -113,   551,    53,   528,   124,
-     529,   464,   332,   333,   132,   275,   276,   139,   140,   141,
-     142,   143,   144,   145,   146,   212,   273,   277,   216,   356,
-     -72,   -72,   -76,   -76,   273,   273,   273,   566,   217,   293,
-     294,   295,   296,   297,   298,   299,   300,   301,   302,   303,
-     304,   305,   306,   218,   380,   -71,   -71,   239,   402,   -75,
-     -75,   -70,   -70,    86,    29,    30,    31,    32,    33,    34,
-      35,   -74,   -74,   240,   381,   425,   426,   427,   428,   429,
-     -69,   -69,   432,   433,   434,   435,   436,   -73,   -73,   334,
-     335,   382,   101,   102,   245,   273,   273,   273,   278,   400,
-     329,   354,   -79,   273,   -80,   338,   352,   360,    86,   401,
-     135,   361,   362,   366,   367,   273,   273,   368,   369,   370,
-     373,   374,   449,   375,   451,   452,   453,   376,   377,   378,
-     457,   379,   473,   474,   383,   399,   385,   388,   403,   480,
-     389,   390,   413,   391,   392,   393,   422,   394,   398,   419,
-     437,   438,   273,   273,   462,   420,   423,   273,   416,   273,
-     424,   448,   445,   273,   463,   454,   404,   485,   455,   273,
-     273,   273,   456,   461,   135,   450,   135,   135,   135,   472,
-     417,   476,   135,   458,   477,   512,   513,   514,   515,   387,
-     516,   517,   518,   519,   478,   492,   479,   395,   396,   397,
-     488,   481,   482,   356,   273,   273,   483,   484,   489,   490,
-     496,   273,   498,   499,   506,   500,   508,   509,   539,   540,
-     273,   504,   510,   511,   521,   527,   530,   532,   538,   135,
-     533,   534,   535,   522,   542,   550,   541,   543,   544,   443,
-     568,   573,   545,   147,   148,   505,   546,   273,   547,   548,
-     561,   549,   562,   563,   554,   556,   558,   559,   439,   440,
-     441,   560,   555,   569,   570,   273,   447,   571,   572,   520,
-     575,   576,   135,   577,   147,   148,   580,   583,   459,   460,
-     337,   104,   135,   135,   135,   203,   204,   364,   135,   205,
-     273,   273,   206,   365,   207,   273,    54,   470,   273,   114,
-     122,   346,   469,    26,    97,   581,   536,   495,     0,   475,
-       0,     0,     0,     0,   135,   486,   487,     0,     0,     0,
-     491,     0,   493,     0,     0,     0,   497,     0,     0,     0,
-       0,     0,   501,   502,   503,   127,    64,    65,    66,    67,
-      68,    69,    70,    71,    72,    73,    74,    75,    76,     0,
-       0,    77,    78,     0,     0,     0,     0,     0,     0,     0,
-      19,     0,    20,     0,     0,     0,     0,   525,   526,     0,
-       0,     0,     0,     0,   531,     0,     0,     0,     0,     0,
-       0,     0,     0,   537,   127,    64,    65,    66,    67,    68,
-      69,    70,    71,    72,    73,    74,    75,    76,     0,     0,
-      77,    78,     0,     0,     0,     0,     0,     0,     0,    19,
-     557,    20,     0,   127,   222,   223,   224,   225,   226,   227,
-     228,   229,   230,   231,   232,    75,    76,     0,   564,    77,
-      78,     0,     0,     0,     0,     0,     0,     0,    19,     0,
-      20,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   578,   579,     0,     0,     0,   582,     0,
-       0,   584,     0,     0,   127,    64,    65,    66,    67,    68,
-      69,    70,    71,    72,    73,    74,    75,    76,     0,     0,
-      77,    78,     0,     0,    79,     0,     0,    80,     0,    19,
-      81,    20,    82,   128,     0,     0,     0,     0,     0,     0,
-       0,   246,     0,   127,    64,    65,    66,    67,    68,    69,
-      70,    71,    72,    73,    74,    75,    76,     0,     0,    77,
-      78,     0,     0,     0,     0,     0,     0,     0,    19,     0,
-      20,     0,     0,    79,     0,     0,    80,     0,     0,    81,
-     355,    82,   241,     0,     0,     0,     0,   127,   222,   223,
-     224,   225,   226,   227,   228,   229,   230,   231,   232,    75,
-      76,     0,    79,    77,    78,    80,     0,     0,    81,     0,
-      82,   411,    19,     0,    20,   127,    64,    65,    66,    67,
-      68,    69,    70,    71,    72,    73,    74,    75,    76,     0,
-       0,    77,    78,     0,     0,     0,     0,     0,     0,     0,
-      19,     0,    20,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   421,    79,     0,     0,    80,     0,     0,    81,
-       0,    82,   127,    64,    65,    66,    67,    68,    69,    70,
-      71,    72,    73,    74,    75,    76,     0,     0,    77,    78,
-       0,     0,     0,     0,     0,     0,     0,    19,     0,    20,
-       0,     0,    79,     0,     0,    80,     0,     0,    81,   468,
-      82,    63,    64,    65,    66,    67,    68,    69,    70,    71,
-      72,    73,    74,    75,    76,     0,     0,    77,    78,     0,
-       0,     0,     0,     0,     0,     0,    19,     0,    20,     0,
-       0,     0,     0,     0,     0,     0,    79,     0,     0,    80,
-       0,   408,    81,     0,    82,     0,   134,    64,    65,    66,
-      67,    68,    69,    70,    71,    72,    73,    74,    75,    76,
-       0,     0,    77,    78,    79,     0,     0,    80,     0,     0,
-      81,    19,    82,    20,   127,    64,    65,    66,    67,    68,
-      69,    70,    71,    72,    73,    74,    75,    76,     0,     0,
-      77,    78,     0,     0,     0,     0,     0,     0,     0,    19,
-       0,    20,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,    79,     0,     0,    80,     0,     0,    81,     0,    82,
-     127,   222,   223,   224,   225,   226,   227,   228,   229,   230,
-     231,   232,    75,    76,     0,     0,    77,    78,     0,     0,
-       0,     0,     0,     0,     0,    19,     0,    20,     0,     0,
-      79,     0,     0,    80,     0,     0,    81,     0,    82,     0,
+      88,   235,   249,   250,   238,   371,   105,   115,    39,   393,
+     394,    26,   223,   334,   252,    42,    88,   454,     4,   432,
+     434,    93,    46,    47,    48,   360,   119,   406,   408,   416,
+     360,   360,   106,   107,   123,   283,   198,   199,   287,   415,
+     455,    49,   360,   288,   289,   290,   291,   292,   293,    26,
+     241,   242,   243,   244,   245,   246,   247,   248,   119,   426,
+     576,   433,   433,    29,   119,   297,   298,   239,   228,   586,
+      39,   205,   206,   207,  -112,   360,   299,    51,   229,   240,
+     588,   594,  -139,   123,  -112,   360,   360,   360,   234,    53,
+      52,   234,  -139,   123,   121,   241,   242,   243,   244,   245,
+     246,   247,   248,   302,   109,   110,   111,   469,   228,   303,
+       7,     8,     9,    10,    54,    12,    55,   465,   339,    56,
+     281,   282,   234,   284,   285,   234,   465,   471,    62,   465,
+     234,   234,   234,   234,   234,   234,   515,   470,   417,   465,
+     465,   123,    58,    59,  -179,    60,   466,   482,    43,   294,
+     295,   296,   234,   234,    94,    64,   360,   360,   360,   300,
+     301,   505,   227,    98,   360,   116,   336,   337,   232,     5,
+     340,    20,    99,    21,   100,     6,   101,   389,   360,   360,
+     307,   308,   -72,   -72,   102,     7,     8,     9,    10,    11,
+      12,    13,  -113,   342,   -71,   -71,   -70,   -70,   113,   575,
+     -69,   -69,   309,   310,   114,   365,    14,   133,   134,   122,
+     197,   531,   202,   532,   201,    88,    30,    31,    32,    33,
+      34,    35,    36,   360,   224,   360,   366,   203,   225,   360,
+     230,   236,   -76,   -75,   -74,   -73,   312,   360,   360,   360,
+     -79,   -80,   313,   367,   587,   338,   346,   347,   368,   370,
+     374,   439,   387,   441,   442,   443,   373,   386,   375,   376,
+     377,   449,    88,   388,   234,   241,   242,   243,   244,   245,
+     246,   247,   248,   378,   360,   360,   379,   360,   360,   380,
+     381,   385,   390,   409,   360,   391,   397,   424,   340,   398,
+     399,   400,   401,   360,   410,   411,   412,   413,   460,   461,
+     462,   463,   464,   414,   418,   458,   362,   363,   421,   427,
+     422,   472,   473,   474,   475,   476,   428,   435,   364,   438,
+     446,   447,   448,   453,   454,   481,   360,   253,   254,   255,
+     256,   257,   258,   259,   260,   261,   262,   459,   234,   440,
+     234,   234,   234,   444,   445,   483,   484,   468,   234,   450,
+     419,   372,   489,   485,   486,   487,   503,   493,   495,   506,
+     507,   382,   383,   384,   496,   360,   513,   497,   501,   504,
+     509,   536,   537,   538,   520,   510,   511,   514,   512,   516,
+     360,   548,   554,   521,   342,   555,   433,   360,   574,   517,
+     518,   360,   360,   519,   523,   530,   533,   535,   234,   541,
+     542,   543,   556,   589,   578,   557,   558,   562,   566,   559,
+     544,   545,   546,   547,   565,   560,   502,   549,   550,   551,
+     552,   264,   265,   567,   568,   569,   579,   593,   570,   249,
+     250,   571,   429,   430,   431,   572,   573,   580,   581,   590,
+     437,   591,   563,   564,   592,   596,   597,   600,   234,   249,
+     250,   601,   186,   187,   451,   452,   188,    96,   234,   234,
+     234,    57,   395,   479,   234,   396,   582,   189,   583,   584,
+     190,   104,   478,   112,    27,   333,    45,   598,   492,   539,
+       0,   508,     0,   553,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   234,     0,     0,   488,
+       0,   490,     0,     0,     0,   494,     0,     0,     0,     0,
+       0,     0,     0,   498,   499,   500,     0,     0,     0,   266,
+     267,   268,   269,   270,   271,   272,   273,   274,   275,   276,
+     277,   278,   279,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,    65,    66,     0,     0,     0,     0,     0,     0,
+     524,   525,     0,   528,   529,     0,     0,     0,     0,    20,
+     534,    21,     0,   314,     0,     0,   -82,     0,    20,   540,
+      21,     0,     0,     0,     0,   315,   316,     6,   -82,   -82,
+       0,     0,     0,     0,     0,     0,     0,   -82,   -82,   -82,
+     -82,   -82,   -82,   -82,     0,     0,   -82,    22,     0,     0,
+       0,     0,   561,     0,    23,     0,     0,     0,    24,     0,
+       0,     0,     0,     0,     0,     0,   135,   136,   137,   138,
+     139,   140,   141,   142,   143,   144,   145,   146,   147,   148,
+     149,   150,   151,   152,   153,   154,   317,   318,     0,     0,
+       0,   585,     0,   319,     0,   320,   163,   164,   165,   166,
+       0,   321,   322,   323,     0,     0,   595,     0,     0,     0,
+       0,     0,     0,   599,     0,     0,     0,   602,   603,     0,
+       0,     0,     0,     0,     0,     0,   173,   174,   175,   176,
+     177,   178,   179,   180,   181,   182,   183,   184,   185,     0,
+       0,     0,     0,     0,   324,     0,     0,   325,     0,   326,
+      65,    66,   327,   117,    68,    69,    70,    71,    72,    73,
+      74,    75,    76,    77,    78,     0,    79,    20,     0,    21,
+      65,    66,     0,   117,    68,    69,    70,    71,    72,    73,
+      74,    75,    76,    77,    78,     0,    79,    20,     0,    21,
+       0,    65,    66,    80,   117,   208,   209,   210,   211,   212,
+     213,   214,   215,   216,   217,   218,     0,    79,    20,     0,
+      21,    65,    66,    80,   117,   208,   209,   210,   211,   212,
+     213,   214,   215,   216,   217,   218,     0,    79,    20,     0,
+      21,     0,     0,     0,    80,     0,    65,    66,     0,   117,
+      68,    69,    70,    71,    72,    73,    74,    75,    76,    77,
+      78,     0,    79,    20,    80,    21,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   231,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,    80,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,    77,    78,     0,   339,   340,   341,     0,     0,
-       0,    19,     0,    20,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,    79,     0,     0,    80,     0,
-       0,    81,     0,    82,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,    81,
+       0,     0,    82,     0,     0,    83,     0,    84,   118,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,    81,
+       0,     0,    82,     0,     0,    83,     0,    84,   226,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,    79,     0,     0,    80,     0,     0,    81,
-       0,    82,   154,   155,   156,   157,   158,   159,   160,   161,
-     162,   163,   164,   165,   166,   167,   168,   169,   170,   171,
-     172,   173,   258,   259,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,    79,
-       0,     0,    80,     0,     0,    81,     0,    82,     0,   260,
-       0,   261,   182,   183,   184,   185,     0,   262,   263,   264,
-     190,   191,   192,   193,   194,   195,   196,   197,   198,   199,
-     200,   201,   202,     0,     0,     0,     0,     0,   342,     0,
-       0,   343,     0,   344,     0,     0,   345,   249,   250,    77,
-      78,   251,   252,   253,   254,   255,   256,     0,    19,     0,
-      20,     0,   -82,    19,     0,    20,     0,     0,     0,     6,
-     -82,   -82,     0,     0,     0,     0,     0,   -82,   -82,   -82,
-     -82,   -82,   -82,   -82,   -82,    21,     0,     0,     0,     0,
-       0,   257,   -82,    22,     0,     0,     0,    23,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   154,
-     155,   156,   157,   158,   159,   160,   161,   162,   163,   164,
-     165,   166,   167,   168,   169,   170,   171,   172,   173,   258,
-     259,     0,     0,     0,     0,     0,   249,   250,     0,     0,
-     251,   252,   253,   254,   255,   256,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   260,     0,   261,   182,
-     183,   184,   185,     0,   262,   263,   264,   190,   191,   192,
-     193,   194,   195,   196,   197,   198,   199,   200,   201,   202,
-     257,     0,     0,     0,     0,     0,     0,     0,   265,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   154,   155,
-     156,   157,   158,   159,   160,   161,   162,   163,   164,   165,
-     166,   167,   168,   169,   170,   171,   172,   173,   258,   259,
+      81,     0,     0,    82,     0,     0,    83,     0,    84,   407,
+       0,   348,   349,    65,    66,   350,     0,     0,     0,     0,
+      81,     0,     0,    82,     0,     0,    83,     0,    84,   467,
+      20,     0,    21,     0,   351,   352,   353,     0,     0,     0,
+       0,     0,     0,     0,     0,    81,   354,   355,    82,     0,
+       0,    83,     0,    84,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   356,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   135,   136,   137,
+     138,   139,   140,   141,   142,   143,   144,   145,   146,   147,
+     148,   149,   150,   151,   152,   153,   154,   317,   318,   348,
+     349,     0,     0,   350,   319,     0,   320,   163,   164,   165,
+     166,     0,   321,   322,   323,     0,     0,     0,     0,     0,
+       0,     0,   351,   352,   353,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   354,   355,     0,   173,   174,   175,
+     176,   177,   178,   179,   180,   181,   182,   183,   184,   185,
+       0,     0,     0,     0,     0,     0,     0,   356,   357,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   260,     0,   261,   182,   183,
-     184,   185,   150,   262,   263,   264,   190,   191,   192,   193,
-     194,   195,   196,   197,   198,   199,   200,   201,   202,     0,
-       0,     0,     0,   151,   152,     0,     0,   265,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   153,
-       0,     0,     0,   154,   155,   156,   157,   158,   159,   160,
-     161,   162,   163,   164,   165,   166,   167,   168,   169,   170,
-     171,   172,   173,   174,   175,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   135,   136,   137,   138,   139,
+     140,   141,   142,   143,   144,   145,   146,   147,   148,   149,
+     150,   151,   152,   153,   154,   317,   318,     0,     0,     0,
+       0,     0,   319,     0,   320,   163,   164,   165,   166,     0,
+     321,   322,   323,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   173,   174,   175,   176,   177,
+     178,   179,   180,   181,   182,   183,   184,   185,     0,     0,
+       0,     0,     0,     0,    65,    66,   357,   117,    68,    69,
+      70,    71,    72,    73,    74,    75,    76,    77,    78,     0,
+      79,    20,     0,    21,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   341,     0,     0,     0,
+       0,     0,     0,     0,     0,    65,    66,    80,   117,   208,
+     209,   210,   211,   212,   213,   214,   215,   216,   217,   218,
+       0,    79,    20,     0,    21,    65,    66,     0,   117,    68,
+      69,    70,    71,    72,    73,    74,    75,    76,    77,    78,
+       0,    79,    20,     0,    21,     0,     0,     0,    80,     0,
+       0,     0,     0,     0,     0,     0,     0,   423,     0,     0,
+       0,     0,     0,     0,     0,     0,    65,    66,    80,   117,
+      68,    69,    70,    71,    72,    73,    74,    75,    76,    77,
+      78,     0,    79,    20,     0,    21,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   477,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,    80,
+       0,     0,     0,    81,     0,     0,    82,     0,     0,    83,
+       0,    84,    65,    66,     0,    67,    68,    69,    70,    71,
+      72,    73,    74,    75,    76,    77,    78,     0,    79,    20,
+       0,    21,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,    81,     0,     0,    82,     0,   402,
+      83,     0,    84,     0,     0,    80,     0,     0,     0,     0,
+       0,     0,     0,     0,    81,     0,     0,    82,     0,     0,
+      83,     0,    84,    65,    66,     0,   117,    68,    69,    70,
+      71,    72,    73,    74,    75,    76,    77,    78,     0,    79,
+      20,     0,    21,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,    81,     0,     0,    82,     0,
+       0,    83,     0,    84,    65,    66,    80,   117,   208,   209,
+     210,   211,   212,   213,   214,   215,   216,   217,   218,     0,
+      79,    20,     0,    21,    65,    66,     0,   237,    68,    69,
+      70,    71,    72,    73,    74,    75,    76,    77,    78,     0,
+      79,    20,     0,    21,     0,     0,     0,    80,     0,     0,
+       0,    81,     0,     0,    82,     0,     0,    83,     0,    84,
+       0,     0,     0,     0,     0,    65,    66,    80,   117,   208,
+     209,   210,   211,   212,   213,   214,   215,   216,   217,   218,
+       0,    79,    20,     0,    21,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,    80,     0,
+       0,     0,    81,     0,     0,    82,     0,     0,    83,     0,
+      84,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,    81,     0,     0,    82,     0,     0,    83,
+       0,    84,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,    81,     0,     0,    82,     0,     0,    83,
+       0,    84,     0,     0,     0,     0,   124,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     125,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     126,   127,     0,     0,    81,     0,     0,    82,     0,     0,
+      83,     0,   405,   128,   129,   130,   131,   132,   133,   134,
+     135,   136,   137,   138,   139,   140,   141,   142,   143,   144,
+     145,   146,   147,   148,   149,   150,   151,   152,   153,   154,
+     155,   156,   157,   158,   159,     0,     0,   160,   161,   162,
+     163,   164,   165,   166,   167,   168,   169,   170,   171,   172,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   176,   177,   178,     0,     0,
-     179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
-     189,   190,   191,   192,   193,   194,   195,   196,   197,   198,
-     199,   200,   201,   202
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     173,   174,   175,   176,   177,   178,   179,   180,   181,   182,
+     183,   184,   185
 };
 
-static const short yycheck[] =
+static const short int yycheck[] =
 {
-      36,   100,   100,    82,    49,   221,   309,     3,    32,   120,
-      98,    10,    18,    49,    29,   522,   552,    10,    33,   153,
-     151,   237,   238,    51,    52,    53,    35,    36,   159,    37,
-     135,   567,   137,   138,     5,     6,     7,     8,     9,    10,
-      11,    12,   151,    71,   149,    41,   553,   126,    56,     4,
-     153,   157,   161,   132,   151,   159,   162,    56,   162,   162,
-      15,     0,    98,    56,   161,     5,     6,     7,     8,     9,
-      10,    11,    12,   151,   208,     0,    28,   151,    30,    61,
-     151,   159,   118,   119,    29,   121,   157,   161,    84,   150,
-     178,   151,    31,   181,    61,    34,   126,   157,   186,   187,
-     188,   189,   132,    42,    43,    44,    45,    46,    47,    48,
-     150,   101,   102,   103,   104,   105,   106,    30,   206,   207,
-      72,    73,    74,    62,    76,    77,    78,   117,   118,   119,
-     120,   236,   342,   343,   344,    18,   160,    25,    26,   150,
-     176,   177,   178,   179,   180,   181,   161,    45,   150,    47,
-     186,   187,   188,   189,   160,    51,   150,    27,    54,    55,
-     239,   240,   150,    28,   243,    30,   155,   203,   204,   205,
-     206,   207,    42,    43,    44,    45,    46,    47,    48,    49,
-      54,    55,    18,   124,   125,   153,   157,    57,   491,    18,
-     493,   407,    25,    26,   153,   137,   138,     5,     6,     7,
-       8,     9,    10,    11,    12,    30,   311,   149,    18,   245,
-      17,    18,    17,    18,   319,   320,   321,   157,    30,   107,
-     108,   109,   110,   111,   112,   113,   114,   115,   116,   117,
-     118,   119,   120,    30,   279,    17,    18,   156,   326,    17,
-      18,    17,    18,   279,    64,    65,    66,    67,    68,    69,
-      70,    17,    18,   156,   290,   366,   367,   368,   369,   370,
-      17,    18,   373,   374,   375,   376,   377,    17,    18,    17,
-      18,   307,    76,    77,   153,   380,   381,   382,    59,   324,
-     151,   360,    21,   388,    21,    21,   159,   151,   324,   325,
-     326,   154,    63,   153,   153,   400,   401,   153,   153,   153,
-     153,   153,   390,   153,   392,   393,   394,   153,   153,   151,
-     398,   151,   423,   424,   151,    39,   151,   155,    30,   430,
-     151,   151,    30,   151,   151,   151,    30,   151,   151,   151,
-      15,    15,   437,   438,    30,   154,   153,   442,   159,   444,
-     153,   155,   151,   448,    18,   151,    37,    39,   151,   454,
-     455,   456,   151,   151,   390,   391,   392,   393,   394,   151,
-     356,   151,   398,   399,   151,   476,   477,   478,   479,   311,
-     481,   482,   483,   484,   151,    18,   151,   319,   320,   321,
-     153,   151,   151,   419,   489,   490,   151,   151,   151,   151,
-     151,   496,   151,   151,    56,   151,    30,   151,   509,   510,
-     505,   153,   151,   154,   151,   151,   151,   151,    18,   445,
-     498,   499,   500,   155,   154,    15,   151,   151,   151,    56,
-      39,   151,   154,   522,   522,   461,   154,   532,   154,   154,
-     541,   154,   543,   544,   154,   157,   154,   154,   380,   381,
-     382,   154,   530,   157,   154,   550,   388,   154,   154,   485,
-      15,    15,   488,   151,   553,   553,    15,    15,   400,   401,
-     234,    41,   498,   499,   500,   104,   104,   258,   504,   104,
-     575,   576,   104,   259,   104,   580,    24,   420,   583,    48,
-      59,   236,   419,     3,    39,   578,   504,   445,    -1,   425,
-      -1,    -1,    -1,    -1,   530,   437,   438,    -1,    -1,    -1,
-     442,    -1,   444,    -1,    -1,    -1,   448,    -1,    -1,    -1,
-      -1,    -1,   454,   455,   456,     3,     4,     5,     6,     7,
-       8,     9,    10,    11,    12,    13,    14,    15,    16,    -1,
-      -1,    19,    20,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      28,    -1,    30,    -1,    -1,    -1,    -1,   489,   490,    -1,
-      -1,    -1,    -1,    -1,   496,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   505,     3,     4,     5,     6,     7,     8,
-       9,    10,    11,    12,    13,    14,    15,    16,    -1,    -1,
-      19,    20,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    28,
-     532,    30,    -1,     3,     4,     5,     6,     7,     8,     9,
-      10,    11,    12,    13,    14,    15,    16,    -1,   550,    19,
-      20,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    28,    -1,
-      30,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   575,   576,    -1,    -1,    -1,   580,    -1,
-      -1,   583,    -1,    -1,     3,     4,     5,     6,     7,     8,
-       9,    10,    11,    12,    13,    14,    15,    16,    -1,    -1,
-      19,    20,    -1,    -1,   152,    -1,    -1,   155,    -1,    28,
-     158,    30,   160,   161,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    40,    -1,     3,     4,     5,     6,     7,     8,     9,
-      10,    11,    12,    13,    14,    15,    16,    -1,    -1,    19,
-      20,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    28,    -1,
-      30,    -1,    -1,   152,    -1,    -1,   155,    -1,    -1,   158,
-      40,   160,   161,    -1,    -1,    -1,    -1,     3,     4,     5,
-       6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
-      16,    -1,   152,    19,    20,   155,    -1,    -1,   158,    -1,
-     160,   161,    28,    -1,    30,     3,     4,     5,     6,     7,
-       8,     9,    10,    11,    12,    13,    14,    15,    16,    -1,
-      -1,    19,    20,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      28,    -1,    30,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    40,   152,    -1,    -1,   155,    -1,    -1,   158,
-      -1,   160,     3,     4,     5,     6,     7,     8,     9,    10,
-      11,    12,    13,    14,    15,    16,    -1,    -1,    19,    20,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    28,    -1,    30,
-      -1,    -1,   152,    -1,    -1,   155,    -1,    -1,   158,    40,
-     160,     3,     4,     5,     6,     7,     8,     9,    10,    11,
-      12,    13,    14,    15,    16,    -1,    -1,    19,    20,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    28,    -1,    30,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   152,    -1,    -1,   155,
-      -1,   157,   158,    -1,   160,    -1,     3,     4,     5,     6,
-       7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
-      -1,    -1,    19,    20,   152,    -1,    -1,   155,    -1,    -1,
-     158,    28,   160,    30,     3,     4,     5,     6,     7,     8,
-       9,    10,    11,    12,    13,    14,    15,    16,    -1,    -1,
-      19,    20,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    28,
-      -1,    30,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   152,    -1,    -1,   155,    -1,    -1,   158,    -1,   160,
-       3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
-      13,    14,    15,    16,    -1,    -1,    19,    20,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    28,    -1,    30,    -1,    -1,
-     152,    -1,    -1,   155,    -1,    -1,   158,    -1,   160,    -1,
+      37,   125,   130,   130,   128,   282,    53,     4,    23,   305,
+     306,     3,   111,   222,   131,    30,    53,    34,     0,    15,
+      15,    29,    52,    53,    54,   234,    84,   325,   326,   159,
+     239,   240,    32,    33,   164,   159,    55,    56,   162,   335,
+      57,    71,   251,   167,   168,   169,   170,   171,   172,    41,
+      10,    11,    12,    13,    14,    15,    16,    17,   116,   357,
+     557,    57,    57,    61,   122,   189,   190,     9,   153,   576,
+      23,   108,   109,   110,   155,   284,   193,   152,   163,    21,
+     577,   588,   153,   164,   155,   294,   295,   296,   125,    20,
+      61,   128,   163,   164,    86,    10,    11,    12,    13,    14,
+      15,    16,    17,   153,    55,    56,    57,   405,   153,   159,
+      41,    42,    43,    44,    45,    46,    47,   153,   163,    50,
+     157,   158,   159,   160,   161,   162,   153,   163,    24,   153,
+     167,   168,   169,   170,   171,   172,   163,   161,   161,   153,
+     153,   164,   152,    45,     0,    47,   159,   161,   163,   186,
+     187,   188,   189,   190,   162,     4,   365,   366,   367,   104,
+     105,   457,   116,   152,   373,   162,   224,   225,   122,    25,
+     228,    22,   152,    24,   152,    31,   152,   301,   387,   388,
+      27,    28,     3,     4,   157,    41,    42,    43,    44,    45,
+      46,    47,   155,   230,     3,     4,     3,     4,     4,   159,
+       3,     4,     3,     4,     4,   252,    62,    77,    78,   155,
+      24,   488,    24,   490,     4,   252,    64,    65,    66,    67,
+      68,    69,    70,   432,   158,   434,   263,    24,   158,   438,
+     155,    59,     4,     4,     4,     4,     4,   446,   447,   448,
+       7,     7,     7,   280,   159,   161,   153,   156,   153,   153,
+     153,   375,   299,   377,   378,   379,   157,    36,   153,   153,
+     153,   385,   299,   300,   301,    10,    11,    12,    13,    14,
+      15,    16,    17,   153,   483,   484,   153,   486,   487,   153,
+     153,   153,    24,    24,   493,   153,   155,    63,   346,   155,
+     155,   155,   155,   502,   155,   155,   155,   155,   397,   398,
+     399,   400,   401,   155,   161,   155,   239,   240,   153,   153,
+     156,   410,   411,   412,   413,   414,   153,   153,   251,   157,
+     153,   153,   153,   153,    34,    24,   535,   119,   120,   121,
+     122,   123,   124,   125,   126,   127,   128,   155,   375,   376,
+     377,   378,   379,   380,   381,    21,    21,   405,   385,   386,
+     342,   284,     4,   155,   153,   153,    24,   153,   153,   458,
+     459,   294,   295,   296,   153,   574,   465,   153,   155,     4,
+     153,   495,   496,   497,    36,   153,   153,   161,   153,   153,
+     589,   161,     4,    57,   421,    24,    57,   596,    21,   153,
+     153,   600,   601,   153,   153,   153,   153,   153,   435,   153,
+     153,   156,   153,    21,    36,   157,   156,   156,   156,   533,
+     509,   510,   511,   512,   153,   159,   453,   516,   517,   518,
+     519,    27,    28,   153,   153,   156,   159,   153,   156,   557,
+     557,   156,   365,   366,   367,   156,   156,   156,   156,   156,
+     373,   156,   541,   542,   156,    21,   153,    21,   485,   577,
+     577,    21,    96,    96,   387,   388,    96,    41,   495,   496,
+     497,    25,   317,   422,   501,   318,   565,    96,   567,   568,
+      96,    52,   421,    61,     3,   222,    19,   595,   435,   501,
+      -1,   460,    -1,   520,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   533,    -1,    -1,   432,
+      -1,   434,    -1,    -1,    -1,   438,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   446,   447,   448,    -1,    -1,    -1,   125,
+     126,   127,   128,   129,   130,   131,   132,   133,   134,   135,
+     136,   137,   138,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,     5,     6,    -1,    -1,    -1,    -1,    -1,    -1,
+     483,   484,    -1,   486,   487,    -1,    -1,    -1,    -1,    22,
+     493,    24,    -1,    26,    -1,    -1,    20,    -1,    22,   502,
+      24,    -1,    -1,    -1,    -1,    38,    39,    31,    32,    33,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    41,    42,    43,
+      44,    45,    46,    47,    -1,    -1,    50,    51,    -1,    -1,
+      -1,    -1,   535,    -1,    58,    -1,    -1,    -1,    62,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    79,    80,    81,    82,
+      83,    84,    85,    86,    87,    88,    89,    90,    91,    92,
+      93,    94,    95,    96,    97,    98,    99,   100,    -1,    -1,
+      -1,   574,    -1,   106,    -1,   108,   109,   110,   111,   112,
+      -1,   114,   115,   116,    -1,    -1,   589,    -1,    -1,    -1,
+      -1,    -1,    -1,   596,    -1,    -1,    -1,   600,   601,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   139,   140,   141,   142,
+     143,   144,   145,   146,   147,   148,   149,   150,   151,    -1,
+      -1,    -1,    -1,    -1,   157,    -1,    -1,   160,    -1,   162,
+       5,     6,   165,     8,     9,    10,    11,    12,    13,    14,
+      15,    16,    17,    18,    19,    -1,    21,    22,    -1,    24,
+       5,     6,    -1,     8,     9,    10,    11,    12,    13,    14,
+      15,    16,    17,    18,    19,    -1,    21,    22,    -1,    24,
+      -1,     5,     6,    48,     8,     9,    10,    11,    12,    13,
+      14,    15,    16,    17,    18,    19,    -1,    21,    22,    -1,
+      24,     5,     6,    48,     8,     9,    10,    11,    12,    13,
+      14,    15,    16,    17,    18,    19,    -1,    21,    22,    -1,
+      24,    -1,    -1,    -1,    48,    -1,     5,     6,    -1,     8,
+       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
+      19,    -1,    21,    22,    48,    24,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    37,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    48,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    19,    20,    -1,    22,    23,    24,    -1,    -1,
-      -1,    28,    -1,    30,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   152,    -1,    -1,   155,    -1,
-      -1,   158,    -1,   160,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   154,
+      -1,    -1,   157,    -1,    -1,   160,    -1,   162,   163,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   154,
+      -1,    -1,   157,    -1,    -1,   160,    -1,   162,   163,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   152,    -1,    -1,   155,    -1,    -1,   158,
-      -1,   160,    79,    80,    81,    82,    83,    84,    85,    86,
-      87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
-      97,    98,    99,   100,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   152,
-      -1,    -1,   155,    -1,    -1,   158,    -1,   160,    -1,   126,
-      -1,   128,   129,   130,   131,   132,    -1,   134,   135,   136,
-     137,   138,   139,   140,   141,   142,   143,   144,   145,   146,
-     147,   148,   149,    -1,    -1,    -1,    -1,    -1,   155,    -1,
-      -1,   158,    -1,   160,    -1,    -1,   163,    17,    18,    19,
-      20,    21,    22,    23,    24,    25,    26,    -1,    28,    -1,
-      30,    -1,    27,    28,    -1,    30,    -1,    -1,    -1,    34,
-      35,    36,    -1,    -1,    -1,    -1,    -1,    42,    43,    44,
-      45,    46,    47,    48,    49,    50,    -1,    -1,    -1,    -1,
-      -1,    61,    57,    58,    -1,    -1,    -1,    62,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    79,
-      80,    81,    82,    83,    84,    85,    86,    87,    88,    89,
-      90,    91,    92,    93,    94,    95,    96,    97,    98,    99,
-     100,    -1,    -1,    -1,    -1,    -1,    17,    18,    -1,    -1,
-      21,    22,    23,    24,    25,    26,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   126,    -1,   128,   129,
-     130,   131,   132,    -1,   134,   135,   136,   137,   138,   139,
-     140,   141,   142,   143,   144,   145,   146,   147,   148,   149,
-      61,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   158,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    79,    80,
-      81,    82,    83,    84,    85,    86,    87,    88,    89,    90,
-      91,    92,    93,    94,    95,    96,    97,    98,    99,   100,
+     154,    -1,    -1,   157,    -1,    -1,   160,    -1,   162,   163,
+      -1,     3,     4,     5,     6,     7,    -1,    -1,    -1,    -1,
+     154,    -1,    -1,   157,    -1,    -1,   160,    -1,   162,   163,
+      22,    -1,    24,    -1,    26,    27,    28,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   154,    38,    39,   157,    -1,
+      -1,   160,    -1,   162,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    61,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    79,    80,    81,
+      82,    83,    84,    85,    86,    87,    88,    89,    90,    91,
+      92,    93,    94,    95,    96,    97,    98,    99,   100,     3,
+       4,    -1,    -1,     7,   106,    -1,   108,   109,   110,   111,
+     112,    -1,   114,   115,   116,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    26,    27,    28,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    38,    39,    -1,   139,   140,   141,
+     142,   143,   144,   145,   146,   147,   148,   149,   150,   151,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    61,   160,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   126,    -1,   128,   129,   130,
-     131,   132,    38,   134,   135,   136,   137,   138,   139,   140,
-     141,   142,   143,   144,   145,   146,   147,   148,   149,    -1,
-      -1,    -1,    -1,    59,    60,    -1,    -1,   158,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    75,
-      -1,    -1,    -1,    79,    80,    81,    82,    83,    84,    85,
-      86,    87,    88,    89,    90,    91,    92,    93,    94,    95,
-      96,    97,    98,    99,   100,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    79,    80,    81,    82,    83,
+      84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
+      94,    95,    96,    97,    98,    99,   100,    -1,    -1,    -1,
+      -1,    -1,   106,    -1,   108,   109,   110,   111,   112,    -1,
+     114,   115,   116,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   121,   122,   123,    -1,    -1,
-     126,   127,   128,   129,   130,   131,   132,   133,   134,   135,
-     136,   137,   138,   139,   140,   141,   142,   143,   144,   145,
-     146,   147,   148,   149
+      -1,    -1,    -1,    -1,    -1,   139,   140,   141,   142,   143,
+     144,   145,   146,   147,   148,   149,   150,   151,    -1,    -1,
+      -1,    -1,    -1,    -1,     5,     6,   160,     8,     9,    10,
+      11,    12,    13,    14,    15,    16,    17,    18,    19,    -1,
+      21,    22,    -1,    24,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    37,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,     5,     6,    48,     8,     9,
+      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+      -1,    21,    22,    -1,    24,     5,     6,    -1,     8,     9,
+      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+      -1,    21,    22,    -1,    24,    -1,    -1,    -1,    48,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    37,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,     5,     6,    48,     8,
+       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
+      19,    -1,    21,    22,    -1,    24,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    37,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    48,
+      -1,    -1,    -1,   154,    -1,    -1,   157,    -1,    -1,   160,
+      -1,   162,     5,     6,    -1,     8,     9,    10,    11,    12,
+      13,    14,    15,    16,    17,    18,    19,    -1,    21,    22,
+      -1,    24,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   154,    -1,    -1,   157,    -1,   159,
+     160,    -1,   162,    -1,    -1,    48,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   154,    -1,    -1,   157,    -1,    -1,
+     160,    -1,   162,     5,     6,    -1,     8,     9,    10,    11,
+      12,    13,    14,    15,    16,    17,    18,    19,    -1,    21,
+      22,    -1,    24,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   154,    -1,    -1,   157,    -1,
+      -1,   160,    -1,   162,     5,     6,    48,     8,     9,    10,
+      11,    12,    13,    14,    15,    16,    17,    18,    19,    -1,
+      21,    22,    -1,    24,     5,     6,    -1,     8,     9,    10,
+      11,    12,    13,    14,    15,    16,    17,    18,    19,    -1,
+      21,    22,    -1,    24,    -1,    -1,    -1,    48,    -1,    -1,
+      -1,   154,    -1,    -1,   157,    -1,    -1,   160,    -1,   162,
+      -1,    -1,    -1,    -1,    -1,     5,     6,    48,     8,     9,
+      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+      -1,    21,    22,    -1,    24,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    48,    -1,
+      -1,    -1,   154,    -1,    -1,   157,    -1,    -1,   160,    -1,
+     162,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   154,    -1,    -1,   157,    -1,    -1,   160,
+      -1,   162,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   154,    -1,    -1,   157,    -1,    -1,   160,
+      -1,   162,    -1,    -1,    -1,    -1,    35,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      49,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      59,    60,    -1,    -1,   154,    -1,    -1,   157,    -1,    -1,
+     160,    -1,   162,    72,    73,    74,    75,    76,    77,    78,
+      79,    80,    81,    82,    83,    84,    85,    86,    87,    88,
+      89,    90,    91,    92,    93,    94,    95,    96,    97,    98,
+      99,   100,   101,   102,   103,    -1,    -1,   106,   107,   108,
+     109,   110,   111,   112,   113,   114,   115,   116,   117,   118,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     139,   140,   141,   142,   143,   144,   145,   146,   147,   148,
+     149,   150,   151
 };
 
 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
    symbol of state STATE-NUM.  */
 static const unsigned char yystos[] =
 {
-       0,   198,   199,   201,     0,    31,    34,    42,    43,    44,
-      45,    46,    47,    48,    62,   179,   214,   216,   218,    28,
-      30,    50,    58,    62,   178,   207,   218,   219,    61,    64,
-      65,    66,    67,    68,    69,    70,   180,   212,    29,   225,
-     226,   227,    51,    52,    53,    71,   204,   150,    61,    27,
-      45,    47,    49,    57,   179,   200,   150,    45,    47,   217,
-      30,   202,    18,     3,     4,     5,     6,     7,     8,     9,
-      10,    11,    12,    13,    14,    15,    16,    19,    20,   152,
-     155,   158,   160,   165,   187,   188,   189,   190,   191,   207,
-     222,    32,   160,   213,    33,   161,   215,   226,    72,    73,
-      74,    76,    77,    78,   178,   228,   229,   231,   150,   150,
-     150,   150,   155,   205,   202,   187,    35,    36,   197,   197,
-     197,   197,   212,    18,    18,    18,   160,     3,   161,   191,
-     192,   207,   153,   162,     3,   189,   224,     4,    15,     5,
-       6,     7,     8,     9,    10,    11,    12,   174,   175,   176,
-      38,    59,    60,    75,    79,    80,    81,    82,    83,    84,
-      85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
-      95,    96,    97,    98,    99,   100,   121,   122,   123,   126,
-     127,   128,   129,   130,   131,   132,   133,   134,   135,   136,
-     137,   138,   139,   140,   141,   142,   143,   144,   145,   146,
-     147,   148,   149,   167,   168,   169,   172,   173,   235,   236,
-     238,   239,    30,    54,    55,   203,    18,    30,    30,   206,
-     189,   189,     4,     5,     6,     7,     8,     9,    10,    11,
-      12,    13,    14,   174,   175,   177,   189,   194,   189,   156,
-     156,   161,   192,   151,   161,   153,    40,   192,   193,    17,
-      18,    21,    22,    23,    24,    25,    26,    61,    99,   100,
-     126,   128,   134,   135,   136,   158,   167,   168,   169,   172,
-     173,   195,   221,   222,   223,   223,   223,   223,    59,   180,
-     101,   102,   103,   104,   105,   106,   117,   118,   119,   120,
-     170,    25,    26,   107,   108,   109,   110,   111,   112,   113,
-     114,   115,   116,   117,   118,   119,   120,   171,   189,   189,
-     224,   189,   189,   232,   224,   224,   224,   224,   224,   189,
-     189,   189,   224,   224,   180,   124,   125,   151,   157,   151,
-     185,   185,    25,    26,    17,    18,   166,   166,    21,    22,
-      23,    24,   155,   158,   160,   163,   195,   222,   185,   185,
-     191,   191,   159,   161,   191,    40,   189,   209,   210,   211,
-     151,   154,    63,   220,   170,   171,   153,   153,   153,   153,
-     153,   194,   196,   153,   153,   153,   153,   153,   151,   151,
-     187,   189,   189,   151,   182,   151,   182,   223,   155,   151,
-     151,   151,   151,   151,   151,   223,   223,   223,   151,    39,
-     187,   189,   224,    30,    37,    56,   183,   186,   157,   196,
-     196,   161,   196,    30,   157,   159,   159,   207,   208,   151,
-     154,    40,    30,   153,   153,   194,   194,   194,   194,   194,
-     151,   159,   194,   194,   194,   194,   194,    15,    15,   223,
-     223,   223,    10,    56,    10,   151,   237,   223,   155,   224,
-     189,   224,   224,   224,   151,   151,   151,   224,   189,   223,
-     223,   151,    30,    18,   185,   157,   159,   161,    40,   209,
-     183,   184,   151,   194,   194,   237,   151,   151,   151,   151,
-     194,   151,   151,   151,   151,    39,   223,   223,   153,   151,
-     151,   223,    18,   223,   224,   233,   151,   223,   151,   151,
-     151,   223,   223,   223,   153,   189,    56,   181,    30,   151,
-     151,   154,   194,   194,   194,   194,   194,   194,   194,   194,
-     189,   151,   155,   233,   234,   223,   223,   151,   182,   182,
-     151,   223,   151,   224,   224,   224,   234,   223,    18,   194,
-     194,   151,   154,   151,   151,   154,   154,   154,   154,   154,
-      15,   157,   176,   230,   154,   224,   157,   223,   154,   154,
-     154,   194,   194,   194,   223,   221,   157,   176,    39,   157,
-     154,   154,   154,   151,   221,    15,    15,   151,   223,   223,
-      15,   228,   223,    15,   223
+       0,   200,   201,   202,     0,    25,    31,    41,    42,    43,
+      44,    45,    46,    47,    62,   181,   219,   221,   223,   230,
+      22,    24,    51,    58,    62,   180,   212,   223,   224,    61,
+      64,    65,    66,    67,    68,    69,    70,   182,   217,    23,
+     231,   232,    30,   163,   220,   231,    52,    53,    54,    71,
+     209,   152,    61,    20,    45,    47,    50,   181,   152,    45,
+      47,   222,    24,   207,     4,     5,     6,     8,     9,    10,
+      11,    12,    13,    14,    15,    16,    17,    18,    19,    21,
+      48,   154,   157,   160,   162,   167,   189,   190,   191,   192,
+     193,   212,   227,    29,   162,   218,   180,   236,   152,   152,
+     152,   152,   157,   210,   207,   189,    32,    33,   199,   199,
+     199,   199,   217,     4,     4,     4,   162,     8,   163,   193,
+     194,   212,   155,   164,    35,    49,    59,    60,    72,    73,
+      74,    75,    76,    77,    78,    79,    80,    81,    82,    83,
+      84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
+      94,    95,    96,    97,    98,    99,   100,   101,   102,   103,
+     106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
+     116,   117,   118,   139,   140,   141,   142,   143,   144,   145,
+     146,   147,   148,   149,   150,   151,   169,   170,   171,   174,
+     175,   233,   234,   240,   241,   243,   244,    24,    55,    56,
+     208,     4,    24,    24,   211,   191,   191,   191,     9,    10,
+      11,    12,    13,    14,    15,    16,    17,    18,    19,   176,
+     177,   179,   191,   196,   158,   158,   163,   194,   153,   163,
+     155,    37,   194,   195,   191,   229,    59,     8,   229,     9,
+      21,    10,    11,    12,    13,    14,    15,    16,    17,   176,
+     177,   178,   182,   119,   120,   121,   122,   123,   124,   125,
+     126,   127,   128,   172,    27,    28,   125,   126,   127,   128,
+     129,   130,   131,   132,   133,   134,   135,   136,   137,   138,
+     173,   191,   191,   229,   191,   191,   237,   229,   229,   229,
+     229,   229,   229,   229,   191,   191,   191,   229,   229,   182,
+     104,   105,   153,   159,   205,   206,   204,    27,    28,     3,
+       4,   168,     4,     7,    26,    38,    39,    99,   100,   106,
+     108,   114,   115,   116,   157,   160,   162,   165,   169,   170,
+     171,   174,   175,   197,   227,   203,   193,   193,   161,   163,
+     193,    37,   191,   214,   215,   216,   153,   156,     3,     4,
+       7,    26,    27,    28,    38,    39,    61,   160,   197,   226,
+     227,   228,   228,   228,   228,   189,   191,   191,   153,   184,
+     153,   184,   228,   157,   153,   153,   153,   153,   153,   153,
+     153,   153,   228,   228,   228,   153,    36,   189,   191,   229,
+      24,   153,   187,   187,   187,   172,   173,   155,   155,   155,
+     155,   155,   159,   196,   198,   162,   198,   163,   198,    24,
+     155,   155,   155,   155,   155,   187,   159,   161,   161,   212,
+     213,   153,   156,    37,    63,   225,   198,   153,   153,   228,
+     228,   228,    15,    57,    15,   153,   242,   228,   157,   229,
+     191,   229,   229,   229,   191,   191,   153,   153,   153,   229,
+     191,   228,   228,   153,    34,    57,   185,   188,   155,   155,
+     196,   196,   196,   196,   196,   153,   159,   163,   193,   198,
+     161,   163,   196,   196,   196,   196,   196,    37,   214,   185,
+     186,    24,   161,    21,    21,   155,   153,   153,   228,     4,
+     228,   229,   238,   153,   228,   153,   153,   153,   228,   228,
+     228,   155,   191,    24,     4,   187,   196,   196,   242,   153,
+     153,   153,   153,   196,   161,   163,   153,   153,   153,   153,
+      36,    57,   183,   153,   228,   228,   238,   239,   228,   228,
+     153,   184,   184,   153,   228,   153,   229,   229,   229,   239,
+     228,   153,   153,   156,   196,   196,   196,   196,   161,   196,
+     196,   196,   196,   191,     4,    24,   153,   157,   156,   229,
+     159,   228,   156,   196,   196,   153,   156,   153,   153,   156,
+     156,   156,   156,   156,    21,   159,   178,   235,    36,   159,
+     156,   156,   196,   196,   196,   228,   226,   159,   178,    21,
+     156,   156,   156,   153,   226,   228,    21,   153,   233,   228,
+      21,    21,   228,   228
 };
 
-#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
-# define YYSIZE_T __SIZE_TYPE__
-#endif
-#if ! defined (YYSIZE_T) && defined (size_t)
-# define YYSIZE_T size_t
-#endif
-#if ! defined (YYSIZE_T)
-# if defined (__STDC__) || defined (__cplusplus)
-#  include  /* INFRINGES ON USER NAME SPACE */
-#  define YYSIZE_T size_t
-# endif
-#endif
-#if ! defined (YYSIZE_T)
-# define YYSIZE_T unsigned int
-#endif
-
 #define yyerrok		(yyerrstatus = 0)
 #define yyclearin	(yychar = YYEMPTY)
-#define YYEMPTY		-2
+#define YYEMPTY		(-2)
 #define YYEOF		0
 
 #define YYACCEPT	goto yyacceptlab
 #define YYABORT		goto yyabortlab
-#define YYERROR		goto yyerrlab1
+#define YYERROR		goto yyerrorlab
+
 
 /* Like YYERROR except do call yyerror.  This remains here temporarily
    to ease the transition to the new meaning of YYERROR, for GCC.
@@ -2413,34 +3047,71 @@
     {								\
       yychar = (Token);						\
       yylval = (Value);						\
-      yychar1 = YYTRANSLATE (yychar);				\
+      yytoken = YYTRANSLATE (yychar);				\
       YYPOPSTACK;						\
       goto yybackup;						\
     }								\
   else								\
-    { 								\
-      yyerror ("syntax error: cannot back up");			\
+    {								\
+      yyerror (YY_("syntax error: cannot back up")); \
       YYERROR;							\
     }								\
 while (0)
 
+
 #define YYTERROR	1
 #define YYERRCODE	256
 
-/* YYLLOC_DEFAULT -- Compute the default location (before the actions
-   are run).  */
 
+/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
+   If N is 0, then set CURRENT to the empty location which ends
+   the previous symbol: RHS[0] (always defined).  */
+
+#define YYRHSLOC(Rhs, K) ((Rhs)[K])
 #ifndef YYLLOC_DEFAULT
-# define YYLLOC_DEFAULT(Current, Rhs, N)           \
-  Current.first_line   = Rhs[1].first_line;      \
-  Current.first_column = Rhs[1].first_column;    \
-  Current.last_line    = Rhs[N].last_line;       \
-  Current.last_column  = Rhs[N].last_column;
+# define YYLLOC_DEFAULT(Current, Rhs, N)				\
+    do									\
+      if (N)								\
+	{								\
+	  (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;	\
+	  (Current).first_column = YYRHSLOC (Rhs, 1).first_column;	\
+	  (Current).last_line    = YYRHSLOC (Rhs, N).last_line;		\
+	  (Current).last_column  = YYRHSLOC (Rhs, N).last_column;	\
+	}								\
+      else								\
+	{								\
+	  (Current).first_line   = (Current).last_line   =		\
+	    YYRHSLOC (Rhs, 0).last_line;				\
+	  (Current).first_column = (Current).last_column =		\
+	    YYRHSLOC (Rhs, 0).last_column;				\
+	}								\
+    while (0)
 #endif
 
+
+/* YY_LOCATION_PRINT -- Print the location on the stream.
+   This macro was not mandated originally: define only if we know
+   we won't break user code: when these are the locations we know.  */
+
+#ifndef YY_LOCATION_PRINT
+# if YYLTYPE_IS_TRIVIAL
+#  define YY_LOCATION_PRINT(File, Loc)			\
+     fprintf (File, "%d.%d-%d.%d",			\
+              (Loc).first_line, (Loc).first_column,	\
+              (Loc).last_line,  (Loc).last_column)
+# else
+#  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
+# endif
+#endif
+
+
 /* YYLEX -- calling `yylex' with the right arguments.  */
 
-#define YYLEX	yylex ()
+#ifdef YYLEX_PARAM
+# define YYLEX yylex (YYLEX_PARAM)
+#else
+# define YYLEX yylex ()
+#endif
 
 /* Enable debugging if requested.  */
 #if YYDEBUG
@@ -2455,19 +3126,86 @@
   if (yydebug)					\
     YYFPRINTF Args;				\
 } while (0)
-# define YYDSYMPRINT(Args)			\
-do {						\
-  if (yydebug)					\
-    yysymprint Args;				\
+
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location)		\
+do {								\
+  if (yydebug)							\
+    {								\
+      YYFPRINTF (stderr, "%s ", Title);				\
+      yysymprint (stderr,					\
+                  Type, Value);	\
+      YYFPRINTF (stderr, "\n");					\
+    }								\
 } while (0)
+
+/*------------------------------------------------------------------.
+| yy_stack_print -- Print the state stack from its BOTTOM up to its |
+| TOP (included).                                                   |
+`------------------------------------------------------------------*/
+
+#if defined (__STDC__) || defined (__cplusplus)
+static void
+yy_stack_print (short int *bottom, short int *top)
+#else
+static void
+yy_stack_print (bottom, top)
+    short int *bottom;
+    short int *top;
+#endif
+{
+  YYFPRINTF (stderr, "Stack now");
+  for (/* Nothing. */; bottom <= top; ++bottom)
+    YYFPRINTF (stderr, " %d", *bottom);
+  YYFPRINTF (stderr, "\n");
+}
+
+# define YY_STACK_PRINT(Bottom, Top)				\
+do {								\
+  if (yydebug)							\
+    yy_stack_print ((Bottom), (Top));				\
+} while (0)
+
+
+/*------------------------------------------------.
+| Report that the YYRULE is going to be reduced.  |
+`------------------------------------------------*/
+
+#if defined (__STDC__) || defined (__cplusplus)
+static void
+yy_reduce_print (int yyrule)
+#else
+static void
+yy_reduce_print (yyrule)
+    int yyrule;
+#endif
+{
+  int yyi;
+  unsigned long int yylno = yyrline[yyrule];
+  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu), ",
+             yyrule - 1, yylno);
+  /* Print the symbols being reduced, and their result.  */
+  for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
+    YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
+  YYFPRINTF (stderr, "-> %s\n", yytname[yyr1[yyrule]]);
+}
+
+# define YY_REDUCE_PRINT(Rule)		\
+do {					\
+  if (yydebug)				\
+    yy_reduce_print (Rule);		\
+} while (0)
+
 /* Nonzero means print parse trace.  It is left uninitialized so that
    multiple parsers can coexist.  */
 int yydebug;
 #else /* !YYDEBUG */
 # define YYDPRINTF(Args)
-# define YYDSYMPRINT(Args)
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
+# define YY_STACK_PRINT(Bottom, Top)
+# define YY_REDUCE_PRINT(Rule)
 #endif /* !YYDEBUG */
 
+
 /* YYINITDEPTH -- initial size of the parser's stacks.  */
 #ifndef	YYINITDEPTH
 # define YYINITDEPTH 200
@@ -2477,13 +3215,9 @@
    if the built-in stack extension method is used).
 
    Do not make this value too large; the results are undefined if
-   SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
+   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
    evaluated with infinite-precision integer arithmetic.  */
 
-#if YYMAXDEPTH == 0
-# undef YYMAXDEPTH
-#endif
-
 #ifndef YYMAXDEPTH
 # define YYMAXDEPTH 10000
 #endif
@@ -2505,7 +3239,7 @@
      const char *yystr;
 #   endif
 {
-  register const char *yys = yystr;
+  const char *yys = yystr;
 
   while (*yys++ != '\0')
     continue;
@@ -2530,8 +3264,8 @@
      const char *yysrc;
 #   endif
 {
-  register char *yyd = yydest;
-  register const char *yys = yysrc;
+  char *yyd = yydest;
+  const char *yys = yysrc;
 
   while ((*yyd++ = *yys++) != '\0')
     continue;
@@ -2541,124 +3275,186 @@
 #  endif
 # endif
 
-#endif /* !YYERROR_VERBOSE */
+# ifndef yytnamerr
+/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
+   quotes and backslashes, so that it's suitable for yyerror.  The
+   heuristic is that double-quoting is unnecessary unless the string
+   contains an apostrophe, a comma, or backslash (other than
+   backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
+   null, do not copy; instead, return the length of what the result
+   would have been.  */
+static YYSIZE_T
+yytnamerr (char *yyres, const char *yystr)
+{
+  if (*yystr == '"')
+    {
+      size_t yyn = 0;
+      char const *yyp = yystr;
+
+      for (;;)
+	switch (*++yyp)
+	  {
+	  case '\'':
+	  case ',':
+	    goto do_not_strip_quotes;
+
+	  case '\\':
+	    if (*++yyp != '\\')
+	      goto do_not_strip_quotes;
+	    /* Fall through.  */
+	  default:
+	    if (yyres)
+	      yyres[yyn] = *yyp;
+	    yyn++;
+	    break;
+
+	  case '"':
+	    if (yyres)
+	      yyres[yyn] = '\0';
+	    return yyn;
+	  }
+    do_not_strip_quotes: ;
+    }
+
+  if (! yyres)
+    return yystrlen (yystr);
+
+  return yystpcpy (yyres, yystr) - yyres;
+}
+# endif
+
+#endif /* YYERROR_VERBOSE */
 
 
 
 #if YYDEBUG
-/*-----------------------------.
-| Print this symbol on YYOUT.  |
-`-----------------------------*/
+/*--------------------------------.
+| Print this symbol on YYOUTPUT.  |
+`--------------------------------*/
 
-static void
 #if defined (__STDC__) || defined (__cplusplus)
-yysymprint (FILE* yyout, int yytype, YYSTYPE yyvalue)
+static void
+yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
 #else
-yysymprint (yyout, yytype, yyvalue)
-    FILE* yyout;
+static void
+yysymprint (yyoutput, yytype, yyvaluep)
+    FILE *yyoutput;
     int yytype;
-    YYSTYPE yyvalue;
+    YYSTYPE *yyvaluep;
 #endif
 {
   /* Pacify ``unused variable'' warnings.  */
-  (void) yyvalue;
+  (void) yyvaluep;
 
   if (yytype < YYNTOKENS)
-    {
-      YYFPRINTF (yyout, "token %s (", yytname[yytype]);
-# ifdef YYPRINT
-      YYPRINT (yyout, yytoknum[yytype], yyvalue);
-# endif
-    }
+    YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
   else
-    YYFPRINTF (yyout, "nterm %s (", yytname[yytype]);
+    YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
+
 
+# ifdef YYPRINT
+  if (yytype < YYNTOKENS)
+    YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
+# endif
   switch (yytype)
     {
       default:
         break;
     }
-  YYFPRINTF (yyout, ")");
+  YYFPRINTF (yyoutput, ")");
 }
-#endif /* YYDEBUG. */
-
 
+#endif /* ! YYDEBUG */
 /*-----------------------------------------------.
 | Release the memory associated to this symbol.  |
 `-----------------------------------------------*/
 
-static void
 #if defined (__STDC__) || defined (__cplusplus)
-yydestruct (int yytype, YYSTYPE yyvalue)
+static void
+yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
 #else
-yydestruct (yytype, yyvalue)
+static void
+yydestruct (yymsg, yytype, yyvaluep)
+    const char *yymsg;
     int yytype;
-    YYSTYPE yyvalue;
+    YYSTYPE *yyvaluep;
 #endif
 {
   /* Pacify ``unused variable'' warnings.  */
-  (void) yyvalue;
+  (void) yyvaluep;
+
+  if (!yymsg)
+    yymsg = "Deleting";
+  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
 
   switch (yytype)
     {
+
       default:
         break;
     }
 }
-
 
 
-/* The user can define YYPARSE_PARAM as the name of an argument to be passed
-   into yyparse.  The argument should have type void *.
-   It should actually point to an object.
-   Grammar actions can access the variable by casting it
-   to the proper pointer type.  */
+/* Prevent warnings from -Wmissing-prototypes.  */
 
 #ifdef YYPARSE_PARAM
 # if defined (__STDC__) || defined (__cplusplus)
-#  define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
-#  define YYPARSE_PARAM_DECL
+int yyparse (void *YYPARSE_PARAM);
 # else
-#  define YYPARSE_PARAM_ARG YYPARSE_PARAM
-#  define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
+int yyparse ();
 # endif
-#else /* !YYPARSE_PARAM */
-# define YYPARSE_PARAM_ARG
-# define YYPARSE_PARAM_DECL
-#endif /* !YYPARSE_PARAM */
-
-/* Prevent warning if -Wstrict-prototypes.  */
-#ifdef __GNUC__
-# ifdef YYPARSE_PARAM
-int yyparse (void *);
-# else
+#else /* ! YYPARSE_PARAM */
+#if defined (__STDC__) || defined (__cplusplus)
 int yyparse (void);
-# endif
+#else
+int yyparse ();
 #endif
+#endif /* ! YYPARSE_PARAM */
+
 
 
-/* The lookahead symbol.  */
+/* The look-ahead symbol.  */
 int yychar;
 
-/* The semantic value of the lookahead symbol.  */
+/* The semantic value of the look-ahead symbol.  */
 YYSTYPE yylval;
 
-/* Number of parse errors so far.  */
+/* Number of syntax errors so far.  */
 int yynerrs;
 
 
+
+/*----------.
+| yyparse.  |
+`----------*/
+
+#ifdef YYPARSE_PARAM
+# if defined (__STDC__) || defined (__cplusplus)
+int yyparse (void *YYPARSE_PARAM)
+# else
+int yyparse (YYPARSE_PARAM)
+  void *YYPARSE_PARAM;
+# endif
+#else /* ! YYPARSE_PARAM */
+#if defined (__STDC__) || defined (__cplusplus)
 int
-yyparse (YYPARSE_PARAM_ARG)
-     YYPARSE_PARAM_DECL
+yyparse (void)
+#else
+int
+yyparse ()
+
+#endif
+#endif
 {
   
-  register int yystate;
-  register int yyn;
+  int yystate;
+  int yyn;
   int yyresult;
   /* Number of tokens to shift before error messages enabled.  */
   int yyerrstatus;
-  /* Lookahead token as an internal (translated) token number.  */
-  int yychar1 = 0;
+  /* Look-ahead token as an internal (translated) token number.  */
+  int yytoken = 0;
 
   /* Three stacks and their tools:
      `yyss': related to states,
@@ -2669,14 +3465,14 @@
      to reallocate them elsewhere.  */
 
   /* The state stack.  */
-  short	yyssa[YYINITDEPTH];
-  short *yyss = yyssa;
-  register short *yyssp;
+  short int yyssa[YYINITDEPTH];
+  short int *yyss = yyssa;
+  short int *yyssp;
 
   /* The semantic value stack.  */
   YYSTYPE yyvsa[YYINITDEPTH];
   YYSTYPE *yyvs = yyvsa;
-  register YYSTYPE *yyvsp;
+  YYSTYPE *yyvsp;
 
 
 
@@ -2722,7 +3518,7 @@
  yysetstate:
   *yyssp = yystate;
 
-  if (yyssp >= yyss + yystacksize - 1)
+  if (yyss + yystacksize - 1 <= yyssp)
     {
       /* Get the current used size of the three stacks, in elements.  */
       YYSIZE_T yysize = yyssp - yyss + 1;
@@ -2733,14 +3529,14 @@
 	   these so that the &'s don't force the real ones into
 	   memory.  */
 	YYSTYPE *yyvs1 = yyvs;
-	short *yyss1 = yyss;
+	short int *yyss1 = yyss;
 
 
 	/* Each stack pointer address is followed by the size of the
 	   data in use in that stack, in bytes.  This used to be a
 	   conditional around just the two extra args, but that might
 	   be undefined if yyoverflow is a macro.  */
-	yyoverflow ("parser stack overflow",
+	yyoverflow (YY_("memory exhausted"),
 		    &yyss1, yysize * sizeof (*yyssp),
 		    &yyvs1, yysize * sizeof (*yyvsp),
 
@@ -2751,21 +3547,21 @@
       }
 #else /* no yyoverflow */
 # ifndef YYSTACK_RELOCATE
-      goto yyoverflowlab;
+      goto yyexhaustedlab;
 # else
       /* Extend the stack our own way.  */
-      if (yystacksize >= YYMAXDEPTH)
-	goto yyoverflowlab;
+      if (YYMAXDEPTH <= yystacksize)
+	goto yyexhaustedlab;
       yystacksize *= 2;
-      if (yystacksize > YYMAXDEPTH)
+      if (YYMAXDEPTH < yystacksize)
 	yystacksize = YYMAXDEPTH;
 
       {
-	short *yyss1 = yyss;
+	short int *yyss1 = yyss;
 	union yyalloc *yyptr =
 	  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
 	if (! yyptr)
-	  goto yyoverflowlab;
+	  goto yyexhaustedlab;
 	YYSTACK_RELOCATE (yyss);
 	YYSTACK_RELOCATE (yyvs);
 
@@ -2783,7 +3579,7 @@
       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
 		  (unsigned long int) yystacksize));
 
-      if (yyssp >= yyss + yystacksize - 1)
+      if (yyss + yystacksize - 1 <= yyssp)
 	YYABORT;
     }
 
@@ -2797,50 +3593,39 @@
 yybackup:
 
 /* Do appropriate processing given the current state.  */
-/* Read a lookahead token if we need one and don't already have one.  */
+/* Read a look-ahead token if we need one and don't already have one.  */
 /* yyresume: */
 
-  /* First try to decide what to do without reference to lookahead token.  */
+  /* First try to decide what to do without reference to look-ahead token.  */
 
   yyn = yypact[yystate];
   if (yyn == YYPACT_NINF)
     goto yydefault;
 
-  /* Not known => get a lookahead token if don't already have one.  */
-
-  /* yychar is either YYEMPTY or YYEOF
-     or a valid token in external form.  */
+  /* Not known => get a look-ahead token if don't already have one.  */
 
+  /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */
   if (yychar == YYEMPTY)
     {
       YYDPRINTF ((stderr, "Reading a token: "));
       yychar = YYLEX;
     }
 
-  /* Convert token to internal form (in yychar1) for indexing tables with.  */
-
-  if (yychar <= 0)		/* This means end of input.  */
+  if (yychar <= YYEOF)
     {
-      yychar1 = 0;
-      yychar = YYEOF;		/* Don't call YYLEX any more.  */
-
+      yychar = yytoken = YYEOF;
       YYDPRINTF ((stderr, "Now at end of input.\n"));
     }
   else
     {
-      yychar1 = YYTRANSLATE (yychar);
-
-      /* We have to keep this `#if YYDEBUG', since we use variables
-	 which are defined only if `YYDEBUG' is set.  */
-      YYDPRINTF ((stderr, "Next token is "));
-      YYDSYMPRINT ((stderr, yychar1, yylval));
-      YYDPRINTF ((stderr, "\n"));
+      yytoken = YYTRANSLATE (yychar);
+      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
     }
 
-  /* If the proper action on seeing token YYCHAR1 is to reduce or to
+  /* If the proper action on seeing token YYTOKEN is to reduce or to
      detect an error, take that action.  */
-  yyn += yychar1;
-  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yychar1)
+  yyn += yytoken;
+  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
     goto yydefault;
   yyn = yytable[yyn];
   if (yyn <= 0)
@@ -2854,9 +3639,8 @@
   if (yyn == YYFINAL)
     YYACCEPT;
 
-  /* Shift the lookahead token.  */
-  YYDPRINTF ((stderr, "Shifting token %d (%s), ",
-	      yychar, yytname[yychar1]));
+  /* Shift the look-ahead token.  */
+  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
 
   /* Discard the token being shifted unless it is eof.  */
   if (yychar != YYEOF)
@@ -2902,1696 +3686,2439 @@
   yyval = yyvsp[1-yylen];
 
 
-
-#if YYDEBUG
-  /* We have to keep this `#if YYDEBUG', since we use variables which
-     are defined only if `YYDEBUG' is set.  */
-  if (yydebug)
-    {
-      int yyi;
-
-      YYFPRINTF (stderr, "Reducing via rule %d (line %d), ",
-		 yyn - 1, yyrline[yyn]);
-
-      /* Print the symbols being reduced, and their result.  */
-      for (yyi = yyprhs[yyn]; yyrhs[yyi] >= 0; yyi++)
-	YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
-      YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);
-    }
-#endif
+  YY_REDUCE_PRINT (yyn);
   switch (yyn)
     {
-        case 81:
-#line 1061 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+        case 3:
+#line 1608 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    yyval.String = yyvsp[-1].String;
-  }
+    if ((yyvsp[0].UIntVal) > (uint32_t)INT32_MAX)     // Outside of my range!
+      error("Value too large for type");
+    (yyval.SIntVal) = (int32_t)(yyvsp[0].UIntVal);
+  ;}
+    break;
+
+  case 5:
+#line 1617 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {
+    if ((yyvsp[0].UInt64Val) > (uint64_t)INT64_MAX)     // Outside of my range!
+      error("Value too large for type");
+    (yyval.SInt64Val) = (int64_t)(yyvsp[0].UInt64Val);
+  ;}
+    break;
+
+  case 26:
+#line 1639 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.IPred) = ICmpInst::ICMP_EQ; ;}
+    break;
+
+  case 27:
+#line 1639 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.IPred) = ICmpInst::ICMP_NE; ;}
+    break;
+
+  case 28:
+#line 1640 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.IPred) = ICmpInst::ICMP_SLT; ;}
+    break;
+
+  case 29:
+#line 1640 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.IPred) = ICmpInst::ICMP_SGT; ;}
+    break;
+
+  case 30:
+#line 1641 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.IPred) = ICmpInst::ICMP_SLE; ;}
+    break;
+
+  case 31:
+#line 1641 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.IPred) = ICmpInst::ICMP_SGE; ;}
+    break;
+
+  case 32:
+#line 1642 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.IPred) = ICmpInst::ICMP_ULT; ;}
+    break;
+
+  case 33:
+#line 1642 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.IPred) = ICmpInst::ICMP_UGT; ;}
+    break;
+
+  case 34:
+#line 1643 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.IPred) = ICmpInst::ICMP_ULE; ;}
+    break;
+
+  case 35:
+#line 1643 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.IPred) = ICmpInst::ICMP_UGE; ;}
+    break;
+
+  case 36:
+#line 1647 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.FPred) = FCmpInst::FCMP_OEQ; ;}
+    break;
+
+  case 37:
+#line 1647 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.FPred) = FCmpInst::FCMP_ONE; ;}
+    break;
+
+  case 38:
+#line 1648 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.FPred) = FCmpInst::FCMP_OLT; ;}
+    break;
+
+  case 39:
+#line 1648 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.FPred) = FCmpInst::FCMP_OGT; ;}
+    break;
+
+  case 40:
+#line 1649 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.FPred) = FCmpInst::FCMP_OLE; ;}
+    break;
+
+  case 41:
+#line 1649 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.FPred) = FCmpInst::FCMP_OGE; ;}
+    break;
+
+  case 42:
+#line 1650 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.FPred) = FCmpInst::FCMP_ORD; ;}
+    break;
+
+  case 43:
+#line 1650 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.FPred) = FCmpInst::FCMP_UNO; ;}
+    break;
+
+  case 44:
+#line 1651 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.FPred) = FCmpInst::FCMP_UEQ; ;}
+    break;
+
+  case 45:
+#line 1651 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.FPred) = FCmpInst::FCMP_UNE; ;}
+    break;
+
+  case 46:
+#line 1652 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.FPred) = FCmpInst::FCMP_ULT; ;}
+    break;
+
+  case 47:
+#line 1652 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.FPred) = FCmpInst::FCMP_UGT; ;}
+    break;
+
+  case 48:
+#line 1653 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.FPred) = FCmpInst::FCMP_ULE; ;}
+    break;
+
+  case 49:
+#line 1653 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.FPred) = FCmpInst::FCMP_UGE; ;}
+    break;
+
+  case 50:
+#line 1654 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.FPred) = FCmpInst::FCMP_TRUE; ;}
+    break;
+
+  case 51:
+#line 1655 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.FPred) = FCmpInst::FCMP_FALSE; ;}
+    break;
+
+  case 81:
+#line 1686 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {
+    (yyval.StrVal) = (yyvsp[-1].StrVal);
+  ;}
     break;
 
   case 82:
-#line 1064 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 1689 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    yyval.String = new std::string(""); 
-  }
+    (yyval.StrVal) = 0;
+  ;}
+    break;
+
+  case 83:
+#line 1694 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.Linkage) = GlobalValue::InternalLinkage; ;}
+    break;
+
+  case 84:
+#line 1695 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.Linkage) = GlobalValue::LinkOnceLinkage; ;}
+    break;
+
+  case 85:
+#line 1696 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.Linkage) = GlobalValue::WeakLinkage; ;}
+    break;
+
+  case 86:
+#line 1697 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.Linkage) = GlobalValue::AppendingLinkage; ;}
+    break;
+
+  case 87:
+#line 1698 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.Linkage) = GlobalValue::DLLImportLinkage; ;}
+    break;
+
+  case 88:
+#line 1699 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.Linkage) = GlobalValue::DLLExportLinkage; ;}
+    break;
+
+  case 89:
+#line 1700 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.Linkage) = GlobalValue::ExternalWeakLinkage; ;}
     break;
 
   case 90:
-#line 1071 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    { yyval.String = new std::string(""); }
+#line 1701 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.Linkage) = GlobalValue::ExternalLinkage; ;}
+    break;
+
+  case 91:
+#line 1705 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.UIntVal) = CallingConv::C; ;}
+    break;
+
+  case 92:
+#line 1706 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.UIntVal) = CallingConv::C; ;}
+    break;
+
+  case 93:
+#line 1707 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.UIntVal) = CallingConv::CSRet; ;}
+    break;
+
+  case 94:
+#line 1708 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.UIntVal) = CallingConv::Fast; ;}
+    break;
+
+  case 95:
+#line 1709 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.UIntVal) = CallingConv::Cold; ;}
+    break;
+
+  case 96:
+#line 1710 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.UIntVal) = CallingConv::X86_StdCall; ;}
     break;
 
   case 97:
-#line 1076 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    { 
-    *yyvsp[-1].String += *yyvsp[0].String; 
-    delete yyvsp[0].String;
-    yyval.String = yyvsp[-1].String; 
-    }
+#line 1711 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.UIntVal) = CallingConv::X86_FastCall; ;}
     break;
 
   case 98:
-#line 1081 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    { yyval.String = new std::string(""); }
+#line 1712 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {
+    if ((unsigned)(yyvsp[0].UInt64Val) != (yyvsp[0].UInt64Val))
+      error("Calling conv too large");
+    (yyval.UIntVal) = (yyvsp[0].UInt64Val);
+  ;}
     break;
 
   case 99:
-#line 1086 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    { yyval.String = new std::string(); }
+#line 1722 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.UIntVal) = 0; ;}
     break;
 
   case 100:
-#line 1087 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    { *yyvsp[-1].String += " " + *yyvsp[0].String; delete yyvsp[0].String; yyval.String = yyvsp[-1].String; }
+#line 1723 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {
+    (yyval.UIntVal) = (yyvsp[0].UInt64Val);
+    if ((yyval.UIntVal) != 0 && !isPowerOf2_32((yyval.UIntVal)))
+      error("Alignment must be a power of two");
+  ;}
     break;
 
   case 101:
-#line 1090 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    { yyval.String = new std::string(); }
+#line 1731 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.UIntVal) = 0; ;}
     break;
 
   case 102:
-#line 1091 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    { 
-    yyvsp[-1].String->insert(0, ", "); 
-    *yyvsp[-1].String += " " + *yyvsp[0].String;
-    delete yyvsp[0].String;
-    yyval.String = yyvsp[-1].String;
-  }
+#line 1732 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {
+    (yyval.UIntVal) = (yyvsp[0].UInt64Val);
+    if ((yyval.UIntVal) != 0 && !isPowerOf2_32((yyval.UIntVal)))
+      error("Alignment must be a power of two");
+  ;}
     break;
 
   case 103:
-#line 1099 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    { 
-    *yyvsp[-1].String += " " + *yyvsp[0].String;
-    delete yyvsp[0].String;
-    yyval.String = yyvsp[-1].String;
-  }
+#line 1740 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {
+    for (unsigned i = 0, e = strlen((yyvsp[0].StrVal)); i != e; ++i)
+      if ((yyvsp[0].StrVal)[i] == '"' || (yyvsp[0].StrVal)[i] == '\\')
+        error("Invalid character in section name");
+    (yyval.StrVal) = (yyvsp[0].StrVal);
+  ;}
     break;
 
   case 104:
-#line 1105 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    { yyval.String = new std::string(); }
+#line 1749 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.StrVal) = 0; ;}
+    break;
+
+  case 105:
+#line 1750 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.StrVal) = (yyvsp[0].StrVal); ;}
     break;
 
   case 106:
-#line 1109 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    { yyval.String = new std::string(); }
+#line 1757 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {;}
     break;
 
   case 107:
-#line 1110 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 1758 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {;}
+    break;
+
+  case 108:
+#line 1762 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-      yyvsp[-1].String->insert(0, ", ");
-      if (!yyvsp[0].String->empty())
-        *yyvsp[-1].String += " " + *yyvsp[0].String;
-      delete yyvsp[0].String;
-      yyval.String = yyvsp[-1].String;
-    }
+    CurGV->setSection((yyvsp[0].StrVal));
+    free((yyvsp[0].StrVal));
+  ;}
     break;
 
   case 109:
-#line 1120 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 1766 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-      *yyvsp[-1].String += " " + *yyvsp[0].String;
-      delete yyvsp[0].String;
-      yyval.String = yyvsp[-1].String;
-    }
+    if ((yyvsp[0].UInt64Val) != 0 && !isPowerOf2_32((yyvsp[0].UInt64Val)))
+      error("Alignment must be a power of two");
+    CurGV->setAlignment((yyvsp[0].UInt64Val));
+    
+  ;}
+    break;
+
+  case 111:
+#line 1783 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { 
+    (yyval.TypeVal).T = new PATypeHolder((yyvsp[0].PrimType).T); 
+    (yyval.TypeVal).S = Signless;
+  ;}
+    break;
+
+  case 113:
+#line 1791 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { 
+    (yyval.TypeVal).T = new PATypeHolder((yyvsp[0].PrimType).T); 
+    (yyval.TypeVal).S = Signless;
+  ;}
+    break;
+
+  case 114:
+#line 1798 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {
+    if (!UpRefs.empty())
+      error("Invalid upreference in type: " + (*(yyvsp[0].TypeVal).T)->getDescription());
+    (yyval.TypeVal) = (yyvsp[0].TypeVal);
+  ;}
     break;
 
   case 127:
-#line 1142 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 1812 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     { 
-    yyval.Ty = Type::get(*yyvsp[0].String, OpaqueTy);
-  }
+    (yyval.TypeVal).T = new PATypeHolder((yyvsp[0].PrimType).T);
+    (yyval.TypeVal).S = (yyvsp[0].PrimType).S;
+  ;}
     break;
 
   case 128:
-#line 1145 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    { 
-    yyval.Ty = Type::get(*yyvsp[0].String, UnresolvedTy);
-  }
+#line 1816 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {
+    (yyval.TypeVal).T = new PATypeHolder(OpaqueType::get());
+    (yyval.TypeVal).S = Signless;
+  ;}
     break;
 
   case 129:
-#line 1148 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    { 
-    yyval.Ty = yyvsp[0].Ty; 
-  }
+#line 1820 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {            // Named types are also simple types...
+    const Type* tmp = getTypeVal((yyvsp[0].ValIDVal));
+    (yyval.TypeVal).T = new PATypeHolder(tmp);
+    (yyval.TypeVal).S = Signless; // FIXME: what if its signed?
+  ;}
     break;
 
   case 130:
-#line 1151 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 1825 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {                   // Type UpReference
-    yyvsp[0].String->insert(0, "\\");
-    yyval.Ty = Type::get(*yyvsp[0].String, UpRefTy);
-  }
+    if ((yyvsp[0].UInt64Val) > (uint64_t)~0U) 
+      error("Value out of range");
+    OpaqueType *OT = OpaqueType::get();        // Use temporary placeholder
+    UpRefs.push_back(UpRefRecord((unsigned)(yyvsp[0].UInt64Val), OT));  // Add to vector...
+    (yyval.TypeVal).T = new PATypeHolder(OT);
+    (yyval.TypeVal).S = Signless;
+    UR_OUT("New Upreference!\n");
+  ;}
     break;
 
   case 131:
-#line 1155 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 1834 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {           // Function derived type?
-    std::string newTy( yyvsp[-3].Ty->getNewTy() + "(");
-    for (unsigned i = 0; i < yyvsp[-1].TypeVec->size(); ++i) {
-      if (i != 0)
-        newTy +=  ", ";
-      if ((*yyvsp[-1].TypeVec)[i]->isVoid())
-        newTy += "...";
-      else
-        newTy += (*yyvsp[-1].TypeVec)[i]->getNewTy();
-    }
-    newTy += ")";
-    yyval.Ty = Type::get(newTy, yyvsp[-3].Ty, yyvsp[-1].TypeVec);
-  }
+    std::vector Params;
+    for (std::list::iterator I = (yyvsp[-1].TypeList)->begin(),
+           E = (yyvsp[-1].TypeList)->end(); I != E; ++I) {
+      Params.push_back(I->T->get());
+      delete I->T;
+    }
+    bool isVarArg = Params.size() && Params.back() == Type::VoidTy;
+    if (isVarArg) Params.pop_back();
+
+    (yyval.TypeVal).T = new PATypeHolder(HandleUpRefs(
+                           FunctionType::get((yyvsp[-3].TypeVal).T->get(),Params,isVarArg)));
+    (yyval.TypeVal).S = (yyvsp[-3].TypeVal).S;
+    delete (yyvsp[-3].TypeVal).T;    // Delete the return type handle
+    delete (yyvsp[-1].TypeList);      // Delete the argument list
+  ;}
     break;
 
   case 132:
-#line 1168 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 1850 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {          // Sized array type?
-    uint64_t elems = atoi(yyvsp[-3].String->c_str());
-    yyvsp[-3].String->insert(0,"[ ");
-    *yyvsp[-3].String += " x " + yyvsp[-1].Ty->getNewTy() + " ]";
-    yyval.Ty = Type::get(*yyvsp[-3].String, ArrayTy, yyvsp[-1].Ty, elems);
-  }
+    (yyval.TypeVal).T = new PATypeHolder(HandleUpRefs(ArrayType::get((yyvsp[-1].TypeVal).T->get(), 
+                                                        (unsigned)(yyvsp[-3].UInt64Val))));
+    (yyval.TypeVal).S = (yyvsp[-1].TypeVal).S;
+    delete (yyvsp[-1].TypeVal).T;
+  ;}
     break;
 
   case 133:
-#line 1174 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 1856 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {          // Packed array type?
-    uint64_t elems = atoi(yyvsp[-3].String->c_str());
-    yyvsp[-3].String->insert(0,"< ");
-    *yyvsp[-3].String += " x " + yyvsp[-1].Ty->getNewTy() + " >";
-    yyval.Ty = Type::get(*yyvsp[-3].String, PackedTy, yyvsp[-1].Ty, elems);
-  }
+     const llvm::Type* ElemTy = (yyvsp[-1].TypeVal).T->get();
+     if ((unsigned)(yyvsp[-3].UInt64Val) != (yyvsp[-3].UInt64Val))
+        error("Unsigned result not equal to signed result");
+     if (!(ElemTy->isInteger() || ElemTy->isFloatingPoint()))
+        error("Elements of a PackedType must be integer or floating point");
+     if (!isPowerOf2_32((yyvsp[-3].UInt64Val)))
+       error("PackedType length should be a power of 2");
+     (yyval.TypeVal).T = new PATypeHolder(HandleUpRefs(PackedType::get(ElemTy, 
+                                          (unsigned)(yyvsp[-3].UInt64Val))));
+     (yyval.TypeVal).S = (yyvsp[-1].TypeVal).S;
+     delete (yyvsp[-1].TypeVal).T;
+  ;}
     break;
 
   case 134:
-#line 1180 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 1869 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {                        // Structure type?
-    std::string newTy("{");
-    for (unsigned i = 0; i < yyvsp[-1].TypeVec->size(); ++i) {
-      if (i != 0)
-        newTy +=  ", ";
-      newTy += (*yyvsp[-1].TypeVec)[i]->getNewTy();
-    }
-    newTy += "}";
-    yyval.Ty = Type::get(newTy, StructTy, yyvsp[-1].TypeVec);
-  }
+    std::vector Elements;
+    for (std::list::iterator I = (yyvsp[-1].TypeList)->begin(),
+           E = (yyvsp[-1].TypeList)->end(); I != E; ++I)
+      Elements.push_back(I->T->get());
+    (yyval.TypeVal).T = new PATypeHolder(HandleUpRefs(StructType::get(Elements)));
+    (yyval.TypeVal).S = Signless;
+    delete (yyvsp[-1].TypeList);
+  ;}
     break;
 
   case 135:
-#line 1190 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 1878 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {                                  // Empty structure type?
-    yyval.Ty = Type::get("{}", StructTy, new TypeList());
-  }
+    (yyval.TypeVal).T = new PATypeHolder(StructType::get(std::vector()));
+    (yyval.TypeVal).S = Signless;
+  ;}
     break;
 
   case 136:
-#line 1193 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 1882 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {                // Packed Structure type?
-    std::string newTy("<{");
-    for (unsigned i = 0; i < yyvsp[-2].TypeVec->size(); ++i) {
-      if (i != 0)
-        newTy +=  ", ";
-      newTy += (*yyvsp[-2].TypeVec)[i]->getNewTy();
-    }
-    newTy += "}>";
-    yyval.Ty = Type::get(newTy, PackedStructTy, yyvsp[-2].TypeVec);
-  }
+    std::vector Elements;
+    for (std::list::iterator I = (yyvsp[-2].TypeList)->begin(),
+           E = (yyvsp[-2].TypeList)->end(); I != E; ++I) {
+      Elements.push_back(I->T->get());
+      delete I->T;
+    }
+    (yyval.TypeVal).T = new PATypeHolder(HandleUpRefs(StructType::get(Elements, true)));
+    (yyval.TypeVal).S = Signless;
+    delete (yyvsp[-2].TypeList);
+  ;}
     break;
 
   case 137:
-#line 1203 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 1893 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {                          // Empty packed structure type?
-    yyval.Ty = Type::get("<{}>", PackedStructTy, new TypeList());
-  }
+    (yyval.TypeVal).T = new PATypeHolder(StructType::get(std::vector(),true));
+    (yyval.TypeVal).S = Signless;
+  ;}
     break;
 
   case 138:
-#line 1206 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 1897 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {                             // Pointer type?
-    yyval.Ty = yyvsp[-1].Ty->getPointerType();
-  }
+    if ((yyvsp[-1].TypeVal).T->get() == Type::LabelTy)
+      error("Cannot form a pointer to a basic block");
+    (yyval.TypeVal).T = new PATypeHolder(HandleUpRefs(PointerType::get((yyvsp[-1].TypeVal).T->get())));
+    (yyval.TypeVal).S = (yyvsp[-1].TypeVal).S;
+    delete (yyvsp[-1].TypeVal).T;
+  ;}
     break;
 
   case 139:
-#line 1214 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 1910 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    yyval.TypeVec = new TypeList();
-    yyval.TypeVec->push_back(yyvsp[0].Ty);
-  }
+    (yyval.TypeList) = new std::list();
+    (yyval.TypeList)->push_back((yyvsp[0].TypeVal)); 
+  ;}
     break;
 
   case 140:
-#line 1218 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 1914 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    yyval.TypeVec = yyvsp[-2].TypeVec;
-    yyval.TypeVec->push_back(yyvsp[0].Ty);
-  }
+    ((yyval.TypeList)=(yyvsp[-2].TypeList))->push_back((yyvsp[0].TypeVal));
+  ;}
     break;
 
   case 142:
-#line 1226 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 1922 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    yyval.TypeVec = yyvsp[-2].TypeVec;
-    yyval.TypeVec->push_back(Type::get("void",VoidTy));
-    delete yyvsp[0].String;
-  }
+    PATypeInfo VoidTI;
+    VoidTI.T = new PATypeHolder(Type::VoidTy);
+    VoidTI.S = Signless;
+    ((yyval.TypeList)=(yyvsp[-2].TypeList))->push_back(VoidTI);
+  ;}
     break;
 
   case 143:
-#line 1231 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 1928 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    yyval.TypeVec = new TypeList();
-    yyval.TypeVec->push_back(Type::get("void",VoidTy));
-    delete yyvsp[0].String;
-  }
+    (yyval.TypeList) = new std::list();
+    PATypeInfo VoidTI;
+    VoidTI.T = new PATypeHolder(Type::VoidTy);
+    VoidTI.S = Signless;
+    (yyval.TypeList)->push_back(VoidTI);
+  ;}
     break;
 
   case 144:
-#line 1236 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 1935 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    yyval.TypeVec = new TypeList();
-  }
+    (yyval.TypeList) = new std::list();
+  ;}
     break;
 
   case 145:
-#line 1246 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 1947 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     { // Nonempty unsized arr
-    yyval.Const = new Constant;
-    yyval.Const->type = yyvsp[-3].Ty;
-    yyval.Const->cnst = new std::string(yyvsp[-3].Ty->getNewTy());
-    *yyval.Const->cnst += " [ " + *yyvsp[-1].String + " ]";
-    delete yyvsp[-1].String;
-  }
+    const ArrayType *ATy = dyn_cast((yyvsp[-3].TypeVal).T->get());
+    if (ATy == 0)
+      error("Cannot make array constant with type: '" + 
+            (yyvsp[-3].TypeVal).T->get()->getDescription() + "'");
+    const Type *ETy = ATy->getElementType();
+    int NumElements = ATy->getNumElements();
+
+    // Verify that we have the correct size...
+    if (NumElements != -1 && NumElements != (int)(yyvsp[-1].ConstVector)->size())
+      error("Type mismatch: constant sized array initialized with " +
+            utostr((yyvsp[-1].ConstVector)->size()) +  " arguments, but has size of " + 
+            itostr(NumElements) + "");
+
+    // Verify all elements are correct type!
+    std::vector Elems;
+    for (unsigned i = 0; i < (yyvsp[-1].ConstVector)->size(); i++) {
+      Constant *C = (*(yyvsp[-1].ConstVector))[i].C;
+      const Type* ValTy = C->getType();
+      if (ETy != ValTy)
+        error("Element #" + utostr(i) + " is not of type '" + 
+              ETy->getDescription() +"' as required!\nIt is of type '"+
+              ValTy->getDescription() + "'");
+      Elems.push_back(C);
+    }
+    (yyval.ConstVal).C = ConstantArray::get(ATy, Elems);
+    (yyval.ConstVal).S = (yyvsp[-3].TypeVal).S;
+    delete (yyvsp[-3].TypeVal).T; 
+    delete (yyvsp[-1].ConstVector);
+  ;}
     break;
 
   case 146:
-#line 1253 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 1977 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    yyval.Const = new Constant;
-    yyval.Const->type = yyvsp[-2].Ty;
-    yyval.Const->cnst = new std::string(yyvsp[-2].Ty->getNewTy());
-    *yyval.Const->cnst += "[ ]";
-  }
+    const ArrayType *ATy = dyn_cast((yyvsp[-2].TypeVal).T->get());
+    if (ATy == 0)
+      error("Cannot make array constant with type: '" + 
+            (yyvsp[-2].TypeVal).T->get()->getDescription() + "'");
+    int NumElements = ATy->getNumElements();
+    if (NumElements != -1 && NumElements != 0) 
+      error("Type mismatch: constant sized array initialized with 0"
+            " arguments, but has size of " + itostr(NumElements) +"");
+    (yyval.ConstVal).C = ConstantArray::get(ATy, std::vector());
+    (yyval.ConstVal).S = (yyvsp[-2].TypeVal).S;
+    delete (yyvsp[-2].TypeVal).T;
+  ;}
     break;
 
   case 147:
-#line 1259 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 1990 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    yyval.Const = new Constant;
-    yyval.Const->type = yyvsp[-2].Ty;
-    yyval.Const->cnst = new std::string(yyvsp[-2].Ty->getNewTy());
-    *yyval.Const->cnst += " c" + *yyvsp[0].String;
-    delete yyvsp[0].String;
-  }
+    const ArrayType *ATy = dyn_cast((yyvsp[-2].TypeVal).T->get());
+    if (ATy == 0)
+      error("Cannot make array constant with type: '" + 
+            (yyvsp[-2].TypeVal).T->get()->getDescription() + "'");
+    int NumElements = ATy->getNumElements();
+    const Type *ETy = dyn_cast(ATy->getElementType());
+    if (!ETy || cast(ETy)->getBitWidth() != 8)
+      error("String arrays require type i8, not '" + ETy->getDescription() + 
+            "'");
+    char *EndStr = UnEscapeLexed((yyvsp[0].StrVal), true);
+    if (NumElements != -1 && NumElements != (EndStr-(yyvsp[0].StrVal)))
+      error("Can't build string constant of size " + 
+            itostr((int)(EndStr-(yyvsp[0].StrVal))) + " when array has size " + 
+            itostr(NumElements) + "");
+    std::vector Vals;
+    for (char *C = (char *)(yyvsp[0].StrVal); C != (char *)EndStr; ++C)
+      Vals.push_back(ConstantInt::get(ETy, *C));
+    free((yyvsp[0].StrVal));
+    (yyval.ConstVal).C = ConstantArray::get(ATy, Vals);
+    (yyval.ConstVal).S = (yyvsp[-2].TypeVal).S;
+    delete (yyvsp[-2].TypeVal).T;
+  ;}
     break;
 
   case 148:
-#line 1266 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 2013 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     { // Nonempty unsized arr
-    yyval.Const = new Constant;
-    yyval.Const->type = yyvsp[-3].Ty;
-    yyval.Const->cnst = new std::string(yyvsp[-3].Ty->getNewTy());
-    *yyval.Const->cnst += " < " + *yyvsp[-1].String + " >";
-    delete yyvsp[-1].String;
-  }
+    const PackedType *PTy = dyn_cast((yyvsp[-3].TypeVal).T->get());
+    if (PTy == 0)
+      error("Cannot make packed constant with type: '" + 
+            (yyvsp[-3].TypeVal).T->get()->getDescription() + "'");
+    const Type *ETy = PTy->getElementType();
+    int NumElements = PTy->getNumElements();
+    // Verify that we have the correct size...
+    if (NumElements != -1 && NumElements != (int)(yyvsp[-1].ConstVector)->size())
+      error("Type mismatch: constant sized packed initialized with " +
+            utostr((yyvsp[-1].ConstVector)->size()) +  " arguments, but has size of " + 
+            itostr(NumElements) + "");
+    // Verify all elements are correct type!
+    std::vector Elems;
+    for (unsigned i = 0; i < (yyvsp[-1].ConstVector)->size(); i++) {
+      Constant *C = (*(yyvsp[-1].ConstVector))[i].C;
+      const Type* ValTy = C->getType();
+      if (ETy != ValTy)
+        error("Element #" + utostr(i) + " is not of type '" + 
+              ETy->getDescription() +"' as required!\nIt is of type '"+
+              ValTy->getDescription() + "'");
+      Elems.push_back(C);
+    }
+    (yyval.ConstVal).C = ConstantPacked::get(PTy, Elems);
+    (yyval.ConstVal).S = (yyvsp[-3].TypeVal).S;
+    delete (yyvsp[-3].TypeVal).T;
+    delete (yyvsp[-1].ConstVector);
+  ;}
     break;
 
   case 149:
-#line 1273 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 2041 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    yyval.Const = new Constant;
-    yyval.Const->type = yyvsp[-3].Ty;
-    yyval.Const->cnst = new std::string(yyvsp[-3].Ty->getNewTy());
-    *yyval.Const->cnst += " { " + *yyvsp[-1].String + " }";
-    delete yyvsp[-1].String;
-  }
+    const StructType *STy = dyn_cast((yyvsp[-3].TypeVal).T->get());
+    if (STy == 0)
+      error("Cannot make struct constant with type: '" + 
+            (yyvsp[-3].TypeVal).T->get()->getDescription() + "'");
+    if ((yyvsp[-1].ConstVector)->size() != STy->getNumContainedTypes())
+      error("Illegal number of initializers for structure type");
+
+    // Check to ensure that constants are compatible with the type initializer!
+    std::vector Fields;
+    for (unsigned i = 0, e = (yyvsp[-1].ConstVector)->size(); i != e; ++i) {
+      Constant *C = (*(yyvsp[-1].ConstVector))[i].C;
+      if (C->getType() != STy->getElementType(i))
+        error("Expected type '" + STy->getElementType(i)->getDescription() +
+              "' for element #" + utostr(i) + " of structure initializer");
+      Fields.push_back(C);
+    }
+    (yyval.ConstVal).C = ConstantStruct::get(STy, Fields);
+    (yyval.ConstVal).S = (yyvsp[-3].TypeVal).S;
+    delete (yyvsp[-3].TypeVal).T;
+    delete (yyvsp[-1].ConstVector);
+  ;}
     break;
 
   case 150:
-#line 1280 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 2063 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    yyval.Const = new Constant;
-    yyval.Const->type = yyvsp[-2].Ty;
-    yyval.Const->cnst = new std::string(yyvsp[-2].Ty->getNewTy());
-    *yyval.Const->cnst += " {}";
-  }
+    const StructType *STy = dyn_cast((yyvsp[-2].TypeVal).T->get());
+    if (STy == 0)
+      error("Cannot make struct constant with type: '" + 
+              (yyvsp[-2].TypeVal).T->get()->getDescription() + "'");
+    if (STy->getNumContainedTypes() != 0)
+      error("Illegal number of initializers for structure type");
+    (yyval.ConstVal).C = ConstantStruct::get(STy, std::vector());
+    (yyval.ConstVal).S = (yyvsp[-2].TypeVal).S;
+    delete (yyvsp[-2].TypeVal).T;
+  ;}
     break;
 
   case 151:
-#line 1286 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 2074 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    yyval.Const = new Constant;
-    yyval.Const->type = yyvsp[-1].Ty;
-    yyval.Const->cnst = new std::string(yyvsp[-1].Ty->getNewTy());
-    *yyval.Const->cnst +=  " " + *yyvsp[0].String;
-    delete yyvsp[0].String;
-  }
+    const StructType *STy = dyn_cast((yyvsp[-5].TypeVal).T->get());
+    if (STy == 0)
+      error("Cannot make packed struct constant with type: '" + 
+            (yyvsp[-5].TypeVal).T->get()->getDescription() + "'");
+    if ((yyvsp[-2].ConstVector)->size() != STy->getNumContainedTypes())
+      error("Illegal number of initializers for packed structure type");
+
+    // Check to ensure that constants are compatible with the type initializer!
+    std::vector Fields;
+    for (unsigned i = 0, e = (yyvsp[-2].ConstVector)->size(); i != e; ++i) {
+      Constant *C = (*(yyvsp[-2].ConstVector))[i].C;
+      if (C->getType() != STy->getElementType(i))
+        error("Expected type '" + STy->getElementType(i)->getDescription() +
+              "' for element #" + utostr(i) + " of packed struct initializer");
+      Fields.push_back(C);
+    }
+    (yyval.ConstVal).C = ConstantStruct::get(STy, Fields);
+    (yyval.ConstVal).S = (yyvsp[-5].TypeVal).S;
+    delete (yyvsp[-5].TypeVal).T; 
+    delete (yyvsp[-2].ConstVector);
+  ;}
     break;
 
   case 152:
-#line 1293 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 2096 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    yyval.Const = new Constant;
-    yyval.Const->type = yyvsp[-1].Ty;
-    yyval.Const->cnst = new std::string(yyvsp[-1].Ty->getNewTy());
-    *yyval.Const->cnst += " " + *yyvsp[0].String;
-    delete yyvsp[0].String;
-  }
+    const StructType *STy = dyn_cast((yyvsp[-4].TypeVal).T->get());
+    if (STy == 0)
+      error("Cannot make packed struct constant with type: '" + 
+              (yyvsp[-4].TypeVal).T->get()->getDescription() + "'");
+    if (STy->getNumContainedTypes() != 0)
+      error("Illegal number of initializers for packed structure type");
+    (yyval.ConstVal).C = ConstantStruct::get(STy, std::vector());
+    (yyval.ConstVal).S = (yyvsp[-4].TypeVal).S;
+    delete (yyvsp[-4].TypeVal).T;
+  ;}
     break;
 
   case 153:
-#line 1300 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 2107 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    yyval.Const = new Constant;
-    std::string Name = getUniqueName(yyvsp[0].String, yyvsp[-1].Ty->resolve(), true);
-    yyval.Const->type = yyvsp[-1].Ty;
-    yyval.Const->cnst = new std::string(yyvsp[-1].Ty->getNewTy());
-    *yyval.Const->cnst += " " + Name;
-    delete yyvsp[0].String;
-  }
+    const PointerType *PTy = dyn_cast((yyvsp[-1].TypeVal).T->get());
+    if (PTy == 0)
+      error("Cannot make null pointer constant with type: '" + 
+            (yyvsp[-1].TypeVal).T->get()->getDescription() + "'");
+    (yyval.ConstVal).C = ConstantPointerNull::get(PTy);
+    (yyval.ConstVal).S = (yyvsp[-1].TypeVal).S;
+    delete (yyvsp[-1].TypeVal).T;
+  ;}
     break;
 
   case 154:
-#line 1308 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 2116 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    yyval.Const = new Constant;
-    yyval.Const->type = yyvsp[-1].Ty;
-    yyval.Const->cnst = new std::string(yyvsp[-1].Ty->getNewTy());
-    *yyval.Const->cnst += " " + *yyvsp[0].String;
-    delete yyvsp[0].String;
-  }
+    (yyval.ConstVal).C = UndefValue::get((yyvsp[-1].TypeVal).T->get());
+    (yyval.ConstVal).S = (yyvsp[-1].TypeVal).S;
+    delete (yyvsp[-1].TypeVal).T;
+  ;}
     break;
 
   case 155:
-#line 1315 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 2121 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    yyval.Const = new Constant;
-    yyval.Const->type = yyvsp[-1].Ty;
-    yyval.Const->cnst = new std::string(yyvsp[-1].Ty->getNewTy());
-    *yyval.Const->cnst += " " + *yyvsp[0].String;
-    delete yyvsp[0].String;
-  }
+    const PointerType *Ty = dyn_cast((yyvsp[-1].TypeVal).T->get());
+    if (Ty == 0)
+      error("Global const reference must be a pointer type, not" +
+            (yyvsp[-1].TypeVal).T->get()->getDescription());
+
+    // ConstExprs can exist in the body of a function, thus creating
+    // GlobalValues whenever they refer to a variable.  Because we are in
+    // the context of a function, getExistingValue will search the functions
+    // symbol table instead of the module symbol table for the global symbol,
+    // which throws things all off.  To get around this, we just tell
+    // getExistingValue that we are at global scope here.
+    //
+    Function *SavedCurFn = CurFun.CurrentFunction;
+    CurFun.CurrentFunction = 0;
+    Value *V = getExistingValue(Ty, (yyvsp[0].ValIDVal));
+    CurFun.CurrentFunction = SavedCurFn;
+
+    // If this is an initializer for a constant pointer, which is referencing a
+    // (currently) undefined variable, create a stub now that shall be replaced
+    // in the future with the right type of variable.
+    //
+    if (V == 0) {
+      assert(isa(Ty) && "Globals may only be used as pointers");
+      const PointerType *PT = cast(Ty);
+
+      // First check to see if the forward references value is already created!
+      PerModuleInfo::GlobalRefsType::iterator I =
+        CurModule.GlobalRefs.find(std::make_pair(PT, (yyvsp[0].ValIDVal)));
+    
+      if (I != CurModule.GlobalRefs.end()) {
+        V = I->second;             // Placeholder already exists, use it...
+        (yyvsp[0].ValIDVal).destroy();
+      } else {
+        std::string Name;
+        if ((yyvsp[0].ValIDVal).Type == ValID::NameVal) Name = (yyvsp[0].ValIDVal).Name;
+
+        // Create the forward referenced global.
+        GlobalValue *GV;
+        if (const FunctionType *FTy = 
+                 dyn_cast(PT->getElementType())) {
+          GV = new Function(FTy, GlobalValue::ExternalLinkage, Name,
+                            CurModule.CurrentModule);
+        } else {
+          GV = new GlobalVariable(PT->getElementType(), false,
+                                  GlobalValue::ExternalLinkage, 0,
+                                  Name, CurModule.CurrentModule);
+        }
+
+        // Keep track of the fact that we have a forward ref to recycle it
+        CurModule.GlobalRefs.insert(std::make_pair(std::make_pair(PT, (yyvsp[0].ValIDVal)), GV));
+        V = GV;
+      }
+    }
+    (yyval.ConstVal).C = cast(V);
+    (yyval.ConstVal).S = (yyvsp[-1].TypeVal).S;
+    delete (yyvsp[-1].TypeVal).T;            // Free the type handle
+  ;}
     break;
 
   case 156:
-#line 1322 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    {      // integral constants
-    yyval.Const = new Constant;
-    yyval.Const->type = yyvsp[-1].Ty;
-    yyval.Const->cnst = new std::string(yyvsp[-1].Ty->getNewTy());
-    *yyval.Const->cnst += " " + *yyvsp[0].String;
-    delete yyvsp[0].String;
-  }
+#line 2179 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {
+    if ((yyvsp[-1].TypeVal).T->get() != (yyvsp[0].ConstVal).C->getType())
+      error("Mismatched types for constant expression");
+    (yyval.ConstVal) = (yyvsp[0].ConstVal);
+    (yyval.ConstVal).S = (yyvsp[-1].TypeVal).S;
+    delete (yyvsp[-1].TypeVal).T;
+  ;}
     break;
 
   case 157:
-#line 1329 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    {            // integral constants
-    yyval.Const = new Constant;
-    yyval.Const->type = yyvsp[-1].Ty;
-    yyval.Const->cnst = new std::string(yyvsp[-1].Ty->getNewTy());
-    *yyval.Const->cnst += " " + *yyvsp[0].String;
-    delete yyvsp[0].String;
-  }
+#line 2186 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {
+    const Type *Ty = (yyvsp[-1].TypeVal).T->get();
+    if (isa(Ty) || Ty == Type::LabelTy || isa(Ty))
+      error("Cannot create a null initialized value of this type");
+    (yyval.ConstVal).C = Constant::getNullValue(Ty);
+    (yyval.ConstVal).S = (yyvsp[-1].TypeVal).S;
+    delete (yyvsp[-1].TypeVal).T;
+  ;}
     break;
 
   case 158:
-#line 1336 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    {                      // Boolean constants
-    yyval.Const = new Constant;
-    yyval.Const->type = yyvsp[-1].Ty;
-    yyval.Const->cnst = new std::string(yyvsp[-1].Ty->getNewTy());
-    *yyval.Const->cnst += " " + *yyvsp[0].String;
-    delete yyvsp[0].String;
-  }
+#line 2194 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {      // integral constants
+    const Type *Ty = (yyvsp[-1].PrimType).T;
+    if (!ConstantInt::isValueValidForType(Ty, (yyvsp[0].SInt64Val)))
+      error("Constant value doesn't fit in type");
+    (yyval.ConstVal).C = ConstantInt::get(Ty, (yyvsp[0].SInt64Val));
+    (yyval.ConstVal).S = Signed;
+  ;}
     break;
 
   case 159:
-#line 1343 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    {                     // Boolean constants
-    yyval.Const = new Constant;
-    yyval.Const->type = yyvsp[-1].Ty;
-    yyval.Const->cnst = new std::string(yyvsp[-1].Ty->getNewTy());
-    *yyval.Const->cnst += " " + *yyvsp[0].String;
-    delete yyvsp[0].String;
-  }
+#line 2201 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {            // integral constants
+    const Type *Ty = (yyvsp[-1].PrimType).T;
+    if (!ConstantInt::isValueValidForType(Ty, (yyvsp[0].UInt64Val)))
+      error("Constant value doesn't fit in type");
+    (yyval.ConstVal).C = ConstantInt::get(Ty, (yyvsp[0].UInt64Val));
+    (yyval.ConstVal).S = Unsigned;
+  ;}
     break;
 
   case 160:
-#line 1350 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    {                   // Float & Double constants
-    yyval.Const = new Constant;
-    yyval.Const->type = yyvsp[-1].Ty;
-    yyval.Const->cnst = new std::string(yyvsp[-1].Ty->getNewTy());
-    *yyval.Const->cnst += " " + *yyvsp[0].String;
-    delete yyvsp[0].String;
-  }
+#line 2208 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {                      // Boolean constants
+    (yyval.ConstVal).C = ConstantInt::get(Type::Int1Ty, true);
+    (yyval.ConstVal).S = Unsigned;
+  ;}
     break;
 
   case 161:
-#line 1358 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    {
-    std::string source = *yyvsp[-3].Const->cnst;
-    const Type* SrcTy = yyvsp[-3].Const->type->resolve();
-    const Type* DstTy = yyvsp[-1].Ty->resolve(); 
-    if (*yyvsp[-5].String == "cast") {
-      // Call getCastUpgrade to upgrade the old cast
-      yyval.String = new std::string(getCastUpgrade(source, SrcTy, DstTy, true));
-    } else {
-      // Nothing to upgrade, just create the cast constant expr
-      yyval.String = new std::string(*yyvsp[-5].String);
-      *yyval.String += "( " + source + " to " + yyvsp[-1].Ty->getNewTy() + ")";
-    }
-    delete yyvsp[-5].String; delete yyvsp[-3].Const; delete yyvsp[-2].String;
-  }
+#line 2212 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {                     // Boolean constants
+    (yyval.ConstVal).C = ConstantInt::get(Type::Int1Ty, false);
+    (yyval.ConstVal).S = Unsigned;
+  ;}
     break;
 
   case 162:
-#line 1372 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    {
-    *yyvsp[-4].String += "(" + *yyvsp[-2].Const->cnst;
-    for (unsigned i = 0; i < yyvsp[-1].ValList->size(); ++i) {
-      Value* V = (*yyvsp[-1].ValList)[i];
-      *yyvsp[-4].String += ", " + *V->val;
-      delete V;
-    }
-    *yyvsp[-4].String += ")";
-    yyval.String = yyvsp[-4].String;
-    delete yyvsp[-2].Const;
-    delete yyvsp[-1].ValList;
-  }
+#line 2216 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {                   // Float & Double constants
+    if (!ConstantFP::isValueValidForType((yyvsp[-1].PrimType).T, (yyvsp[0].FPVal)))
+      error("Floating point constant invalid for type");
+    (yyval.ConstVal).C = ConstantFP::get((yyvsp[-1].PrimType).T, (yyvsp[0].FPVal));
+    (yyval.ConstVal).S = Signless;
+  ;}
     break;
 
   case 163:
-#line 1384 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 2225 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    *yyvsp[-7].String += "(" + *yyvsp[-5].Const->cnst + "," + *yyvsp[-3].Const->cnst + "," + *yyvsp[-1].Const->cnst + ")";
-    delete yyvsp[-5].Const; delete yyvsp[-3].Const; delete yyvsp[-1].Const;
-    yyval.String = yyvsp[-7].String;
-  }
+    const Type* SrcTy = (yyvsp[-3].ConstVal).C->getType();
+    const Type* DstTy = (yyvsp[-1].TypeVal).T->get();
+    Signedness SrcSign = (yyvsp[-3].ConstVal).S;
+    Signedness DstSign = (yyvsp[-1].TypeVal).S;
+    if (!SrcTy->isFirstClassType())
+      error("cast constant expression from a non-primitive type: '" +
+            SrcTy->getDescription() + "'");
+    if (!DstTy->isFirstClassType())
+      error("cast constant expression to a non-primitive type: '" +
+            DstTy->getDescription() + "'");
+    (yyval.ConstVal).C = cast(getCast((yyvsp[-5].CastOpVal), (yyvsp[-3].ConstVal).C, SrcSign, DstTy, DstSign));
+    (yyval.ConstVal).S = DstSign;
+    delete (yyvsp[-1].TypeVal).T;
+  ;}
     break;
 
   case 164:
-#line 1389 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 2240 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    const char* op = getDivRemOpcode(*yyvsp[-5].String, yyvsp[-3].Const->type); 
-    yyval.String = new std::string(op);
-    *yyval.String += "(" + *yyvsp[-3].Const->cnst + "," + *yyvsp[-1].Const->cnst + ")";
-    delete yyvsp[-5].String; delete yyvsp[-3].Const; delete yyvsp[-1].Const;
-  }
+    const Type *Ty = (yyvsp[-2].ConstVal).C->getType();
+    if (!isa(Ty))
+      error("GetElementPtr requires a pointer operand");
+
+    std::vector VIndices;
+    std::vector CIndices;
+    upgradeGEPIndices((yyvsp[-2].ConstVal).C->getType(), (yyvsp[-1].ValueList), VIndices, &CIndices);
+
+    delete (yyvsp[-1].ValueList);
+    (yyval.ConstVal).C = ConstantExpr::getGetElementPtr((yyvsp[-2].ConstVal).C, CIndices);
+    (yyval.ConstVal).S = Signless;
+  ;}
     break;
 
   case 165:
-#line 1395 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 2253 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    *yyvsp[-5].String += "(" + *yyvsp[-3].Const->cnst + "," + *yyvsp[-1].Const->cnst + ")";
-    delete yyvsp[-3].Const; delete yyvsp[-1].Const;
-    yyval.String = yyvsp[-5].String;
-  }
+    if (!(yyvsp[-5].ConstVal).C->getType()->isInteger() ||
+        cast((yyvsp[-5].ConstVal).C->getType())->getBitWidth() != 1)
+      error("Select condition must be bool type");
+    if ((yyvsp[-3].ConstVal).C->getType() != (yyvsp[-1].ConstVal).C->getType())
+      error("Select operand types must match");
+    (yyval.ConstVal).C = ConstantExpr::getSelect((yyvsp[-5].ConstVal).C, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
+    (yyval.ConstVal).S = Unsigned;
+  ;}
     break;
 
   case 166:
-#line 1400 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 2262 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    *yyvsp[-5].String = getCompareOp(*yyvsp[-5].String, yyvsp[-3].Const->type);
-    *yyvsp[-5].String += "(" + *yyvsp[-3].Const->cnst + "," + *yyvsp[-1].Const->cnst + ")";
-    delete yyvsp[-3].Const; delete yyvsp[-1].Const;
-    yyval.String = yyvsp[-5].String;
-  }
+    const Type *Ty = (yyvsp[-3].ConstVal).C->getType();
+    if (Ty != (yyvsp[-1].ConstVal).C->getType())
+      error("Binary operator types must match");
+    // First, make sure we're dealing with the right opcode by upgrading from
+    // obsolete versions.
+    Instruction::BinaryOps Opcode = getBinaryOp((yyvsp[-5].BinaryOpVal), Ty, (yyvsp[-3].ConstVal).S);
+
+    // HACK: llvm 1.3 and earlier used to emit invalid pointer constant exprs.
+    // To retain backward compatibility with these early compilers, we emit a
+    // cast to the appropriate integer type automatically if we are in the
+    // broken case.  See PR424 for more information.
+    if (!isa(Ty)) {
+      (yyval.ConstVal).C = ConstantExpr::get(Opcode, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
+    } else {
+      const Type *IntPtrTy = 0;
+      switch (CurModule.CurrentModule->getPointerSize()) {
+      case Module::Pointer32: IntPtrTy = Type::Int32Ty; break;
+      case Module::Pointer64: IntPtrTy = Type::Int64Ty; break;
+      default: error("invalid pointer binary constant expr");
+      }
+      (yyval.ConstVal).C = ConstantExpr::get(Opcode, 
+             ConstantExpr::getCast(Instruction::PtrToInt, (yyvsp[-3].ConstVal).C, IntPtrTy),
+             ConstantExpr::getCast(Instruction::PtrToInt, (yyvsp[-1].ConstVal).C, IntPtrTy));
+      (yyval.ConstVal).C = ConstantExpr::getCast(Instruction::IntToPtr, (yyval.ConstVal).C, Ty);
+    }
+    (yyval.ConstVal).S = (yyvsp[-3].ConstVal).S; 
+  ;}
     break;
 
   case 167:
-#line 1406 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 2290 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    *yyvsp[-6].String += " " + *yyvsp[-5].String + " (" +  *yyvsp[-3].Const->cnst + "," + *yyvsp[-1].Const->cnst + ")";
-    delete yyvsp[-5].String; delete yyvsp[-3].Const; delete yyvsp[-1].Const;
-    yyval.String = yyvsp[-6].String;
-  }
+    const Type* Ty = (yyvsp[-3].ConstVal).C->getType();
+    if (Ty != (yyvsp[-1].ConstVal).C->getType())
+      error("Logical operator types must match");
+    if (!Ty->isInteger()) {
+      if (!isa(Ty) || 
+          !cast(Ty)->getElementType()->isInteger())
+        error("Logical operator requires integer operands");
+    }
+    Instruction::BinaryOps Opcode = getBinaryOp((yyvsp[-5].BinaryOpVal), Ty, (yyvsp[-3].ConstVal).S);
+    (yyval.ConstVal).C = ConstantExpr::get(Opcode, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
+    (yyval.ConstVal).S = (yyvsp[-3].ConstVal).S;
+  ;}
     break;
 
   case 168:
-#line 1411 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 2303 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    *yyvsp[-6].String += " " + *yyvsp[-5].String + " (" + *yyvsp[-3].Const->cnst + "," + *yyvsp[-1].Const->cnst + ")";
-    delete yyvsp[-5].String; delete yyvsp[-3].Const; delete yyvsp[-1].Const;
-    yyval.String = yyvsp[-6].String;
-  }
+    const Type* Ty = (yyvsp[-3].ConstVal).C->getType();
+    if (Ty != (yyvsp[-1].ConstVal).C->getType())
+      error("setcc operand types must match");
+    unsigned short pred;
+    Instruction::OtherOps Opcode = getCompareOp((yyvsp[-5].BinaryOpVal), pred, Ty, (yyvsp[-3].ConstVal).S);
+    (yyval.ConstVal).C = ConstantExpr::getCompare(Opcode, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
+    (yyval.ConstVal).S = Unsigned;
+  ;}
     break;
 
   case 169:
-#line 1416 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 2312 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    const char* shiftop = yyvsp[-5].String->c_str();
-    if (*yyvsp[-5].String == "shr")
-      shiftop = (yyvsp[-3].Const->type->isUnsigned()) ? "lshr" : "ashr";
-    yyval.String = new std::string(shiftop);
-    *yyval.String += "(" + *yyvsp[-3].Const->cnst + "," + *yyvsp[-1].Const->cnst + ")";
-    delete yyvsp[-5].String; delete yyvsp[-3].Const; delete yyvsp[-1].Const;
-  }
+    if ((yyvsp[-3].ConstVal).C->getType() != (yyvsp[-1].ConstVal).C->getType()) 
+      error("icmp operand types must match");
+    (yyval.ConstVal).C = ConstantExpr::getCompare((yyvsp[-5].IPred), (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
+    (yyval.ConstVal).S = Unsigned;
+  ;}
     break;
 
   case 170:
-#line 1424 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 2318 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    *yyvsp[-5].String += "(" + *yyvsp[-3].Const->cnst + "," + *yyvsp[-1].Const->cnst + ")";
-    delete yyvsp[-3].Const; delete yyvsp[-1].Const;
-    yyval.String = yyvsp[-5].String;
-  }
+    if ((yyvsp[-3].ConstVal).C->getType() != (yyvsp[-1].ConstVal).C->getType()) 
+      error("fcmp operand types must match");
+    (yyval.ConstVal).C = ConstantExpr::getCompare((yyvsp[-5].FPred), (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
+    (yyval.ConstVal).S = Unsigned;
+  ;}
     break;
 
   case 171:
-#line 1429 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 2324 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    *yyvsp[-7].String += "(" + *yyvsp[-5].Const->cnst + "," + *yyvsp[-3].Const->cnst + "," + *yyvsp[-1].Const->cnst + ")";
-    delete yyvsp[-5].Const; delete yyvsp[-3].Const; delete yyvsp[-1].Const;
-    yyval.String = yyvsp[-7].String;
-  }
+    if (!(yyvsp[-1].ConstVal).C->getType()->isInteger() ||
+        cast((yyvsp[-1].ConstVal).C->getType())->getBitWidth() != 8)
+      error("Shift count for shift constant must be unsigned byte");
+    if (!(yyvsp[-3].ConstVal).C->getType()->isInteger())
+      error("Shift constant expression requires integer operand");
+    (yyval.ConstVal).C = ConstantExpr::get(getOtherOp((yyvsp[-5].OtherOpVal), (yyvsp[-3].ConstVal).S), (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
+    (yyval.ConstVal).S = (yyvsp[-3].ConstVal).S;
+  ;}
     break;
 
   case 172:
-#line 1434 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 2333 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    *yyvsp[-7].String += "(" + *yyvsp[-5].Const->cnst + "," + *yyvsp[-3].Const->cnst + "," + *yyvsp[-1].Const->cnst + ")";
-    delete yyvsp[-5].Const; delete yyvsp[-3].Const; delete yyvsp[-1].Const;
-    yyval.String = yyvsp[-7].String;
-  }
+    if (!ExtractElementInst::isValidOperands((yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C))
+      error("Invalid extractelement operands");
+    (yyval.ConstVal).C = ConstantExpr::getExtractElement((yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
+    (yyval.ConstVal).S = (yyvsp[-3].ConstVal).S;
+  ;}
     break;
 
   case 173:
-#line 1444 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 2339 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    *yyvsp[-2].String += ", " + *yyvsp[0].Const->cnst;
-    delete yyvsp[0].Const;
-    yyval.String = yyvsp[-2].String;
-  }
+    if (!InsertElementInst::isValidOperands((yyvsp[-5].ConstVal).C, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C))
+      error("Invalid insertelement operands");
+    (yyval.ConstVal).C = ConstantExpr::getInsertElement((yyvsp[-5].ConstVal).C, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
+    (yyval.ConstVal).S = (yyvsp[-5].ConstVal).S;
+  ;}
     break;
 
   case 174:
-#line 1449 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    { yyval.String = new std::string(*yyvsp[0].Const->cnst); delete yyvsp[0].Const; }
+#line 2345 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {
+    if (!ShuffleVectorInst::isValidOperands((yyvsp[-5].ConstVal).C, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C))
+      error("Invalid shufflevector operands");
+    (yyval.ConstVal).C = ConstantExpr::getShuffleVector((yyvsp[-5].ConstVal).C, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
+    (yyval.ConstVal).S = (yyvsp[-5].ConstVal).S;
+  ;}
     break;
 
-  case 177:
-#line 1464 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+  case 175:
+#line 2356 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { ((yyval.ConstVector) = (yyvsp[-2].ConstVector))->push_back((yyvsp[0].ConstVal)); ;}
+    break;
+
+  case 176:
+#line 2357 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-}
+    (yyval.ConstVector) = new std::vector();
+    (yyval.ConstVector)->push_back((yyvsp[0].ConstVal));
+  ;}
+    break;
+
+  case 177:
+#line 2366 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.BoolVal) = false; ;}
     break;
 
   case 178:
-#line 1469 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    {
-    yyval.String = 0;
-  }
+#line 2367 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.BoolVal) = true; ;}
     break;
 
   case 179:
-#line 1472 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 2379 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    *O << *yyvsp[0].String << '\n';
-    delete yyvsp[0].String;
-    yyval.String = 0;
-  }
+    (yyval.ModuleVal) = ParserResult = (yyvsp[0].ModuleVal);
+    CurModule.ModuleDone();
+  ;}
     break;
 
   case 180:
-#line 1477 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    {
-    *O << "module asm " << ' ' << *yyvsp[0].String << '\n';
-    yyval.String = 0;
-  }
+#line 2388 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.ModuleVal) = (yyvsp[-1].ModuleVal); CurFun.FunctionDone(); ;}
     break;
 
   case 181:
-#line 1481 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    {
-    *O << "implementation\n";
-    yyval.String = 0;
-  }
+#line 2389 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.ModuleVal) = (yyvsp[-1].ModuleVal); ;}
     break;
 
   case 182:
-#line 1485 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    { yyval.String = 0; }
+#line 2390 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.ModuleVal) = (yyvsp[-3].ModuleVal); ;}
+    break;
+
+  case 183:
+#line 2391 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.ModuleVal) = (yyvsp[-1].ModuleVal); ;}
     break;
 
   case 184:
-#line 1488 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    { yyval.String = yyvsp[0].String; *yyval.String = "external"; }
+#line 2392 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {
+    (yyval.ModuleVal) = CurModule.CurrentModule;
+    // Emit an error if there are any unresolved types left.
+    if (!CurModule.LateResolveTypes.empty()) {
+      const ValID &DID = CurModule.LateResolveTypes.begin()->first;
+      if (DID.Type == ValID::NameVal) {
+        error("Reference to an undefined type: '"+DID.getName() + "'");
+      } else {
+        error("Reference to an undefined type: #" + itostr(DID.Num));
+      }
+    }
+  ;}
     break;
 
   case 185:
-#line 1491 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 2408 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    Type::EnumeratedTypes.push_back(yyvsp[0].Ty);
-    if (!yyvsp[-2].String->empty()) {
-      Type::NamedTypes[*yyvsp[-2].String] = yyvsp[0].Ty;
-      *O << *yyvsp[-2].String << " = ";
-    }
-    *O << "type " << yyvsp[0].Ty->getNewTy() << '\n';
-    delete yyvsp[-2].String; delete yyvsp[-1].String;
-    yyval.String = 0;
-  }
+    // Eagerly resolve types.  This is not an optimization, this is a
+    // requirement that is due to the fact that we could have this:
+    //
+    // %list = type { %list * }
+    // %list = type { %list * }    ; repeated type decl
+    //
+    // If types are not resolved eagerly, then the two types will not be
+    // determined to be the same type!
+    //
+    const Type* Ty = (yyvsp[0].TypeVal).T->get();
+    ResolveTypeTo((yyvsp[-2].StrVal), Ty);
+
+    if (!setTypeName(Ty, (yyvsp[-2].StrVal)) && !(yyvsp[-2].StrVal)) {
+      // If this is a named type that is not a redefinition, add it to the slot
+      // table.
+      CurModule.Types.push_back(Ty);
+    }
+    delete (yyvsp[0].TypeVal).T;
+  ;}
     break;
 
   case 186:
-#line 1501 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 2428 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {       // Function prototypes can be in const pool
-    *O << *yyvsp[0].String << '\n';
-    delete yyvsp[0].String;
-    yyval.String = 0;
-  }
+  ;}
     break;
 
   case 187:
-#line 1506 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 2430 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {  // Asm blocks can be in the const pool
-    *O << *yyvsp[-2].String << ' ' << *yyvsp[-1].String << ' ' << *yyvsp[0].String << '\n';
-    delete yyvsp[-2].String; delete yyvsp[-1].String; delete yyvsp[0].String; 
-    yyval.String = 0;
-  }
+  ;}
     break;
 
   case 188:
-#line 1511 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 2432 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    if (!yyvsp[-4].String->empty()) {
-      std::string Name = getGlobalName(yyvsp[-4].String,*yyvsp[-3].String, yyvsp[-1].Const->type->getPointerType(),
-                                       *yyvsp[-2].String == "constant");
-      *O << Name << " = ";
-    }
-    *O << *yyvsp[-3].String << ' ' << *yyvsp[-2].String << ' ' << *yyvsp[-1].Const->cnst << ' ' << *yyvsp[0].String << '\n';
-    delete yyvsp[-4].String; delete yyvsp[-3].String; delete yyvsp[-2].String; delete yyvsp[0].String; 
-    yyval.String = 0;
-  }
+    if ((yyvsp[0].ConstVal).C == 0) 
+      error("Global value initializer is not a constant");
+    CurGV = ParseGlobalVariable((yyvsp[-3].StrVal), (yyvsp[-2].Linkage), (yyvsp[-1].BoolVal), (yyvsp[0].ConstVal).C->getType(), (yyvsp[0].ConstVal).C);
+  ;}
     break;
 
   case 189:
-#line 1521 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 2436 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    if (!yyvsp[-4].String->empty()) {
-      std::string Name = getGlobalName(yyvsp[-4].String,*yyvsp[-3].String,yyvsp[-1].Ty->getPointerType(),
-                                       *yyvsp[-2].String == "constant");
-      *O << Name << " = ";
-    }
-    *O <<  *yyvsp[-3].String << ' ' << *yyvsp[-2].String << ' ' << yyvsp[-1].Ty->getNewTy() << ' ' << *yyvsp[0].String << '\n';
-    delete yyvsp[-4].String; delete yyvsp[-3].String; delete yyvsp[-2].String; delete yyvsp[0].String;
-    yyval.String = 0;
-  }
+    CurGV = 0;
+  ;}
     break;
 
   case 190:
-#line 1531 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 2439 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    if (!yyvsp[-4].String->empty()) {
-      std::string Name = getGlobalName(yyvsp[-4].String,*yyvsp[-3].String,yyvsp[-1].Ty->getPointerType(),
-                                       *yyvsp[-2].String == "constant");
-      *O << Name << " = ";
-    }
-    *O << *yyvsp[-3].String << ' ' << *yyvsp[-2].String << ' ' << yyvsp[-1].Ty->getNewTy() << ' ' << *yyvsp[0].String << '\n';
-    delete yyvsp[-4].String; delete yyvsp[-3].String; delete yyvsp[-2].String; delete yyvsp[0].String;
-    yyval.String = 0;
-  }
+    const Type *Ty = (yyvsp[0].TypeVal).T->get();
+    CurGV = ParseGlobalVariable((yyvsp[-3].StrVal), GlobalValue::ExternalLinkage, (yyvsp[-1].BoolVal), Ty, 0);
+    delete (yyvsp[0].TypeVal).T;
+  ;}
     break;
 
   case 191:
-#line 1541 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 2443 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    if (!yyvsp[-4].String->empty()) {
-      std::string Name = getGlobalName(yyvsp[-4].String,*yyvsp[-3].String,yyvsp[-1].Ty->getPointerType(),
-                                       *yyvsp[-2].String == "constant");
-      *O << Name << " = ";
-    }
-    *O << *yyvsp[-3].String << ' ' << *yyvsp[-2].String << ' ' << yyvsp[-1].Ty->getNewTy() << ' ' << *yyvsp[0].String << '\n';
-    delete yyvsp[-4].String; delete yyvsp[-3].String; delete yyvsp[-2].String; delete yyvsp[0].String;
-    yyval.String = 0;
-  }
+    CurGV = 0;
+  ;}
     break;
 
   case 192:
-#line 1551 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    { 
-    *O << *yyvsp[-1].String << ' ' << *yyvsp[0].String << '\n';
-    delete yyvsp[-1].String; delete yyvsp[0].String;
-    yyval.String = 0;
-  }
+#line 2446 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {
+    const Type *Ty = (yyvsp[0].TypeVal).T->get();
+    CurGV = ParseGlobalVariable((yyvsp[-3].StrVal), GlobalValue::DLLImportLinkage, (yyvsp[-1].BoolVal), Ty, 0);
+    delete (yyvsp[0].TypeVal).T;
+  ;}
     break;
 
   case 193:
-#line 1556 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 2450 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    *O << *yyvsp[-2].String << " = " << *yyvsp[0].String << '\n';
-    delete yyvsp[-2].String; delete yyvsp[0].String;
-    yyval.String = 0;
-  }
+    CurGV = 0;
+  ;}
     break;
 
   case 194:
-#line 1561 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 2453 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {
+    const Type *Ty = (yyvsp[0].TypeVal).T->get();
+    CurGV = 
+      ParseGlobalVariable((yyvsp[-3].StrVal), GlobalValue::ExternalWeakLinkage, (yyvsp[-1].BoolVal), Ty, 0);
+    delete (yyvsp[0].TypeVal).T;
+  ;}
+    break;
+
+  case 195:
+#line 2458 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {
+    CurGV = 0;
+  ;}
+    break;
+
+  case 196:
+#line 2461 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     { 
-    yyval.String = 0;
-  }
+  ;}
     break;
 
-  case 198:
-#line 1571 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+  case 197:
+#line 2463 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    *yyvsp[-2].String += " = " + *yyvsp[0].String;
-    delete yyvsp[0].String;
-    yyval.String = yyvsp[-2].String;
-  }
+  ;}
+    break;
+
+  case 198:
+#line 2465 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { 
+  ;}
     break;
 
   case 199:
-#line 1576 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 2470 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    *yyvsp[-2].String += " = " + *yyvsp[0].String;
-    if (*yyvsp[0].String == "64")
-      SizeOfPointer = 64;
-    delete yyvsp[0].String;
-    yyval.String = yyvsp[-2].String;
-  }
+    const std::string &AsmSoFar = CurModule.CurrentModule->getModuleInlineAsm();
+    char *EndStr = UnEscapeLexed((yyvsp[0].StrVal), true);
+    std::string NewAsm((yyvsp[0].StrVal), EndStr);
+    free((yyvsp[0].StrVal));
+
+    if (AsmSoFar.empty())
+      CurModule.CurrentModule->setModuleInlineAsm(NewAsm);
+    else
+      CurModule.CurrentModule->setModuleInlineAsm(AsmSoFar+"\n"+NewAsm);
+  ;}
     break;
 
   case 200:
-#line 1583 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    {
-    *yyvsp[-2].String += " = " + *yyvsp[0].String;
-    delete yyvsp[0].String;
-    yyval.String = yyvsp[-2].String;
-  }
+#line 2484 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.Endianness) = Module::BigEndian; ;}
     break;
 
   case 201:
-#line 1588 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    {
-    *yyvsp[-2].String += " = " + *yyvsp[0].String;
-    delete yyvsp[0].String;
-    yyval.String = yyvsp[-2].String;
-  }
+#line 2485 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.Endianness) = Module::LittleEndian; ;}
     break;
 
   case 202:
-#line 1595 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 2489 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    yyvsp[-1].String->insert(0, "[ ");
-    *yyvsp[-1].String += " ]";
-    yyval.String = yyvsp[-1].String;
-  }
+    CurModule.setEndianness((yyvsp[0].Endianness));
+  ;}
     break;
 
   case 203:
-#line 1602 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 2492 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    *yyvsp[-2].String += ", " + *yyvsp[0].String;
-    delete yyvsp[0].String;
-    yyval.String = yyvsp[-2].String;
-  }
+    if ((yyvsp[0].UInt64Val) == 32)
+      CurModule.setPointerSize(Module::Pointer32);
+    else if ((yyvsp[0].UInt64Val) == 64)
+      CurModule.setPointerSize(Module::Pointer64);
+    else
+      error("Invalid pointer size: '" + utostr((yyvsp[0].UInt64Val)) + "'");
+  ;}
     break;
 
-  case 205:
-#line 1608 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+  case 204:
+#line 2500 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    yyval.String = new std::string();
-  }
-    break;
-
-  case 209:
-#line 1617 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    { yyval.String = new std::string(); }
+    CurModule.CurrentModule->setTargetTriple((yyvsp[0].StrVal));
+    free((yyvsp[0].StrVal));
+  ;}
     break;
 
-  case 210:
-#line 1619 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+  case 205:
+#line 2504 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-  yyval.String = new std::string(yyvsp[-1].Ty->getNewTy());
-  if (!yyvsp[0].String->empty()) {
-    std::string Name = getUniqueName(yyvsp[0].String, yyvsp[-1].Ty->resolve());
-    *yyval.String += " " + Name;
-  }
-  delete yyvsp[0].String;
-}
+    CurModule.CurrentModule->setDataLayout((yyvsp[0].StrVal));
+    free((yyvsp[0].StrVal));
+  ;}
     break;
 
-  case 211:
-#line 1628 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+  case 207:
+#line 2515 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    *yyvsp[-2].String += ", " + *yyvsp[0].String;
-    delete yyvsp[0].String;
-  }
+      CurModule.CurrentModule->addLibrary((yyvsp[0].StrVal));
+      free((yyvsp[0].StrVal));
+  ;}
     break;
 
-  case 212:
-#line 1632 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+  case 208:
+#line 2519 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    yyval.String = yyvsp[0].String;
-  }
+    CurModule.CurrentModule->addLibrary((yyvsp[0].StrVal));
+    free((yyvsp[0].StrVal));
+  ;}
+    break;
+
+  case 209:
+#line 2523 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { ;}
     break;
 
   case 213:
-#line 1636 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    {
-    yyval.String = yyvsp[0].String;
-  }
+#line 2536 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.StrVal) = 0; ;}
     break;
 
   case 214:
-#line 1639 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 2540 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    *yyvsp[-2].String += ", ...";
-    yyval.String = yyvsp[-2].String;
-    delete yyvsp[0].String;
-  }
+    if ((yyvsp[-1].TypeVal).T->get() == Type::VoidTy)
+      error("void typed arguments are invalid");
+    (yyval.ArgVal) = new std::pair((yyvsp[-1].TypeVal), (yyvsp[0].StrVal));
+  ;}
     break;
 
   case 215:
-#line 1644 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 2548 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    yyval.String = yyvsp[0].String;
-  }
+    (yyval.ArgList) = (yyvsp[-2].ArgList);
+    (yyval.ArgList)->push_back(*(yyvsp[0].ArgVal));
+    delete (yyvsp[0].ArgVal);
+  ;}
     break;
 
   case 216:
-#line 1647 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    { yyval.String = new std::string(); }
+#line 2553 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {
+    (yyval.ArgList) = new std::vector >();
+    (yyval.ArgList)->push_back(*(yyvsp[0].ArgVal));
+    delete (yyvsp[0].ArgVal);
+  ;}
     break;
 
   case 217:
-#line 1650 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    {
-    if (*yyvsp[-5].String == "%llvm.va_start" || *yyvsp[-5].String == "%llvm.va_end") {
-      *yyvsp[-3].String = "i8*";
-    } else if (*yyvsp[-5].String == "%llvm.va_copy") {
-      *yyvsp[-3].String = "i8*, i8*";
-    }
-    if (!yyvsp[-7].String->empty()) {
-      *yyvsp[-7].String += " ";
-    }
-    *yyvsp[-7].String += yyvsp[-6].Ty->getNewTy() + " " + *yyvsp[-5].String + "(" + *yyvsp[-3].String + ")";
-    if (!yyvsp[-1].String->empty()) {
-      *yyvsp[-7].String += " " + *yyvsp[-1].String;
-    }
-    if (!yyvsp[0].String->empty()) {
-      *yyvsp[-7].String += " " + *yyvsp[0].String;
-    }
-    delete yyvsp[-5].String;
-    delete yyvsp[-3].String;
-    delete yyvsp[-1].String;
-    delete yyvsp[0].String;
-    yyval.String = yyvsp[-7].String;
-  }
+#line 2561 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.ArgList) = (yyvsp[0].ArgList); ;}
     break;
 
   case 218:
-#line 1673 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    { yyval.String = new std::string("{"); delete yyvsp[0].String; }
+#line 2562 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {
+    (yyval.ArgList) = (yyvsp[-2].ArgList);
+    PATypeInfo VoidTI;
+    VoidTI.T = new PATypeHolder(Type::VoidTy);
+    VoidTI.S = Signless;
+    (yyval.ArgList)->push_back(std::pair(VoidTI, 0));
+  ;}
     break;
 
   case 219:
-#line 1674 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    { yyval.String = new std::string ("{"); }
+#line 2569 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {
+    (yyval.ArgList) = new std::vector >();
+    PATypeInfo VoidTI;
+    VoidTI.T = new PATypeHolder(Type::VoidTy);
+    VoidTI.S = Signless;
+    (yyval.ArgList)->push_back(std::pair(VoidTI, 0));
+  ;}
     break;
 
   case 220:
-#line 1678 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    {
-    *O << "define ";
-    if (!yyvsp[-2].String->empty()) {
-      *O << *yyvsp[-2].String << ' ';
-    }
-    *O << *yyvsp[-1].String << ' ' << *yyvsp[0].String << '\n';
-    delete yyvsp[-2].String; delete yyvsp[-1].String; delete yyvsp[0].String;
-    yyval.String = 0;
-  }
+#line 2576 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.ArgList) = 0; ;}
     break;
 
   case 221:
-#line 1689 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    { yyval.String = new std::string("}"); delete yyvsp[0].String; }
+#line 2580 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {
+    UnEscapeLexed((yyvsp[-5].StrVal));
+    std::string FunctionName((yyvsp[-5].StrVal));
+    free((yyvsp[-5].StrVal));  // Free strdup'd memory!
+
+    const Type* RetTy = (yyvsp[-6].TypeVal).T->get();
+    
+    if (!RetTy->isFirstClassType() && RetTy != Type::VoidTy)
+      error("LLVM functions cannot return aggregate types");
+
+    std::vector ParamTypeList;
+
+    // In LLVM 2.0 the signatures of three varargs intrinsics changed to take
+    // i8*. We check here for those names and override the parameter list
+    // types to ensure the prototype is correct.
+    if (FunctionName == "llvm.va_start" || FunctionName == "llvm.va_end") {
+      ParamTypeList.push_back(PointerType::get(Type::Int8Ty));
+    } else if (FunctionName == "llvm.va_copy") {
+      ParamTypeList.push_back(PointerType::get(Type::Int8Ty));
+      ParamTypeList.push_back(PointerType::get(Type::Int8Ty));
+    } else if ((yyvsp[-3].ArgList)) {   // If there are arguments...
+      for (std::vector >::iterator 
+           I = (yyvsp[-3].ArgList)->begin(), E = (yyvsp[-3].ArgList)->end(); I != E; ++I) {
+        const Type *Ty = I->first.T->get();
+        ParamTypeList.push_back(Ty);
+      }
+    }
+
+    bool isVarArg = 
+      ParamTypeList.size() && ParamTypeList.back() == Type::VoidTy;
+    if (isVarArg) ParamTypeList.pop_back();
+
+    const FunctionType *FT = FunctionType::get(RetTy, ParamTypeList, isVarArg);
+    const PointerType *PFT = PointerType::get(FT);
+    delete (yyvsp[-6].TypeVal).T;
+
+    ValID ID;
+    if (!FunctionName.empty()) {
+      ID = ValID::create((char*)FunctionName.c_str());
+    } else {
+      ID = ValID::create((int)CurModule.Values[PFT].size());
+    }
+
+    Function *Fn = 0;
+    // See if this function was forward referenced.  If so, recycle the object.
+    if (GlobalValue *FWRef = CurModule.GetForwardRefForGlobal(PFT, ID)) {
+      // Move the function to the end of the list, from whereever it was 
+      // previously inserted.
+      Fn = cast(FWRef);
+      CurModule.CurrentModule->getFunctionList().remove(Fn);
+      CurModule.CurrentModule->getFunctionList().push_back(Fn);
+    } else if (!FunctionName.empty() &&     // Merge with an earlier prototype?
+               (Fn = CurModule.CurrentModule->getFunction(FunctionName, FT))) {
+      // If this is the case, either we need to be a forward decl, or it needs 
+      // to be.
+      if (!CurFun.isDeclare && !Fn->isExternal())
+        error("Redefinition of function '" + FunctionName + "'");
+      
+      // Make sure to strip off any argument names so we can't get conflicts.
+      if (Fn->isExternal())
+        for (Function::arg_iterator AI = Fn->arg_begin(), AE = Fn->arg_end();
+             AI != AE; ++AI)
+          AI->setName("");
+    } else  {  // Not already defined?
+      Fn = new Function(FT, GlobalValue::ExternalLinkage, FunctionName,
+                        CurModule.CurrentModule);
+
+      InsertValue(Fn, CurModule.Values);
+    }
+
+    CurFun.FunctionStart(Fn);
+
+    if (CurFun.isDeclare) {
+      // If we have declaration, always overwrite linkage.  This will allow us 
+      // to correctly handle cases, when pointer to function is passed as 
+      // argument to another function.
+      Fn->setLinkage(CurFun.Linkage);
+    }
+    Fn->setCallingConv((yyvsp[-7].UIntVal));
+    Fn->setAlignment((yyvsp[0].UIntVal));
+    if ((yyvsp[-1].StrVal)) {
+      Fn->setSection((yyvsp[-1].StrVal));
+      free((yyvsp[-1].StrVal));
+    }
+
+    // Add all of the arguments we parsed to the function...
+    if ((yyvsp[-3].ArgList)) {                     // Is null if empty...
+      if (isVarArg) {  // Nuke the last entry
+        assert((yyvsp[-3].ArgList)->back().first.T->get() == Type::VoidTy && 
+               (yyvsp[-3].ArgList)->back().second == 0 && "Not a varargs marker");
+        delete (yyvsp[-3].ArgList)->back().first.T;
+        (yyvsp[-3].ArgList)->pop_back();  // Delete the last entry
+      }
+      Function::arg_iterator ArgIt = Fn->arg_begin();
+      for (std::vector >::iterator 
+           I = (yyvsp[-3].ArgList)->begin(), E = (yyvsp[-3].ArgList)->end(); I != E; ++I, ++ArgIt) {
+        delete I->first.T;                        // Delete the typeholder...
+        setValueName(ArgIt, I->second);           // Insert arg into symtab...
+        InsertValue(ArgIt);
+      }
+      delete (yyvsp[-3].ArgList);                     // We're now done with the argument list
+    }
+  ;}
+    break;
+
+  case 224:
+#line 2690 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {
+    (yyval.FunctionVal) = CurFun.CurrentFunction;
+
+    // Make sure that we keep track of the linkage type even if there was a
+    // previous "declare".
+    (yyval.FunctionVal)->setLinkage((yyvsp[-2].Linkage));
+  ;}
+    break;
+
+  case 227:
+#line 2704 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {
+    (yyval.FunctionVal) = (yyvsp[-1].FunctionVal);
+  ;}
+    break;
+
+  case 229:
+#line 2710 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { CurFun.Linkage = GlobalValue::DLLImportLinkage; ;}
+    break;
+
+  case 230:
+#line 2711 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { CurFun.Linkage = GlobalValue::ExternalWeakLinkage; ;}
     break;
 
-  case 222:
-#line 1690 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    { yyval.String = new std::string("}"); }
+  case 231:
+#line 2715 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { CurFun.isDeclare = true; ;}
     break;
 
-  case 223:
-#line 1692 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+  case 232:
+#line 2715 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-  if (yyvsp[-1].String)
-    *O << *yyvsp[-1].String;
-  *O << *yyvsp[0].String << "\n\n";
-  delete yyvsp[-2].String; delete yyvsp[-1].String; delete yyvsp[0].String;
-  yyval.String = 0;
-}
+    (yyval.FunctionVal) = CurFun.CurrentFunction;
+    CurFun.FunctionDone();
+    
+  ;}
     break;
 
-  case 224:
-#line 1701 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    { yyval.String = new std::string(); }
+  case 233:
+#line 2727 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.BoolVal) = false; ;}
     break;
 
-  case 227:
-#line 1707 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    { isDeclare = true; }
+  case 234:
+#line 2728 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.BoolVal) = true; ;}
     break;
 
-  case 228:
-#line 1707 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    { 
-    if (!yyvsp[-1].String->empty())
-      *yyvsp[-3].String += " " + *yyvsp[-1].String;
-    *yyvsp[-3].String += " " + *yyvsp[0].String;
-    delete yyvsp[-1].String;
-    delete yyvsp[0].String;
-    yyval.String = yyvsp[-3].String;
-    isDeclare = false;
-  }
+  case 235:
+#line 2733 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {    (yyval.ValIDVal) = ValID::create((yyvsp[0].SInt64Val)); ;}
     break;
 
-  case 229:
-#line 1721 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    { yyval.String = new std::string(); }
+  case 236:
+#line 2734 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.ValIDVal) = ValID::create((yyvsp[0].UInt64Val)); ;}
+    break;
+
+  case 237:
+#line 2735 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.ValIDVal) = ValID::create((yyvsp[0].FPVal)); ;}
+    break;
+
+  case 238:
+#line 2736 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.ValIDVal) = ValID::create(ConstantInt::get(Type::Int1Ty, true)); ;}
     break;
 
   case 239:
-#line 1727 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    { 
-    yyvsp[-1].String->insert(0, "<");
-    *yyvsp[-1].String += ">";
-    yyval.String = yyvsp[-1].String;
-  }
+#line 2737 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.ValIDVal) = ValID::create(ConstantInt::get(Type::Int1Ty, false)); ;}
+    break;
+
+  case 240:
+#line 2738 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.ValIDVal) = ValID::createNull(); ;}
     break;
 
   case 241:
-#line 1733 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    {
-    if (!yyvsp[-3].String->empty()) {
-      *yyvsp[-4].String += " " + *yyvsp[-3].String;
-    }
-    *yyvsp[-4].String += " " + *yyvsp[-2].String + ", " + *yyvsp[0].String;
-    delete yyvsp[-3].String; delete yyvsp[-2].String; delete yyvsp[0].String;
-    yyval.String = yyvsp[-4].String;
-  }
+#line 2739 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.ValIDVal) = ValID::createUndef(); ;}
+    break;
+
+  case 242:
+#line 2740 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.ValIDVal) = ValID::createZeroInit(); ;}
+    break;
+
+  case 243:
+#line 2741 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { // Nonempty unsized packed vector
+    const Type *ETy = (*(yyvsp[-1].ConstVector))[0].C->getType();
+    int NumElements = (yyvsp[-1].ConstVector)->size(); 
+    PackedType* pt = PackedType::get(ETy, NumElements);
+    PATypeHolder* PTy = new PATypeHolder(
+      HandleUpRefs(PackedType::get(ETy, NumElements)));
+    
+    // Verify all elements are correct type!
+    std::vector Elems;
+    for (unsigned i = 0; i < (yyvsp[-1].ConstVector)->size(); i++) {
+      Constant *C = (*(yyvsp[-1].ConstVector))[i].C;
+      const Type *CTy = C->getType();
+      if (ETy != CTy)
+        error("Element #" + utostr(i) + " is not of type '" + 
+              ETy->getDescription() +"' as required!\nIt is of type '" +
+              CTy->getDescription() + "'");
+      Elems.push_back(C);
+    }
+    (yyval.ValIDVal) = ValID::create(ConstantPacked::get(pt, Elems));
+    delete PTy; delete (yyvsp[-1].ConstVector);
+  ;}
     break;
 
   case 244:
-#line 1746 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 2762 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    yyval.Val = new Value;
-    yyval.Val->val = yyvsp[0].String;
-    yyval.Val->constant = false;
-    yyval.Val->type = 0;
-  }
+    (yyval.ValIDVal) = ValID::create((yyvsp[0].ConstVal).C);
+  ;}
     break;
 
   case 245:
-#line 1752 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 2765 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    yyval.Val = new Value;
-    yyval.Val->val = yyvsp[0].String;
-    yyval.Val->constant = true;
-    yyval.Val->type = 0;
-  }
+    char *End = UnEscapeLexed((yyvsp[-2].StrVal), true);
+    std::string AsmStr = std::string((yyvsp[-2].StrVal), End);
+    End = UnEscapeLexed((yyvsp[0].StrVal), true);
+    std::string Constraints = std::string((yyvsp[0].StrVal), End);
+    (yyval.ValIDVal) = ValID::createInlineAsm(AsmStr, Constraints, (yyvsp[-3].BoolVal));
+    free((yyvsp[-2].StrVal));
+    free((yyvsp[0].StrVal));
+  ;}
     break;
 
   case 246:
-#line 1763 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    {
-    yyvsp[-1].Ty = yyvsp[-1].Ty->resolve();
-    std::string Name = getUniqueName(yyvsp[0].Val->val, yyvsp[-1].Ty);
-    yyval.Val = yyvsp[0].Val;
-    delete yyval.Val->val;
-    yyval.Val->val = new std::string(yyvsp[-1].Ty->getNewTy() + " " + Name);
-    yyval.Val->type = yyvsp[-1].Ty;
-  }
+#line 2780 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {  (yyval.ValIDVal) = ValID::create((yyvsp[0].SIntVal)); ;}
     break;
 
   case 247:
-#line 1772 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    {
-    yyval.String = 0;
-  }
-    break;
-
-  case 248:
-#line 1775 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    { // Do not allow functions with 0 basic blocks   
-    yyval.String = 0;
-  }
-    break;
-
-  case 249:
-#line 1783 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    {
-    yyval.String = 0;
-  }
+#line 2781 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {  (yyval.ValIDVal) = ValID::create((yyvsp[0].StrVal)); ;}
     break;
 
   case 250:
-#line 1787 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    {
-    *O << "    " << *yyvsp[0].String << '\n';
-    delete yyvsp[0].String;
-    yyval.String = 0;
-  }
+#line 2794 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { 
+    const Type *Ty = (yyvsp[-1].TypeVal).T->get();
+    (yyval.ValueVal).S = (yyvsp[-1].TypeVal).S;
+    (yyval.ValueVal).V = getVal(Ty, (yyvsp[0].ValIDVal)); 
+    delete (yyvsp[-1].TypeVal).T;
+  ;}
     break;
 
   case 251:
-#line 1792 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 2803 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    yyval.String = 0;
-  }
+    (yyval.FunctionVal) = (yyvsp[-1].FunctionVal);
+  ;}
     break;
 
   case 252:
-#line 1795 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 2806 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { // Do not allow functions with 0 basic blocks   
+    (yyval.FunctionVal) = (yyvsp[-1].FunctionVal);
+  ;}
+    break;
+
+  case 253:
+#line 2815 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    *O << *yyvsp[0].String << '\n';
-    delete yyvsp[0].String;
-    yyval.String = 0;
-  }
+    setValueName((yyvsp[0].TermInstVal), (yyvsp[-1].StrVal));
+    InsertValue((yyvsp[0].TermInstVal));
+    (yyvsp[-2].BasicBlockVal)->getInstList().push_back((yyvsp[0].TermInstVal));
+    InsertValue((yyvsp[-2].BasicBlockVal));
+    (yyval.BasicBlockVal) = (yyvsp[-2].BasicBlockVal);
+  ;}
     break;
 
   case 254:
-#line 1801 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    { yyval.String = yyvsp[0].String; *yyval.String = "unwind"; }
+#line 2825 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {
+    if ((yyvsp[0].InstVal).I)
+      (yyvsp[-1].BasicBlockVal)->getInstList().push_back((yyvsp[0].InstVal).I);
+    (yyval.BasicBlockVal) = (yyvsp[-1].BasicBlockVal);
+  ;}
     break;
 
   case 255:
-#line 1803 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    {              // Return with a result...
-    *O << "    " << *yyvsp[-1].String << ' ' << *yyvsp[0].Val->val << '\n';
-    delete yyvsp[-1].String; delete yyvsp[0].Val;
-    yyval.String = 0;
-  }
+#line 2830 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {
+    (yyval.BasicBlockVal) = CurBB = getBBVal(ValID::create((int)CurFun.NextBBNum++), true);
+    // Make sure to move the basic block to the correct location in the
+    // function, instead of leaving it inserted wherever it was first
+    // referenced.
+    Function::BasicBlockListType &BBL = 
+      CurFun.CurrentFunction->getBasicBlockList();
+    BBL.splice(BBL.end(), BBL, (yyval.BasicBlockVal));
+  ;}
     break;
 
   case 256:
-#line 1808 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    {                                       // Return with no result...
-    *O << "    " << *yyvsp[-1].String << ' ' << yyvsp[0].Ty->getNewTy() << '\n';
-    delete yyvsp[-1].String;
-    yyval.String = 0;
-  }
-    break;
-
-  case 257:
-#line 1813 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    {                         // Unconditional Branch...
-    *O << "    " << *yyvsp[-2].String << ' ' << yyvsp[-1].Ty->getNewTy() << ' ' << *yyvsp[0].Val->val << '\n';
-    delete yyvsp[-2].String; delete yyvsp[0].Val;
-    yyval.String = 0;
-  }
-    break;
-
-  case 258:
-#line 1818 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    {  
-    std::string Name = getUniqueName(yyvsp[-6].Val->val, yyvsp[-7].Ty);
-    *O << "    " << *yyvsp[-8].String << ' ' << yyvsp[-7].Ty->getNewTy() << ' ' << Name << ", " 
-       << yyvsp[-4].Ty->getNewTy() << ' ' << *yyvsp[-3].Val->val << ", " << yyvsp[-1].Ty->getNewTy() << ' ' 
-       << *yyvsp[0].Val->val << '\n';
-    delete yyvsp[-8].String; delete yyvsp[-6].Val; delete yyvsp[-3].Val; delete yyvsp[0].Val;
-    yyval.String = 0;
-  }
+#line 2839 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {
+    (yyval.BasicBlockVal) = CurBB = getBBVal(ValID::create((yyvsp[0].StrVal)), true);
+    // Make sure to move the basic block to the correct location in the
+    // function, instead of leaving it inserted wherever it was first
+    // referenced.
+    Function::BasicBlockListType &BBL = 
+      CurFun.CurrentFunction->getBasicBlockList();
+    BBL.splice(BBL.end(), BBL, (yyval.BasicBlockVal));
+  ;}
     break;
 
   case 259:
-#line 1826 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    {
-    std::string Name = getUniqueName(yyvsp[-6].Val->val, yyvsp[-7].Ty);
-    *O << "    " << *yyvsp[-8].String << ' ' << yyvsp[-7].Ty->getNewTy() << ' ' << Name << ", " 
-       << yyvsp[-4].Ty->getNewTy() << ' ' << *yyvsp[-3].Val->val << " [" << *yyvsp[-1].String << " ]\n";
-    delete yyvsp[-8].String; 
-    delete yyvsp[-6].Val;
-    delete yyvsp[-3].Val; 
-    delete yyvsp[-1].String;
-    yyval.String = 0;
-  }
+#line 2853 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {              // Return with a result...
+    (yyval.TermInstVal) = new ReturnInst((yyvsp[0].ValueVal).V);
+  ;}
     break;
 
   case 260:
-#line 1836 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    {
-    std::string Name = getUniqueName(yyvsp[-5].Val->val, yyvsp[-6].Ty);
-    *O << "    " << *yyvsp[-7].String << ' ' << yyvsp[-6].Ty->getNewTy() << ' ' << Name << ", " 
-       << yyvsp[-3].Ty->getNewTy() << ' ' << *yyvsp[-2].Val->val << "[]\n";
-    delete yyvsp[-7].String; 
-    delete yyvsp[-5].Val; 
-    delete yyvsp[-2].Val;
-    yyval.String = 0;
-  }
+#line 2856 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {                                       // Return with no result...
+    (yyval.TermInstVal) = new ReturnInst();
+  ;}
     break;
 
   case 261:
-#line 1846 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    {
-    const Type* ResTy = getFunctionReturnType(yyvsp[-10].Ty);
-    *O << "    ";
-    if (!yyvsp[-13].String->empty()) {
-      std::string Name = getUniqueName(yyvsp[-13].String, ResTy);
-      *O << Name << " = ";
-    }
-    *O << *yyvsp[-12].String << ' ' << *yyvsp[-11].String << ' ' << yyvsp[-10].Ty->getNewTy() << ' ' << *yyvsp[-9].Val->val << " (";
-    for (unsigned i = 0; i < yyvsp[-7].ValList->size(); ++i) {
-      Value* V = (*yyvsp[-7].ValList)[i];
-      *O << *V->val;
-      if (i+1 < yyvsp[-7].ValList->size())
-        *O << ", ";
-      delete V;
-    }
-    *O << ") " << *yyvsp[-5].String << ' ' << yyvsp[-4].Ty->getNewTy() << ' ' << *yyvsp[-3].Val->val << ' ' 
-       << *yyvsp[-2].String << ' ' << yyvsp[-1].Ty->getNewTy() << ' ' << *yyvsp[0].Val->val << '\n';
-    delete yyvsp[-13].String; delete yyvsp[-12].String; delete yyvsp[-11].String; delete yyvsp[-9].Val; delete yyvsp[-7].ValList; 
-    delete yyvsp[-5].String; delete yyvsp[-3].Val; delete yyvsp[-2].String; delete yyvsp[0].Val; 
-    yyval.String = 0;
-  }
+#line 2859 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {                         // Unconditional Branch...
+    BasicBlock* tmpBB = getBBVal((yyvsp[0].ValIDVal));
+    (yyval.TermInstVal) = new BranchInst(tmpBB);
+  ;}
     break;
 
   case 262:
-#line 1867 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    {
-    *O << "    " << *yyvsp[0].String << '\n';
-    delete yyvsp[0].String;
-    yyval.String = 0;
-  }
+#line 2863 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {  
+    BasicBlock* tmpBBA = getBBVal((yyvsp[-3].ValIDVal));
+    BasicBlock* tmpBBB = getBBVal((yyvsp[0].ValIDVal));
+    Value* tmpVal = getVal(Type::Int1Ty, (yyvsp[-6].ValIDVal));
+    (yyval.TermInstVal) = new BranchInst(tmpBBA, tmpBBB, tmpVal);
+  ;}
     break;
 
   case 263:
-#line 1872 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 2869 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    *O << "    " << *yyvsp[0].String << '\n';
-    delete yyvsp[0].String;
-    yyval.String = 0;
-  }
+    Value* tmpVal = getVal((yyvsp[-7].PrimType).T, (yyvsp[-6].ValIDVal));
+    BasicBlock* tmpBB = getBBVal((yyvsp[-3].ValIDVal));
+    SwitchInst *S = new SwitchInst(tmpVal, tmpBB, (yyvsp[-1].JumpTable)->size());
+    (yyval.TermInstVal) = S;
+    std::vector >::iterator I = (yyvsp[-1].JumpTable)->begin(),
+      E = (yyvsp[-1].JumpTable)->end();
+    for (; I != E; ++I) {
+      if (ConstantInt *CI = dyn_cast(I->first))
+          S->addCase(CI, I->second);
+      else
+        error("Switch case is constant, but not a simple integer");
+    }
+    delete (yyvsp[-1].JumpTable);
+  ;}
     break;
 
   case 264:
-#line 1878 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 2884 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    *yyvsp[-5].String += " " + yyvsp[-4].Ty->getNewTy() + " " + *yyvsp[-3].String + ", " + yyvsp[-1].Ty->getNewTy() + " " + 
-           *yyvsp[0].Val->val;
-    delete yyvsp[-3].String; delete yyvsp[0].Val;
-    yyval.String = yyvsp[-5].String;
-  }
+    Value* tmpVal = getVal((yyvsp[-6].PrimType).T, (yyvsp[-5].ValIDVal));
+    BasicBlock* tmpBB = getBBVal((yyvsp[-2].ValIDVal));
+    SwitchInst *S = new SwitchInst(tmpVal, tmpBB, 0);
+    (yyval.TermInstVal) = S;
+  ;}
     break;
 
   case 265:
-#line 1884 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 2891 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    yyvsp[-3].String->insert(0, yyvsp[-4].Ty->getNewTy() + " " );
-    *yyvsp[-3].String += ", " + yyvsp[-1].Ty->getNewTy() + " " + *yyvsp[0].Val->val;
-    delete yyvsp[0].Val;
-    yyval.String = yyvsp[-3].String;
-  }
+    const PointerType *PFTy;
+    const FunctionType *Ty;
+
+    if (!(PFTy = dyn_cast((yyvsp[-10].TypeVal).T->get())) ||
+        !(Ty = dyn_cast(PFTy->getElementType()))) {
+      // Pull out the types of all of the arguments...
+      std::vector ParamTypes;
+      if ((yyvsp[-7].ValueList)) {
+        for (std::vector::iterator I = (yyvsp[-7].ValueList)->begin(), E = (yyvsp[-7].ValueList)->end();
+             I != E; ++I)
+          ParamTypes.push_back((*I).V->getType());
+      }
+      bool isVarArg = ParamTypes.size() && ParamTypes.back() == Type::VoidTy;
+      if (isVarArg) ParamTypes.pop_back();
+      Ty = FunctionType::get((yyvsp[-10].TypeVal).T->get(), ParamTypes, isVarArg);
+      PFTy = PointerType::get(Ty);
+    }
+    Value *V = getVal(PFTy, (yyvsp[-9].ValIDVal));   // Get the function we're calling...
+    BasicBlock *Normal = getBBVal((yyvsp[-3].ValIDVal));
+    BasicBlock *Except = getBBVal((yyvsp[0].ValIDVal));
+
+    // Create the call node...
+    if (!(yyvsp[-7].ValueList)) {                                   // Has no arguments?
+      (yyval.TermInstVal) = new InvokeInst(V, Normal, Except, std::vector());
+    } else {                                     // Has arguments?
+      // Loop through FunctionType's arguments and ensure they are specified
+      // correctly!
+      //
+      FunctionType::param_iterator I = Ty->param_begin();
+      FunctionType::param_iterator E = Ty->param_end();
+      std::vector::iterator ArgI = (yyvsp[-7].ValueList)->begin(), ArgE = (yyvsp[-7].ValueList)->end();
+
+      std::vector Args;
+      for (; ArgI != ArgE && I != E; ++ArgI, ++I) {
+        if ((*ArgI).V->getType() != *I)
+          error("Parameter " +(*ArgI).V->getName()+ " is not of type '" +
+                (*I)->getDescription() + "'");
+        Args.push_back((*ArgI).V);
+      }
+
+      if (I != E || (ArgI != ArgE && !Ty->isVarArg()))
+        error("Invalid number of parameters detected");
+
+      (yyval.TermInstVal) = new InvokeInst(V, Normal, Except, Args);
+    }
+    cast((yyval.TermInstVal))->setCallingConv((yyvsp[-11].UIntVal));
+    delete (yyvsp[-10].TypeVal).T;
+    delete (yyvsp[-7].ValueList);
+  ;}
     break;
 
   case 266:
-#line 1892 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 2941 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    if (!yyvsp[-1].String->empty()) {
-      // Get a unique name for this value, based on its type.
-      std::string Name = getUniqueName(yyvsp[-1].String, yyvsp[0].Val->type);
-      *yyvsp[-1].String = Name + " = ";
-      if (deleteUselessCastFlag && *deleteUselessCastName == Name) {
-        // don't actually delete it, just comment it out
-        yyvsp[-1].String->insert(0, "; USELSS BITCAST: "); 
-        delete deleteUselessCastName;
-      }
-    }
-    *yyvsp[-1].String += *yyvsp[0].Val->val;
-    delete yyvsp[0].Val;
-    deleteUselessCastFlag = false;
-    yyval.String = yyvsp[-1].String; 
-  }
+    (yyval.TermInstVal) = new UnwindInst();
+  ;}
     break;
 
   case 267:
-#line 1910 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    {    // Used for PHI nodes
-    std::string Name = getUniqueName(yyvsp[-3].Val->val, yyvsp[-5].Ty);
-    Name.insert(0, yyvsp[-5].Ty->getNewTy() + "[");
-    Name += "," + *yyvsp[-1].Val->val + "]";
-    yyval.Val = new Value;
-    yyval.Val->val = new std::string(Name);
-    yyval.Val->type = yyvsp[-5].Ty;
-    delete yyvsp[-3].Val; delete yyvsp[-1].Val;
-  }
+#line 2944 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {
+    (yyval.TermInstVal) = new UnreachableInst();
+  ;}
     break;
 
   case 268:
-#line 1919 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 2950 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    std::string Name = getUniqueName(yyvsp[-3].Val->val, yyvsp[-6].Val->type);
-    *yyvsp[-6].Val->val += ", [" + Name + "," + *yyvsp[-1].Val->val + "]";
-    delete yyvsp[-3].Val; 
-    delete yyvsp[-1].Val;
-    yyval.Val = yyvsp[-6].Val;
-  }
+    (yyval.JumpTable) = (yyvsp[-5].JumpTable);
+    Constant *V = cast(getExistingValue((yyvsp[-4].PrimType).T, (yyvsp[-3].ValIDVal)));
+    
+    if (V == 0)
+      error("May only switch on a constant pool value");
+
+    BasicBlock* tmpBB = getBBVal((yyvsp[0].ValIDVal));
+    (yyval.JumpTable)->push_back(std::make_pair(V, tmpBB));
+  ;}
     break;
 
   case 269:
-#line 1929 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 2960 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    yyval.ValList = new ValueList();
-    yyval.ValList->push_back(yyvsp[0].Val);
-  }
+    (yyval.JumpTable) = new std::vector >();
+    Constant *V = cast(getExistingValue((yyvsp[-4].PrimType).T, (yyvsp[-3].ValIDVal)));
+
+    if (V == 0)
+      error("May only switch on a constant pool value");
+
+    BasicBlock* tmpBB = getBBVal((yyvsp[0].ValIDVal));
+    (yyval.JumpTable)->push_back(std::make_pair(V, tmpBB)); 
+  ;}
     break;
 
   case 270:
-#line 1933 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 2973 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    yyval.ValList = yyvsp[-2].ValList;
-    yyval.ValList->push_back(yyvsp[0].Val);
-  }
+    bool omit = false;
+    if ((yyvsp[-1].StrVal))
+      if (BitCastInst *BCI = dyn_cast((yyvsp[0].InstVal).I))
+        if (BCI->getSrcTy() == BCI->getDestTy() && 
+            BCI->getOperand(0)->getName() == (yyvsp[-1].StrVal))
+          // This is a useless bit cast causing a name redefinition. It is
+          // a bit cast from a type to the same type of an operand with the
+          // same name as the name we would give this instruction. Since this
+          // instruction results in no code generation, it is safe to omit
+          // the instruction. This situation can occur because of collapsed
+          // type planes. For example:
+          //   %X = add int %Y, %Z
+          //   %X = cast int %Y to uint
+          // After upgrade, this looks like:
+          //   %X = add i32 %Y, %Z
+          //   %X = bitcast i32 to i32
+          // The bitcast is clearly useless so we omit it.
+          omit = true;
+    if (omit) {
+      (yyval.InstVal).I = 0;
+      (yyval.InstVal).S = Signless;
+    } else {
+      setValueName((yyvsp[0].InstVal).I, (yyvsp[-1].StrVal));
+      InsertValue((yyvsp[0].InstVal).I);
+      (yyval.InstVal) = (yyvsp[0].InstVal);
+    }
+  ;}
     break;
 
   case 271:
-#line 1940 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    { yyval.ValList = yyvsp[0].ValList; }
+#line 3002 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {    // Used for PHI nodes
+    (yyval.PHIList).P = new std::list >();
+    (yyval.PHIList).S = (yyvsp[-5].TypeVal).S;
+    Value* tmpVal = getVal((yyvsp[-5].TypeVal).T->get(), (yyvsp[-3].ValIDVal));
+    BasicBlock* tmpBB = getBBVal((yyvsp[-1].ValIDVal));
+    (yyval.PHIList).P->push_back(std::make_pair(tmpVal, tmpBB));
+    delete (yyvsp[-5].TypeVal).T;
+  ;}
     break;
 
   case 272:
-#line 1941 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    { yyval.ValList = new ValueList(); }
+#line 3010 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {
+    (yyval.PHIList) = (yyvsp[-6].PHIList);
+    Value* tmpVal = getVal((yyvsp[-6].PHIList).P->front().first->getType(), (yyvsp[-3].ValIDVal));
+    BasicBlock* tmpBB = getBBVal((yyvsp[-1].ValIDVal));
+    (yyvsp[-6].PHIList).P->push_back(std::make_pair(tmpVal, tmpBB));
+  ;}
     break;
 
   case 273:
-#line 1945 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    {
-    *yyvsp[-1].String += " " + *yyvsp[0].String;
-    delete yyvsp[0].String;
-    yyval.String = yyvsp[-1].String;
-  }
+#line 3018 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {    // Used for call statements, and memory insts...
+    (yyval.ValueList) = new std::vector();
+    (yyval.ValueList)->push_back((yyvsp[0].ValueVal));
+  ;}
     break;
 
-  case 275:
-#line 1953 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    {
-    const char* op = getDivRemOpcode(*yyvsp[-4].String, yyvsp[-3].Ty); 
-    std::string Name1 = getUniqueName(yyvsp[-2].Val->val, yyvsp[-3].Ty);
-    std::string Name2 = getUniqueName(yyvsp[0].Val->val, yyvsp[-3].Ty);
-    yyval.Val = yyvsp[-2].Val;
-    delete yyval.Val->val;
-    yyval.Val->val = new std::string(op);
-    *yyval.Val->val += " " + yyvsp[-3].Ty->getNewTy() + " " + Name1 + ", " + Name2;
-    yyval.Val->type = yyvsp[-3].Ty;
-    delete yyvsp[-4].String; delete yyvsp[0].Val;
-  }
+  case 274:
+#line 3022 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {
+    (yyval.ValueList) = (yyvsp[-2].ValueList);
+    (yyvsp[-2].ValueList)->push_back((yyvsp[0].ValueVal));
+  ;}
     break;
 
   case 276:
-#line 1964 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    {
-    std::string Name1 = getUniqueName(yyvsp[-2].Val->val, yyvsp[-3].Ty);
-    std::string Name2 = getUniqueName(yyvsp[0].Val->val, yyvsp[-3].Ty);
-    *yyvsp[-4].String += " " + yyvsp[-3].Ty->getNewTy() + " " + Name1 + ", " + Name2;
-    yyval.Val = yyvsp[-2].Val;
-    delete yyval.Val->val;
-    yyval.Val->val = yyvsp[-4].String;
-    yyval.Val->type = yyvsp[-3].Ty;
-    delete yyvsp[0].Val;
-  }
+#line 3030 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.ValueList) = 0; ;}
     break;
 
   case 277:
-#line 1974 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 3034 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    std::string Name1 = getUniqueName(yyvsp[-2].Val->val, yyvsp[-3].Ty);
-    std::string Name2 = getUniqueName(yyvsp[0].Val->val, yyvsp[-3].Ty);
-    *yyvsp[-4].String = getCompareOp(*yyvsp[-4].String, yyvsp[-3].Ty);
-    *yyvsp[-4].String += " " + yyvsp[-3].Ty->getNewTy() + " " + Name1 + ", " + Name2;
-    yyval.Val = yyvsp[-2].Val;
-    delete yyval.Val->val;
-    yyval.Val->val = yyvsp[-4].String;
-    yyval.Val->type = Type::get("i1",BoolTy);
-    delete yyvsp[0].Val;
-  }
+    (yyval.BoolVal) = true;
+  ;}
     break;
 
   case 278:
-#line 1985 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 3037 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    std::string Name1 = getUniqueName(yyvsp[-2].Val->val, yyvsp[-3].Ty);
-    std::string Name2 = getUniqueName(yyvsp[0].Val->val, yyvsp[-3].Ty);
-    *yyvsp[-5].String += " " + *yyvsp[-4].String + " " + yyvsp[-3].Ty->getNewTy() + " " + Name1 + "," + Name2;
-    yyval.Val = yyvsp[-2].Val;
-    delete yyval.Val->val;
-    yyval.Val->val = yyvsp[-5].String;
-    yyval.Val->type = Type::get("i1",BoolTy);
-    delete yyvsp[-4].String; delete yyvsp[0].Val;
-  }
+    (yyval.BoolVal) = false;
+  ;}
     break;
 
   case 279:
-#line 1995 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 3043 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    std::string Name1 = getUniqueName(yyvsp[-2].Val->val, yyvsp[-3].Ty);
-    std::string Name2 = getUniqueName(yyvsp[0].Val->val, yyvsp[-3].Ty);
-    *yyvsp[-5].String += " " + *yyvsp[-4].String + " " + yyvsp[-3].Ty->getNewTy() + " " + Name1 + "," + Name2;
-    yyval.Val = yyvsp[-2].Val;
-    delete yyval.Val->val;
-    yyval.Val->val = yyvsp[-5].String;
-    yyval.Val->type = Type::get("i1",BoolTy);
-    delete yyvsp[-4].String; delete yyvsp[0].Val;
-  }
+    const Type* Ty = (yyvsp[-3].TypeVal).T->get();
+    if (!Ty->isInteger() && !Ty->isFloatingPoint() && !isa(Ty))
+      error("Arithmetic operator requires integer, FP, or packed operands");
+    if (isa(Ty) && 
+        ((yyvsp[-4].BinaryOpVal) == URemOp || (yyvsp[-4].BinaryOpVal) == SRemOp || (yyvsp[-4].BinaryOpVal) == FRemOp || (yyvsp[-4].BinaryOpVal) == RemOp))
+      error("Remainder not supported on packed types");
+    // Upgrade the opcode from obsolete versions before we do anything with it.
+    Instruction::BinaryOps Opcode = getBinaryOp((yyvsp[-4].BinaryOpVal), Ty, (yyvsp[-3].TypeVal).S);
+    Value* val1 = getVal(Ty, (yyvsp[-2].ValIDVal)); 
+    Value* val2 = getVal(Ty, (yyvsp[0].ValIDVal));
+    (yyval.InstVal).I = BinaryOperator::create(Opcode, val1, val2);
+    if ((yyval.InstVal).I == 0)
+      error("binary operator returned null");
+    (yyval.InstVal).S = (yyvsp[-3].TypeVal).S;
+    delete (yyvsp[-3].TypeVal).T;
+  ;}
     break;
 
   case 280:
-#line 2005 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 3060 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    const char* shiftop = yyvsp[-3].String->c_str();
-    if (*yyvsp[-3].String == "shr")
-      shiftop = (yyvsp[-2].Val->type->isUnsigned()) ? "lshr" : "ashr";
-    std::string *val = new std::string(shiftop);
-    *val += " " + *yyvsp[-2].Val->val + ", " + *yyvsp[0].Val->val;
-    yyval.Val = yyvsp[-2].Val;
-    delete yyval.Val->val;
-    yyval.Val->val = val;
-    delete yyvsp[-3].String; delete yyvsp[0].Val;
-  }
+    const Type *Ty = (yyvsp[-3].TypeVal).T->get();
+    if (!Ty->isInteger()) {
+      if (!isa(Ty) ||
+          !cast(Ty)->getElementType()->isInteger())
+        error("Logical operator requires integral operands");
+    }
+    Instruction::BinaryOps Opcode = getBinaryOp((yyvsp[-4].BinaryOpVal), Ty, (yyvsp[-3].TypeVal).S);
+    Value* tmpVal1 = getVal(Ty, (yyvsp[-2].ValIDVal));
+    Value* tmpVal2 = getVal(Ty, (yyvsp[0].ValIDVal));
+    (yyval.InstVal).I = BinaryOperator::create(Opcode, tmpVal1, tmpVal2);
+    if ((yyval.InstVal).I == 0)
+      error("binary operator returned null");
+    (yyval.InstVal).S = (yyvsp[-3].TypeVal).S;
+    delete (yyvsp[-3].TypeVal).T;
+  ;}
     break;
 
   case 281:
-#line 2016 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 3076 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    std::string source = *yyvsp[-2].Val->val;
-    const Type* SrcTy = yyvsp[-2].Val->type->resolve();
-    const Type* DstTy = yyvsp[0].Ty->resolve();
-    yyval.Val = yyvsp[-2].Val;
-    delete yyval.Val->val;
-    yyval.Val->val = new std::string();
-    yyval.Val->type = DstTy;
-    if (*yyvsp[-3].String == "cast") {
-      *yyval.Val->val += getCastUpgrade(source, SrcTy, DstTy, false);
-    } else {
-      *yyval.Val->val += *yyvsp[-3].String + " " + source + " to " + DstTy->getNewTy();
-    }
-    // Check to see if this is a useless cast of a value to the same name
-    // and the same type. Such casts will probably cause redefinition errors
-    // when assembled and perform no code gen action so just remove them.
-    if (*yyvsp[-3].String == "cast" || *yyvsp[-3].String == "bitcast")
-      if (SrcTy->isInteger() && DstTy->isInteger() &&
-          SrcTy->getBitWidth() == DstTy->getBitWidth()) {
-        deleteUselessCastFlag = true; // Flag the "Inst" rule
-        deleteUselessCastName = new std::string(*yyvsp[-2].Val->val); // save the name
-        size_t pos = deleteUselessCastName->find_first_of("%\"",0);
-        if (pos != std::string::npos) {
-          // remove the type portion before val
-          deleteUselessCastName->erase(0, pos);
-        }
-      }
-    delete yyvsp[-3].String; 
-    delete yyvsp[-1].String;
-  }
+    const Type* Ty = (yyvsp[-3].TypeVal).T->get();
+    if(isa(Ty))
+      error("PackedTypes currently not supported in setcc instructions");
+    unsigned short pred;
+    Instruction::OtherOps Opcode = getCompareOp((yyvsp[-4].BinaryOpVal), pred, Ty, (yyvsp[-3].TypeVal).S);
+    Value* tmpVal1 = getVal(Ty, (yyvsp[-2].ValIDVal));
+    Value* tmpVal2 = getVal(Ty, (yyvsp[0].ValIDVal));
+    (yyval.InstVal).I = CmpInst::create(Opcode, pred, tmpVal1, tmpVal2);
+    if ((yyval.InstVal).I == 0)
+      error("binary operator returned null");
+    (yyval.InstVal).S = Unsigned;
+    delete (yyvsp[-3].TypeVal).T;
+  ;}
     break;
 
   case 282:
-#line 2046 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 3090 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    *yyvsp[-5].String += " " + *yyvsp[-4].Val->val + ", " + *yyvsp[-2].Val->val + ", " + *yyvsp[0].Val->val;
-    yyval.Val = yyvsp[-4].Val;
-    delete yyval.Val->val;
-    yyval.Val->val = yyvsp[-5].String;
-    yyval.Val->type = yyvsp[-2].Val->type;
-    delete yyvsp[-2].Val;
-    delete yyvsp[0].Val;
-  }
+    const Type *Ty = (yyvsp[-3].TypeVal).T->get();
+    if (isa(Ty)) 
+      error("PackedTypes currently not supported in icmp instructions");
+    else if (!Ty->isInteger() && !isa(Ty))
+      error("icmp requires integer or pointer typed operands");
+    Value* tmpVal1 = getVal(Ty, (yyvsp[-2].ValIDVal));
+    Value* tmpVal2 = getVal(Ty, (yyvsp[0].ValIDVal));
+    (yyval.InstVal).I = new ICmpInst((yyvsp[-4].IPred), tmpVal1, tmpVal2);
+    (yyval.InstVal).S = Unsigned;
+    delete (yyvsp[-3].TypeVal).T;
+  ;}
     break;
 
   case 283:
-#line 2055 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 3102 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    *yyvsp[-3].String += " " + *yyvsp[-2].Val->val + ", " + yyvsp[0].Ty->getNewTy();
-    yyval.Val = yyvsp[-2].Val;
-    delete yyval.Val->val;
-    yyval.Val->val = yyvsp[-3].String;
-    yyval.Val->type = yyvsp[0].Ty;
-  }
+    const Type *Ty = (yyvsp[-3].TypeVal).T->get();
+    if (isa(Ty))
+      error("PackedTypes currently not supported in fcmp instructions");
+    else if (!Ty->isFloatingPoint())
+      error("fcmp instruction requires floating point operands");
+    Value* tmpVal1 = getVal(Ty, (yyvsp[-2].ValIDVal));
+    Value* tmpVal2 = getVal(Ty, (yyvsp[0].ValIDVal));
+    (yyval.InstVal).I = new FCmpInst((yyvsp[-4].FPred), tmpVal1, tmpVal2);
+    (yyval.InstVal).S = Unsigned;
+    delete (yyvsp[-3].TypeVal).T;
+  ;}
     break;
 
   case 284:
-#line 2062 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 3114 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    *yyvsp[-3].String += " " + *yyvsp[-2].Val->val + ", " + *yyvsp[0].Val->val;
-    yyval.Val = yyvsp[-2].Val;
-    delete yyval.Val->val;
-    yyval.Val->val = yyvsp[-3].String;
-    yyval.Val->type = yyval.Val->type->resolve();
-    yyval.Val->type = yyval.Val->type->getElementType();
-    delete yyvsp[0].Val;
-  }
+    warning("Use of obsolete 'not' instruction: Replacing with 'xor");
+    const Type *Ty = (yyvsp[0].ValueVal).V->getType();
+    Value *Ones = ConstantInt::getAllOnesValue(Ty);
+    if (Ones == 0)
+      error("Expected integral type for not instruction");
+    (yyval.InstVal).I = BinaryOperator::create(Instruction::Xor, (yyvsp[0].ValueVal).V, Ones);
+    if ((yyval.InstVal).I == 0)
+      error("Could not create a xor instruction");
+    (yyval.InstVal).S = (yyvsp[0].ValueVal).S
+  ;}
     break;
 
   case 285:
-#line 2071 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 3125 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    *yyvsp[-5].String += " " + *yyvsp[-4].Val->val + ", " + *yyvsp[-2].Val->val + ", " + *yyvsp[0].Val->val;
-    yyval.Val = yyvsp[-4].Val;
-    delete yyval.Val->val;
-    yyval.Val->val = yyvsp[-5].String;
-    delete yyvsp[-2].Val; delete yyvsp[0].Val;
-  }
+    if (!(yyvsp[0].ValueVal).V->getType()->isInteger() ||
+        cast((yyvsp[0].ValueVal).V->getType())->getBitWidth() != 8)
+      error("Shift amount must be int8");
+    if (!(yyvsp[-2].ValueVal).V->getType()->isInteger())
+      error("Shift constant expression requires integer operand");
+    (yyval.InstVal).I = new ShiftInst(getOtherOp((yyvsp[-3].OtherOpVal), (yyvsp[-2].ValueVal).S), (yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V);
+    (yyval.InstVal).S = (yyvsp[-2].ValueVal).S;
+  ;}
     break;
 
   case 286:
-#line 2078 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 3134 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    *yyvsp[-5].String += " " + *yyvsp[-4].Val->val + ", " + *yyvsp[-2].Val->val + ", " + *yyvsp[0].Val->val;
-    yyval.Val = yyvsp[-4].Val;
-    delete yyval.Val->val;
-    yyval.Val->val = yyvsp[-5].String;
-    delete yyvsp[-2].Val; delete yyvsp[0].Val;
-  }
+    const Type *DstTy = (yyvsp[0].TypeVal).T->get();
+    if (!DstTy->isFirstClassType())
+      error("cast instruction to a non-primitive type: '" +
+            DstTy->getDescription() + "'");
+    (yyval.InstVal).I = cast(getCast((yyvsp[-3].CastOpVal), (yyvsp[-2].ValueVal).V, (yyvsp[-2].ValueVal).S, DstTy, (yyvsp[0].TypeVal).S, true));
+    (yyval.InstVal).S = (yyvsp[0].TypeVal).S;
+    delete (yyvsp[0].TypeVal).T;
+  ;}
     break;
 
   case 287:
-#line 2085 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 3143 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    *yyvsp[-1].String += " " + *yyvsp[0].Val->val;
-    yyval.Val = yyvsp[0].Val;
-    delete yyvsp[0].Val->val;
-    yyval.Val->val = yyvsp[-1].String;
-  }
+    if (!(yyvsp[-4].ValueVal).V->getType()->isInteger() ||
+        cast((yyvsp[-4].ValueVal).V->getType())->getBitWidth() != 1)
+      error("select condition must be bool");
+    if ((yyvsp[-2].ValueVal).V->getType() != (yyvsp[0].ValueVal).V->getType())
+      error("select value types should match");
+    (yyval.InstVal).I = new SelectInst((yyvsp[-4].ValueVal).V, (yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V);
+    (yyval.InstVal).S = (yyvsp[-4].ValueVal).S;
+  ;}
     break;
 
   case 288:
-#line 2091 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 3152 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    // map llvm.isunordered to "fcmp uno" 
-    yyval.Val = new Value;
-    if (*yyvsp[-3].Val->val == "%llvm.isunordered.f32" ||
-        *yyvsp[-3].Val->val == "%llvm.isunordered.f64") {
-      yyval.Val->val = new std::string( "fcmp uno " + *(*yyvsp[-1].ValList)[0]->val + ", ");
-      size_t pos = (*yyvsp[-1].ValList)[1]->val->find(' ');
-      assert(pos != std::string::npos && "no space?");
-      *yyval.Val->val += (*yyvsp[-1].ValList)[1]->val->substr(pos+1);
-      yyval.Val->type = Type::get("i1", BoolTy);
-    } else {
-      static unsigned upgradeCount = 1;
-      if (*yyvsp[-3].Val->val == "%llvm.va_start" || *yyvsp[-3].Val->val == "%llvm.va_end") {
-        if (!yyvsp[-1].ValList->empty()) {
-          std::string name("%va_upgrade");
-          name += llvm::utostr(upgradeCount++);
-          yyvsp[-6].String->insert(0, name + " = bitcast " + *(*yyvsp[-1].ValList)[0]->val + " to i8*\n    ");
-          *(*yyvsp[-1].ValList)[0]->val = "i8* " + name;
-          (*yyvsp[-1].ValList)[0]->type = Type::get("i8", UByteTy)->getPointerType();
-        }
-      } else if (*yyvsp[-3].Val->val == "%llvm.va_copy") {
-        std::string name0("%va_upgrade");
-        name0 += llvm::utostr(upgradeCount++);
-        std::string name1("%va_upgrade");
-        name1 += llvm::utostr(upgradeCount++);
-        yyvsp[-6].String->insert(0, name0 + " = bitcast " + *(*yyvsp[-1].ValList)[0]->val + " to i8*\n    " +
-                      name1 + " = bitcast " + *(*yyvsp[-1].ValList)[1]->val + " to i8*\n    ");
-        *(*yyvsp[-1].ValList)[0]->val = "i8* " + name0;
-        (*yyvsp[-1].ValList)[0]->type = Type::get("i8", UByteTy)->getPointerType();
-        *(*yyvsp[-1].ValList)[1]->val = "i8* " + name1;
-        (*yyvsp[-1].ValList)[0]->type = Type::get("i8", UByteTy)->getPointerType();
-      }
-      if (!yyvsp[-5].String->empty())
-        *yyvsp[-6].String += " " + *yyvsp[-5].String;
-      if (!yyvsp[-6].String->empty())
-        *yyvsp[-6].String += " ";
-      *yyvsp[-6].String += yyvsp[-4].Ty->getNewTy() + " " + *yyvsp[-3].Val->val + "(";
-      for (unsigned i = 0; i < yyvsp[-1].ValList->size(); ++i) {
-        Value* V = (*yyvsp[-1].ValList)[i];
-        *yyvsp[-6].String += *V->val;
-        if (i+1 < yyvsp[-1].ValList->size())
-          *yyvsp[-6].String += ", ";
-        delete V;
-      }
-      *yyvsp[-6].String += ")";
-      yyval.Val = new Value;
-      yyval.Val->val = yyvsp[-6].String;
-      yyval.Val->type = getFunctionReturnType(yyvsp[-4].Ty);
-    }
-    delete yyvsp[-5].String; delete yyvsp[-3].Val; delete yyvsp[-1].ValList;
-  }
+    const Type *Ty = (yyvsp[0].TypeVal).T->get();
+    NewVarArgs = true;
+    (yyval.InstVal).I = new VAArgInst((yyvsp[-2].ValueVal).V, Ty);
+    (yyval.InstVal).S = (yyvsp[0].TypeVal).S;
+    delete (yyvsp[0].TypeVal).T;
+  ;}
+    break;
+
+  case 289:
+#line 3159 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {
+    const Type* ArgTy = (yyvsp[-2].ValueVal).V->getType();
+    const Type* DstTy = (yyvsp[0].TypeVal).T->get();
+    ObsoleteVarArgs = true;
+    Function* NF = cast(CurModule.CurrentModule->
+      getOrInsertFunction("llvm.va_copy", ArgTy, ArgTy, (Type *)0));
+
+    //b = vaarg a, t -> 
+    //foo = alloca 1 of t
+    //bar = vacopy a 
+    //store bar -> foo
+    //b = vaarg foo, t
+    AllocaInst* foo = new AllocaInst(ArgTy, 0, "vaarg.fix");
+    CurBB->getInstList().push_back(foo);
+    CallInst* bar = new CallInst(NF, (yyvsp[-2].ValueVal).V);
+    CurBB->getInstList().push_back(bar);
+    CurBB->getInstList().push_back(new StoreInst(bar, foo));
+    (yyval.InstVal).I = new VAArgInst(foo, DstTy);
+    (yyval.InstVal).S = (yyvsp[0].TypeVal).S;
+    delete (yyvsp[0].TypeVal).T;
+  ;}
     break;
 
   case 290:
-#line 2147 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    { yyval.ValList = yyvsp[0].ValList; }
+#line 3180 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {
+    const Type* ArgTy = (yyvsp[-2].ValueVal).V->getType();
+    const Type* DstTy = (yyvsp[0].TypeVal).T->get();
+    ObsoleteVarArgs = true;
+    Function* NF = cast(CurModule.CurrentModule->
+      getOrInsertFunction("llvm.va_copy", ArgTy, ArgTy, (Type *)0));
+
+    //b = vanext a, t ->
+    //foo = alloca 1 of t
+    //bar = vacopy a
+    //store bar -> foo
+    //tmp = vaarg foo, t
+    //b = load foo
+    AllocaInst* foo = new AllocaInst(ArgTy, 0, "vanext.fix");
+    CurBB->getInstList().push_back(foo);
+    CallInst* bar = new CallInst(NF, (yyvsp[-2].ValueVal).V);
+    CurBB->getInstList().push_back(bar);
+    CurBB->getInstList().push_back(new StoreInst(bar, foo));
+    Instruction* tmp = new VAArgInst(foo, DstTy);
+    CurBB->getInstList().push_back(tmp);
+    (yyval.InstVal).I = new LoadInst(foo);
+    (yyval.InstVal).S = (yyvsp[0].TypeVal).S;
+    delete (yyvsp[0].TypeVal).T;
+  ;}
     break;
 
   case 291:
-#line 2148 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    {  yyval.ValList = new ValueList(); }
+#line 3204 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {
+    if (!ExtractElementInst::isValidOperands((yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V))
+      error("Invalid extractelement operands");
+    (yyval.InstVal).I = new ExtractElementInst((yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V);
+    (yyval.InstVal).S = (yyvsp[-2].ValueVal).S;
+  ;}
+    break;
+
+  case 292:
+#line 3210 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {
+    if (!InsertElementInst::isValidOperands((yyvsp[-4].ValueVal).V, (yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V))
+      error("Invalid insertelement operands");
+    (yyval.InstVal).I = new InsertElementInst((yyvsp[-4].ValueVal).V, (yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V);
+    (yyval.InstVal).S = (yyvsp[-4].ValueVal).S;
+  ;}
     break;
 
   case 293:
-#line 2153 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    { yyval.String = new std::string(); }
+#line 3216 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {
+    if (!ShuffleVectorInst::isValidOperands((yyvsp[-4].ValueVal).V, (yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V))
+      error("Invalid shufflevector operands");
+    (yyval.InstVal).I = new ShuffleVectorInst((yyvsp[-4].ValueVal).V, (yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V);
+    (yyval.InstVal).S = (yyvsp[-4].ValueVal).S;
+  ;}
     break;
 
   case 294:
-#line 2156 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 3222 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    *yyvsp[-2].String += " " + yyvsp[-1].Ty->getNewTy();
-    if (!yyvsp[0].String->empty())
-      *yyvsp[-2].String += " " + *yyvsp[0].String;
-    yyval.Val = new Value;
-    yyval.Val->val = yyvsp[-2].String;
-    yyval.Val->type = yyvsp[-1].Ty->getPointerType();
-    delete yyvsp[0].String;
-  }
+    const Type *Ty = (yyvsp[0].PHIList).P->front().first->getType();
+    if (!Ty->isFirstClassType())
+      error("PHI node operands must be of first class type");
+    PHINode *PHI = new PHINode(Ty);
+    PHI->reserveOperandSpace((yyvsp[0].PHIList).P->size());
+    while ((yyvsp[0].PHIList).P->begin() != (yyvsp[0].PHIList).P->end()) {
+      if ((yyvsp[0].PHIList).P->front().first->getType() != Ty) 
+        error("All elements of a PHI node must be of the same type");
+      PHI->addIncoming((yyvsp[0].PHIList).P->front().first, (yyvsp[0].PHIList).P->front().second);
+      (yyvsp[0].PHIList).P->pop_front();
+    }
+    (yyval.InstVal).I = PHI;
+    (yyval.InstVal).S = (yyvsp[0].PHIList).S;
+    delete (yyvsp[0].PHIList).P;  // Free the list...
+  ;}
     break;
 
   case 295:
-#line 2165 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 3238 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    std::string Name = getUniqueName(yyvsp[-1].Val->val, yyvsp[-2].Ty);
-    *yyvsp[-5].String += " " + yyvsp[-4].Ty->getNewTy() + ", " + yyvsp[-2].Ty->getNewTy() + " " + Name;
-    if (!yyvsp[0].String->empty())
-      *yyvsp[-5].String += " " + *yyvsp[0].String;
-    yyval.Val = new Value;
-    yyval.Val->val = yyvsp[-5].String;
-    yyval.Val->type = yyvsp[-4].Ty->getPointerType();
-    delete yyvsp[-1].Val; delete yyvsp[0].String;
-  }
+
+    // Handle the short call syntax
+    const PointerType *PFTy;
+    const FunctionType *FTy;
+    if (!(PFTy = dyn_cast((yyvsp[-4].TypeVal).T->get())) ||
+        !(FTy = dyn_cast(PFTy->getElementType()))) {
+      // Pull out the types of all of the arguments...
+      std::vector ParamTypes;
+      if ((yyvsp[-1].ValueList)) {
+        for (std::vector::iterator I = (yyvsp[-1].ValueList)->begin(), E = (yyvsp[-1].ValueList)->end();
+             I != E; ++I)
+          ParamTypes.push_back((*I).V->getType());
+      }
+
+      bool isVarArg = ParamTypes.size() && ParamTypes.back() == Type::VoidTy;
+      if (isVarArg) ParamTypes.pop_back();
+
+      const Type *RetTy = (yyvsp[-4].TypeVal).T->get();
+      if (!RetTy->isFirstClassType() && RetTy != Type::VoidTy)
+        error("Functions cannot return aggregate types");
+
+      FTy = FunctionType::get(RetTy, ParamTypes, isVarArg);
+      PFTy = PointerType::get(FTy);
+    }
+
+    // First upgrade any intrinsic calls.
+    std::vector Args;
+    if ((yyvsp[-1].ValueList))
+      for (unsigned i = 0, e = (yyvsp[-1].ValueList)->size(); i < e; ++i) 
+        Args.push_back((*(yyvsp[-1].ValueList))[i].V);
+    Instruction *Inst = upgradeIntrinsicCall(FTy, (yyvsp[-3].ValIDVal), Args);
+
+    // If we got an upgraded intrinsic
+    if (Inst) {
+      (yyval.InstVal).I = Inst;
+      (yyval.InstVal).S = Signless;
+    } else {
+      // Get the function we're calling
+      Value *V = getVal(PFTy, (yyvsp[-3].ValIDVal));
+
+      // Check the argument values match
+      if (!(yyvsp[-1].ValueList)) {                                   // Has no arguments?
+        // Make sure no arguments is a good thing!
+        if (FTy->getNumParams() != 0)
+          error("No arguments passed to a function that expects arguments");
+      } else {                                     // Has arguments?
+        // Loop through FunctionType's arguments and ensure they are specified
+        // correctly!
+        //
+        FunctionType::param_iterator I = FTy->param_begin();
+        FunctionType::param_iterator E = FTy->param_end();
+        std::vector::iterator ArgI = (yyvsp[-1].ValueList)->begin(), ArgE = (yyvsp[-1].ValueList)->end();
+
+        for (; ArgI != ArgE && I != E; ++ArgI, ++I)
+          if ((*ArgI).V->getType() != *I)
+            error("Parameter " +(*ArgI).V->getName()+ " is not of type '" +
+                  (*I)->getDescription() + "'");
+
+        if (I != E || (ArgI != ArgE && !FTy->isVarArg()))
+          error("Invalid number of parameters detected");
+      }
+
+      // Create the call instruction
+      CallInst *CI = new CallInst(V, Args);
+      CI->setTailCall((yyvsp[-6].BoolVal));
+      CI->setCallingConv((yyvsp[-5].UIntVal));
+      (yyval.InstVal).I = CI;
+      (yyval.InstVal).S = (yyvsp[-4].TypeVal).S;
+    }
+    delete (yyvsp[-4].TypeVal).T;
+    delete (yyvsp[-1].ValueList);
+  ;}
     break;
 
   case 296:
-#line 2175 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 3311 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    *yyvsp[-2].String += " " + yyvsp[-1].Ty->getNewTy();
-    if (!yyvsp[0].String->empty())
-      *yyvsp[-2].String += " " + *yyvsp[0].String;
-    yyval.Val = new Value;
-    yyval.Val->val = yyvsp[-2].String;
-    yyval.Val->type = yyvsp[-1].Ty->getPointerType();
-    delete yyvsp[0].String;
-  }
+    (yyval.InstVal) = (yyvsp[0].InstVal);
+  ;}
     break;
 
   case 297:
-#line 2184 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    {
-    std::string Name = getUniqueName(yyvsp[-1].Val->val, yyvsp[-2].Ty);
-    *yyvsp[-5].String += " " + yyvsp[-4].Ty->getNewTy() + ", " + yyvsp[-2].Ty->getNewTy() + " " + Name;
-    if (!yyvsp[0].String->empty())
-      *yyvsp[-5].String += " " + *yyvsp[0].String;
-    yyval.Val = yyvsp[-1].Val;
-    delete yyval.Val->val;
-    yyval.Val->val = yyvsp[-5].String;
-    yyval.Val->type = yyvsp[-4].Ty->getPointerType();
-    delete yyvsp[0].String;
-  }
+#line 3319 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.ValueList) = (yyvsp[0].ValueList); ;}
     break;
 
   case 298:
-#line 2195 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    {
-    *yyvsp[-1].String += " " + *yyvsp[0].Val->val;
-    yyval.Val = yyvsp[0].Val;
-    delete yyvsp[0].Val->val;
-    yyval.Val->val = yyvsp[-1].String;
-    yyval.Val->type = Type::get("void", VoidTy); 
-  }
+#line 3320 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.ValueList) = new std::vector(); ;}
     break;
 
   case 299:
-#line 2202 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    {
-    std::string Name = getUniqueName(yyvsp[0].Val->val, yyvsp[-1].Ty);
-    if (!yyvsp[-3].String->empty())
-      *yyvsp[-3].String += " ";
-    *yyvsp[-3].String += *yyvsp[-2].String + " " + yyvsp[-1].Ty->getNewTy() + " " + Name;
-    yyval.Val = yyvsp[0].Val;
-    delete yyval.Val->val;
-    yyval.Val->val = yyvsp[-3].String;
-    yyval.Val->type = yyvsp[-1].Ty->getElementType();
-    delete yyvsp[-2].String;
-  }
+#line 3324 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.BoolVal) = true; ;}
     break;
 
   case 300:
-#line 2213 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-    {
-    std::string Name = getUniqueName(yyvsp[0].Val->val, yyvsp[-1].Ty);
-    if (!yyvsp[-5].String->empty())
-      *yyvsp[-5].String += " ";
-    *yyvsp[-5].String += *yyvsp[-4].String + " " + *yyvsp[-3].Val->val + ", " + yyvsp[-1].Ty->getNewTy() + " " + Name;
-    yyval.Val = yyvsp[-3].Val;
-    delete yyval.Val->val;
-    yyval.Val->val = yyvsp[-5].String;
-    yyval.Val->type = Type::get("void", VoidTy);
-    delete yyvsp[-4].String; delete yyvsp[0].Val;
-  }
+#line 3325 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    { (yyval.BoolVal) = false; ;}
     break;
 
   case 301:
-#line 2224 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 3329 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
     {
-    std::string Name = getUniqueName(yyvsp[-1].Val->val, yyvsp[-2].Ty);
-    // Upgrade the indices
-    for (unsigned i = 0; i < yyvsp[0].ValList->size(); ++i) {
-      Value* V = (*yyvsp[0].ValList)[i];
-      if (V->type->isUnsigned() && !V->isConstant() && 
-          V->type->getBitWidth() < 64) {
-        *O << "    %gep_upgrade" << UniqueNameCounter << " = zext " << *V->val 
-           << " to i64\n";
-        *V->val = "i64 %gep_upgrade" + llvm::utostr(UniqueNameCounter++);
-        V->type = Type::get("i64",ULongTy);
-      }
-    }
-    *yyvsp[-3].String += " " + yyvsp[-2].Ty->getNewTy() + " " + Name;
-    for (unsigned i = 0; i < yyvsp[0].ValList->size(); ++i) {
-      Value* V = (*yyvsp[0].ValList)[i];
-      *yyvsp[-3].String += ", " + *V->val;
-    }
-    yyval.Val = yyvsp[-1].Val;
-    delete yyval.Val->val;
-    yyval.Val->val = yyvsp[-3].String;
-    yyval.Val->type = getGEPIndexedType(yyvsp[-2].Ty,yyvsp[0].ValList); 
-    for (unsigned i = 0; i < yyvsp[0].ValList->size(); ++i)
-      delete (*yyvsp[0].ValList)[i];
-    delete yyvsp[0].ValList;
-  }
+    const Type *Ty = (yyvsp[-1].TypeVal).T->get();
+    (yyval.InstVal).S = (yyvsp[-1].TypeVal).S;
+    (yyval.InstVal).I = new MallocInst(Ty, 0, (yyvsp[0].UIntVal));
+    delete (yyvsp[-1].TypeVal).T;
+  ;}
     break;
 
+  case 302:
+#line 3335 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {
+    const Type *Ty = (yyvsp[-4].TypeVal).T->get();
+    (yyval.InstVal).S = (yyvsp[-4].TypeVal).S;
+    (yyval.InstVal).I = new MallocInst(Ty, getVal((yyvsp[-2].PrimType).T, (yyvsp[-1].ValIDVal)), (yyvsp[0].UIntVal));
+    delete (yyvsp[-4].TypeVal).T;
+  ;}
+    break;
+
+  case 303:
+#line 3341 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {
+    const Type *Ty = (yyvsp[-1].TypeVal).T->get();
+    (yyval.InstVal).S = (yyvsp[-1].TypeVal).S;
+    (yyval.InstVal).I = new AllocaInst(Ty, 0, (yyvsp[0].UIntVal));
+    delete (yyvsp[-1].TypeVal).T;
+  ;}
+    break;
+
+  case 304:
+#line 3347 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {
+    const Type *Ty = (yyvsp[-4].TypeVal).T->get();
+    (yyval.InstVal).S = (yyvsp[-4].TypeVal).S;
+    (yyval.InstVal).I = new AllocaInst(Ty, getVal((yyvsp[-2].PrimType).T, (yyvsp[-1].ValIDVal)), (yyvsp[0].UIntVal));
+    delete (yyvsp[-4].TypeVal).T;
+  ;}
+    break;
+
+  case 305:
+#line 3353 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {
+    const Type *PTy = (yyvsp[0].ValueVal).V->getType();
+    if (!isa(PTy))
+      error("Trying to free nonpointer type '" + PTy->getDescription() + "'");
+    (yyval.InstVal).I = new FreeInst((yyvsp[0].ValueVal).V);
+    (yyval.InstVal).S = Signless;
+  ;}
+    break;
+
+  case 306:
+#line 3360 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {
+    const Type* Ty = (yyvsp[-1].TypeVal).T->get();
+    (yyval.InstVal).S = (yyvsp[-1].TypeVal).S;
+    if (!isa(Ty))
+      error("Can't load from nonpointer type: " + Ty->getDescription());
+    if (!cast(Ty)->getElementType()->isFirstClassType())
+      error("Can't load from pointer of non-first-class type: " +
+                     Ty->getDescription());
+    Value* tmpVal = getVal(Ty, (yyvsp[0].ValIDVal));
+    (yyval.InstVal).I = new LoadInst(tmpVal, "", (yyvsp[-3].BoolVal));
+    delete (yyvsp[-1].TypeVal).T;
+  ;}
+    break;
+
+  case 307:
+#line 3372 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {
+    const PointerType *PTy = dyn_cast((yyvsp[-1].TypeVal).T->get());
+    if (!PTy)
+      error("Can't store to a nonpointer type: " + 
+             (yyvsp[-1].TypeVal).T->get()->getDescription());
+    const Type *ElTy = PTy->getElementType();
+    if (ElTy != (yyvsp[-3].ValueVal).V->getType())
+      error("Can't store '" + (yyvsp[-3].ValueVal).V->getType()->getDescription() +
+            "' into space of type '" + ElTy->getDescription() + "'");
+    Value* tmpVal = getVal(PTy, (yyvsp[0].ValIDVal));
+    (yyval.InstVal).I = new StoreInst((yyvsp[-3].ValueVal).V, tmpVal, (yyvsp[-5].BoolVal));
+    (yyval.InstVal).S = Signless;
+    delete (yyvsp[-1].TypeVal).T;
+  ;}
+    break;
+
+  case 308:
+#line 3386 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+    {
+    const Type* Ty = (yyvsp[-2].TypeVal).T->get();
+    if (!isa(Ty))
+      error("getelementptr insn requires pointer operand");
+
+    std::vector VIndices;
+    upgradeGEPIndices(Ty, (yyvsp[0].ValueList), VIndices);
 
+    Value* tmpVal = getVal(Ty, (yyvsp[-1].ValIDVal));
+    (yyval.InstVal).I = new GetElementPtrInst(tmpVal, VIndices);
+    (yyval.InstVal).S = Signless;
+    delete (yyvsp[-2].TypeVal).T;
+    delete (yyvsp[0].ValueList);
+  ;}
+    break;
+
+
+      default: break;
     }
 
-/* Line 1016 of /usr/local/share/bison/yacc.c.  */
-#line 4580 "UpgradeParser.tab.c"
+/* Line 1126 of yacc.c.  */
+#line 6116 "UpgradeParser.tab.c"
 
   yyvsp -= yylen;
   yyssp -= yylen;
 
 
-#if YYDEBUG
-  if (yydebug)
-    {
-      short *yyssp1 = yyss - 1;
-      YYFPRINTF (stderr, "state stack now");
-      while (yyssp1 != yyssp)
-	YYFPRINTF (stderr, " %d", *++yyssp1);
-      YYFPRINTF (stderr, "\n");
-    }
-#endif
+  YY_STACK_PRINT (yyss, yyssp);
 
   *++yyvsp = yyval;
 
@@ -4624,90 +6151,153 @@
 
       if (YYPACT_NINF < yyn && yyn < YYLAST)
 	{
-	  YYSIZE_T yysize = 0;
 	  int yytype = YYTRANSLATE (yychar);
-	  char *yymsg;
-	  int yyx, yycount;
+	  YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
+	  YYSIZE_T yysize = yysize0;
+	  YYSIZE_T yysize1;
+	  int yysize_overflow = 0;
+	  char *yymsg = 0;
+#	  define YYERROR_VERBOSE_ARGS_MAXIMUM 5
+	  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
+	  int yyx;
+
+#if 0
+	  /* This is so xgettext sees the translatable formats that are
+	     constructed on the fly.  */
+	  YY_("syntax error, unexpected %s");
+	  YY_("syntax error, unexpected %s, expecting %s");
+	  YY_("syntax error, unexpected %s, expecting %s or %s");
+	  YY_("syntax error, unexpected %s, expecting %s or %s or %s");
+	  YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
+#endif
+	  char *yyfmt;
+	  char const *yyf;
+	  static char const yyunexpected[] = "syntax error, unexpected %s";
+	  static char const yyexpecting[] = ", expecting %s";
+	  static char const yyor[] = " or %s";
+	  char yyformat[sizeof yyunexpected
+			+ sizeof yyexpecting - 1
+			+ ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
+			   * (sizeof yyor - 1))];
+	  char const *yyprefix = yyexpecting;
 
-	  yycount = 0;
 	  /* Start YYX at -YYN if negative to avoid negative indexes in
 	     YYCHECK.  */
-	  for (yyx = yyn < 0 ? -yyn : 0;
-	       yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
+	  int yyxbegin = yyn < 0 ? -yyn : 0;
+
+	  /* Stay within bounds of both yycheck and yytname.  */
+	  int yychecklim = YYLAST - yyn;
+	  int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
+	  int yycount = 1;
+
+	  yyarg[0] = yytname[yytype];
+	  yyfmt = yystpcpy (yyformat, yyunexpected);
+
+	  for (yyx = yyxbegin; yyx < yyxend; ++yyx)
 	    if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
-	      yysize += yystrlen (yytname[yyx]) + 15, yycount++;
-	  yysize += yystrlen ("parse error, unexpected ") + 1;
-	  yysize += yystrlen (yytname[yytype]);
-	  yymsg = (char *) YYSTACK_ALLOC (yysize);
-	  if (yymsg != 0)
+	      {
+		if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
+		  {
+		    yycount = 1;
+		    yysize = yysize0;
+		    yyformat[sizeof yyunexpected - 1] = '\0';
+		    break;
+		  }
+		yyarg[yycount++] = yytname[yyx];
+		yysize1 = yysize + yytnamerr (0, yytname[yyx]);
+		yysize_overflow |= yysize1 < yysize;
+		yysize = yysize1;
+		yyfmt = yystpcpy (yyfmt, yyprefix);
+		yyprefix = yyor;
+	      }
+
+	  yyf = YY_(yyformat);
+	  yysize1 = yysize + yystrlen (yyf);
+	  yysize_overflow |= yysize1 < yysize;
+	  yysize = yysize1;
+
+	  if (!yysize_overflow && yysize <= YYSTACK_ALLOC_MAXIMUM)
+	    yymsg = (char *) YYSTACK_ALLOC (yysize);
+	  if (yymsg)
 	    {
-	      char *yyp = yystpcpy (yymsg, "parse error, unexpected ");
-	      yyp = yystpcpy (yyp, yytname[yytype]);
-
-	      if (yycount < 5)
+	      /* Avoid sprintf, as that infringes on the user's name space.
+		 Don't have undefined behavior even if the translation
+		 produced a string with the wrong number of "%s"s.  */
+	      char *yyp = yymsg;
+	      int yyi = 0;
+	      while ((*yyp = *yyf))
 		{
-		  yycount = 0;
-		  for (yyx = yyn < 0 ? -yyn : 0;
-		       yyx < (int) (sizeof (yytname) / sizeof (char *));
-		       yyx++)
-		    if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
-		      {
-			const char *yyq = ! yycount ? ", expecting " : " or ";
-			yyp = yystpcpy (yyp, yyq);
-			yyp = yystpcpy (yyp, yytname[yyx]);
-			yycount++;
-		      }
+		  if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
+		    {
+		      yyp += yytnamerr (yyp, yyarg[yyi++]);
+		      yyf += 2;
+		    }
+		  else
+		    {
+		      yyp++;
+		      yyf++;
+		    }
 		}
 	      yyerror (yymsg);
 	      YYSTACK_FREE (yymsg);
 	    }
 	  else
-	    yyerror ("parse error; also virtual memory exhausted");
+	    {
+	      yyerror (YY_("syntax error"));
+	      goto yyexhaustedlab;
+	    }
 	}
       else
 #endif /* YYERROR_VERBOSE */
-	yyerror ("parse error");
+	yyerror (YY_("syntax error"));
     }
-  goto yyerrlab1;
 
 
-/*----------------------------------------------------.
-| yyerrlab1 -- error raised explicitly by an action.  |
-`----------------------------------------------------*/
-yyerrlab1:
+
   if (yyerrstatus == 3)
     {
-      /* If just tried and failed to reuse lookahead token after an
+      /* If just tried and failed to reuse look-ahead token after an
 	 error, discard it.  */
 
-      /* Return failure if at end of input.  */
-      if (yychar == YYEOF)
+      if (yychar <= YYEOF)
         {
-	  /* Pop the error token.  */
-          YYPOPSTACK;
-	  /* Pop the rest of the stack.  */
-	  while (yyssp > yyss)
-	    {
-	      YYDPRINTF ((stderr, "Error: popping "));
-	      YYDSYMPRINT ((stderr,
-			    yystos[*yyssp],
-			    *yyvsp));
-	      YYDPRINTF ((stderr, "\n"));
-	      yydestruct (yystos[*yyssp], *yyvsp);
-	      YYPOPSTACK;
-	    }
-	  YYABORT;
+	  /* Return failure if at end of input.  */
+	  if (yychar == YYEOF)
+	    YYABORT;
         }
-
-      YYDPRINTF ((stderr, "Discarding token %d (%s).\n",
-		  yychar, yytname[yychar1]));
-      yydestruct (yychar1, yylval);
-      yychar = YYEMPTY;
+      else
+	{
+	  yydestruct ("Error: discarding", yytoken, &yylval);
+	  yychar = YYEMPTY;
+	}
     }
 
-  /* Else will try to reuse lookahead token after shifting the error
+  /* Else will try to reuse look-ahead token after shifting the error
      token.  */
+  goto yyerrlab1;
+
+
+/*---------------------------------------------------.
+| yyerrorlab -- error raised explicitly by YYERROR.  |
+`---------------------------------------------------*/
+yyerrorlab:
+
+  /* Pacify compilers like GCC when the user code never invokes
+     YYERROR and the label yyerrorlab therefore never appears in user
+     code.  */
+  if (0)
+     goto yyerrorlab;
+
+yyvsp -= yylen;
+  yyssp -= yylen;
+  yystate = *yyssp;
+  goto yyerrlab1;
+
 
+/*-------------------------------------------------------------.
+| yyerrlab1 -- common code for both syntax error and YYERROR.  |
+`-------------------------------------------------------------*/
+yyerrlab1:
   yyerrstatus = 3;	/* Each real token shifted decrements this.  */
 
   for (;;)
@@ -4728,36 +6318,22 @@
       if (yyssp == yyss)
 	YYABORT;
 
-      YYDPRINTF ((stderr, "Error: popping "));
-      YYDSYMPRINT ((stderr,
-		    yystos[*yyssp], *yyvsp));
-      YYDPRINTF ((stderr, "\n"));
-
-      yydestruct (yystos[yystate], *yyvsp);
-      yyvsp--;
-      yystate = *--yyssp;
-
 
-#if YYDEBUG
-      if (yydebug)
-	{
-	  short *yyssp1 = yyss - 1;
-	  YYFPRINTF (stderr, "Error: state stack now");
-	  while (yyssp1 != yyssp)
-	    YYFPRINTF (stderr, " %d", *++yyssp1);
-	  YYFPRINTF (stderr, "\n");
-	}
-#endif
+      yydestruct ("Error: popping", yystos[yystate], yyvsp);
+      YYPOPSTACK;
+      yystate = *yyssp;
+      YY_STACK_PRINT (yyss, yyssp);
     }
 
   if (yyn == YYFINAL)
     YYACCEPT;
 
-  YYDPRINTF ((stderr, "Shifting error token, "));
-
   *++yyvsp = yylval;
 
 
+  /* Shift the error token. */
+  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
+
   yystate = yyn;
   goto yynewstate;
 
@@ -4777,16 +6353,25 @@
   goto yyreturn;
 
 #ifndef yyoverflow
-/*----------------------------------------------.
-| yyoverflowlab -- parser overflow comes here.  |
-`----------------------------------------------*/
-yyoverflowlab:
-  yyerror ("parser stack overflow");
+/*-------------------------------------------------.
+| yyexhaustedlab -- memory exhaustion comes here.  |
+`-------------------------------------------------*/
+yyexhaustedlab:
+  yyerror (YY_("memory exhausted"));
   yyresult = 2;
   /* Fall through.  */
 #endif
 
 yyreturn:
+  if (yychar != YYEOF && yychar != YYEMPTY)
+     yydestruct ("Cleanup: discarding lookahead",
+		 yytoken, &yylval);
+  while (yyssp != yyss)
+    {
+      yydestruct ("Cleanup: popping",
+		  yystos[*yyssp], yyvsp);
+      YYPOPSTACK;
+    }
 #ifndef yyoverflow
   if (yyss != yyssa)
     YYSTACK_FREE (yyss);
@@ -4795,34 +6380,37 @@
 }
 
 
-#line 2251 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
+#line 3402 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
 
 
 int yyerror(const char *ErrorMsg) {
   std::string where 
     = std::string((CurFilename == "-") ? std::string("") : CurFilename)
-                  + ":" + llvm::utostr((unsigned) Upgradelineno) + ": ";
-  std::string errMsg = where + "error: " + std::string(ErrorMsg) + 
-                       " while reading ";
-  if (yychar == YYEMPTY || yychar == 0)
-    errMsg += "end-of-file.";
-  else
-    errMsg += "token: '" + std::string(Upgradetext, Upgradeleng) + "'";
+                  + ":" + llvm::utostr((unsigned) Upgradelineno-1) + ": ";
+  std::string errMsg = where + "error: " + std::string(ErrorMsg);
+  if (yychar != YYEMPTY && yychar != 0)
+    errMsg += " while reading token '" + std::string(Upgradetext, Upgradeleng) +
+              "'.";
   std::cerr << "llvm-upgrade: " << errMsg << '\n';
-  *O << "llvm-upgrade parse failed.\n";
+  std::cout << "llvm-upgrade: parse failed.\n";
   exit(1);
 }
 
 void warning(const std::string& ErrorMsg) {
   std::string where 
     = std::string((CurFilename == "-") ? std::string("") : CurFilename)
-                  + ":" + llvm::utostr((unsigned) Upgradelineno) + ": ";
-  std::string errMsg = where + "warning: " + std::string(ErrorMsg) + 
-                       " while reading ";
-  if (yychar == YYEMPTY || yychar == 0)
-    errMsg += "end-of-file.";
-  else
-    errMsg += "token: '" + std::string(Upgradetext, Upgradeleng) + "'";
+                  + ":" + llvm::utostr((unsigned) Upgradelineno-1) + ": ";
+  std::string errMsg = where + "warning: " + std::string(ErrorMsg);
+  if (yychar != YYEMPTY && yychar != 0)
+    errMsg += " while reading token '" + std::string(Upgradetext, Upgradeleng) +
+              "'.";
   std::cerr << "llvm-upgrade: " << errMsg << '\n';
 }
 
+void error(const std::string& ErrorMsg, int LineNo) {
+  if (LineNo == -1) LineNo = Upgradelineno;
+  Upgradelineno = LineNo;
+  yyerror(ErrorMsg.c_str());
+}
+
+


Index: llvm/tools/llvm-upgrade/UpgradeParser.h.cvs
diff -u llvm/tools/llvm-upgrade/UpgradeParser.h.cvs:1.31 llvm/tools/llvm-upgrade/UpgradeParser.h.cvs:1.32
--- llvm/tools/llvm-upgrade/UpgradeParser.h.cvs:1.31	Sun Jan 21 13:30:52 2007
+++ llvm/tools/llvm-upgrade/UpgradeParser.h.cvs	Fri Jan 26 02:19:09 2007
@@ -1,7 +1,7 @@
-/* A Bison parser, made from /usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y, by GNU bison 1.75.  */
+/* A Bison parser, made by GNU Bison 2.1.  */
 
 /* Skeleton parser for Yacc-like parsing with Bison,
-   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software Foundation, Inc.
+   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -15,78 +15,75 @@
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
+   Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.  */
 
 /* As a special exception, when this file is copied by Bison into a
    Bison output file, you may use that output file without restriction.
    This special exception was added by the Free Software Foundation
    in version 1.24 of Bison.  */
 
-#ifndef BISON_UPGRADEPARSER_TAB_H
-# define BISON_UPGRADEPARSER_TAB_H
-
 /* Tokens.  */
 #ifndef YYTOKENTYPE
 # define YYTOKENTYPE
    /* Put the tokens into the symbol table, so that GDB and other debuggers
       know about them.  */
    enum yytokentype {
-     VOID = 258,
-     BOOL = 259,
-     SBYTE = 260,
-     UBYTE = 261,
-     SHORT = 262,
-     USHORT = 263,
-     INT = 264,
-     UINT = 265,
-     LONG = 266,
-     ULONG = 267,
-     FLOAT = 268,
-     DOUBLE = 269,
-     LABEL = 270,
-     OPAQUE = 271,
-     ESINT64VAL = 272,
-     EUINT64VAL = 273,
-     SINTVAL = 274,
-     UINTVAL = 275,
-     FPVAL = 276,
-     NULL_TOK = 277,
-     UNDEF = 278,
-     ZEROINITIALIZER = 279,
-     TRUETOK = 280,
-     FALSETOK = 281,
-     TYPE = 282,
-     VAR_ID = 283,
-     LABELSTR = 284,
-     STRINGCONSTANT = 285,
-     IMPLEMENTATION = 286,
-     BEGINTOK = 287,
-     ENDTOK = 288,
-     DECLARE = 289,
-     GLOBAL = 290,
-     CONSTANT = 291,
-     SECTION = 292,
-     VOLATILE = 293,
-     TO = 294,
-     DOTDOTDOT = 295,
-     CONST = 296,
-     INTERNAL = 297,
-     LINKONCE = 298,
-     WEAK = 299,
+     ESINT64VAL = 258,
+     EUINT64VAL = 259,
+     SINTVAL = 260,
+     UINTVAL = 261,
+     FPVAL = 262,
+     VOID = 263,
+     BOOL = 264,
+     SBYTE = 265,
+     UBYTE = 266,
+     SHORT = 267,
+     USHORT = 268,
+     INT = 269,
+     UINT = 270,
+     LONG = 271,
+     ULONG = 272,
+     FLOAT = 273,
+     DOUBLE = 274,
+     TYPE = 275,
+     LABEL = 276,
+     VAR_ID = 277,
+     LABELSTR = 278,
+     STRINGCONSTANT = 279,
+     IMPLEMENTATION = 280,
+     ZEROINITIALIZER = 281,
+     TRUETOK = 282,
+     FALSETOK = 283,
+     BEGINTOK = 284,
+     ENDTOK = 285,
+     DECLARE = 286,
+     GLOBAL = 287,
+     CONSTANT = 288,
+     SECTION = 289,
+     VOLATILE = 290,
+     TO = 291,
+     DOTDOTDOT = 292,
+     NULL_TOK = 293,
+     UNDEF = 294,
+     CONST = 295,
+     INTERNAL = 296,
+     LINKONCE = 297,
+     WEAK = 298,
+     APPENDING = 299,
      DLLIMPORT = 300,
      DLLEXPORT = 301,
      EXTERN_WEAK = 302,
-     APPENDING = 303,
-     EXTERNAL = 304,
-     TARGET = 305,
-     TRIPLE = 306,
-     ENDIAN = 307,
-     POINTERSIZE = 308,
-     LITTLE = 309,
-     BIG = 310,
-     ALIGN = 311,
-     UNINITIALIZED = 312,
+     OPAQUE = 303,
+     NOT = 304,
+     EXTERNAL = 305,
+     TARGET = 306,
+     TRIPLE = 307,
+     ENDIAN = 308,
+     POINTERSIZE = 309,
+     LITTLE = 310,
+     BIG = 311,
+     ALIGN = 312,
      DEPLIBS = 313,
      CALL = 314,
      TAIL = 315,
@@ -105,9 +102,9 @@
      BR = 328,
      SWITCH = 329,
      INVOKE = 330,
-     EXCEPT = 331,
+     UNREACHABLE = 331,
      UNWIND = 332,
-     UNREACHABLE = 333,
+     EXCEPT = 333,
      ADD = 334,
      SUB = 335,
      MUL = 336,
@@ -130,112 +127,115 @@
      SETNE = 353,
      ICMP = 354,
      FCMP = 355,
-     EQ = 356,
-     NE = 357,
-     SLT = 358,
-     SGT = 359,
-     SLE = 360,
-     SGE = 361,
-     OEQ = 362,
-     ONE = 363,
-     OLT = 364,
-     OGT = 365,
-     OLE = 366,
-     OGE = 367,
-     ORD = 368,
-     UNO = 369,
-     UEQ = 370,
-     UNE = 371,
-     ULT = 372,
-     UGT = 373,
-     ULE = 374,
-     UGE = 375,
-     MALLOC = 376,
-     ALLOCA = 377,
-     FREE = 378,
-     LOAD = 379,
-     STORE = 380,
-     GETELEMENTPTR = 381,
-     PHI_TOK = 382,
-     SELECT = 383,
-     SHL = 384,
-     SHR = 385,
-     ASHR = 386,
-     LSHR = 387,
-     VAARG = 388,
-     EXTRACTELEMENT = 389,
-     INSERTELEMENT = 390,
-     SHUFFLEVECTOR = 391,
-     CAST = 392,
-     TRUNC = 393,
-     ZEXT = 394,
-     SEXT = 395,
-     FPTRUNC = 396,
-     FPEXT = 397,
-     FPTOUI = 398,
-     FPTOSI = 399,
-     UITOFP = 400,
-     SITOFP = 401,
-     PTRTOINT = 402,
-     INTTOPTR = 403,
-     BITCAST = 404
+     MALLOC = 356,
+     ALLOCA = 357,
+     FREE = 358,
+     LOAD = 359,
+     STORE = 360,
+     GETELEMENTPTR = 361,
+     PHI_TOK = 362,
+     SELECT = 363,
+     SHL = 364,
+     SHR = 365,
+     ASHR = 366,
+     LSHR = 367,
+     VAARG = 368,
+     EXTRACTELEMENT = 369,
+     INSERTELEMENT = 370,
+     SHUFFLEVECTOR = 371,
+     VAARG_old = 372,
+     VANEXT_old = 373,
+     EQ = 374,
+     NE = 375,
+     SLT = 376,
+     SGT = 377,
+     SLE = 378,
+     SGE = 379,
+     ULT = 380,
+     UGT = 381,
+     ULE = 382,
+     UGE = 383,
+     OEQ = 384,
+     ONE = 385,
+     OLT = 386,
+     OGT = 387,
+     OLE = 388,
+     OGE = 389,
+     ORD = 390,
+     UNO = 391,
+     UEQ = 392,
+     UNE = 393,
+     CAST = 394,
+     TRUNC = 395,
+     ZEXT = 396,
+     SEXT = 397,
+     FPTRUNC = 398,
+     FPEXT = 399,
+     FPTOUI = 400,
+     FPTOSI = 401,
+     UITOFP = 402,
+     SITOFP = 403,
+     PTRTOINT = 404,
+     INTTOPTR = 405,
+     BITCAST = 406
    };
 #endif
-#define VOID 258
-#define BOOL 259
-#define SBYTE 260
-#define UBYTE 261
-#define SHORT 262
-#define USHORT 263
-#define INT 264
-#define UINT 265
-#define LONG 266
-#define ULONG 267
-#define FLOAT 268
-#define DOUBLE 269
-#define LABEL 270
-#define OPAQUE 271
-#define ESINT64VAL 272
-#define EUINT64VAL 273
-#define SINTVAL 274
-#define UINTVAL 275
-#define FPVAL 276
-#define NULL_TOK 277
-#define UNDEF 278
-#define ZEROINITIALIZER 279
-#define TRUETOK 280
-#define FALSETOK 281
-#define TYPE 282
-#define VAR_ID 283
-#define LABELSTR 284
-#define STRINGCONSTANT 285
-#define IMPLEMENTATION 286
-#define BEGINTOK 287
-#define ENDTOK 288
-#define DECLARE 289
-#define GLOBAL 290
-#define CONSTANT 291
-#define SECTION 292
-#define VOLATILE 293
-#define TO 294
-#define DOTDOTDOT 295
-#define CONST 296
-#define INTERNAL 297
-#define LINKONCE 298
-#define WEAK 299
+/* Tokens.  */
+#define ESINT64VAL 258
+#define EUINT64VAL 259
+#define SINTVAL 260
+#define UINTVAL 261
+#define FPVAL 262
+#define VOID 263
+#define BOOL 264
+#define SBYTE 265
+#define UBYTE 266
+#define SHORT 267
+#define USHORT 268
+#define INT 269
+#define UINT 270
+#define LONG 271
+#define ULONG 272
+#define FLOAT 273
+#define DOUBLE 274
+#define TYPE 275
+#define LABEL 276
+#define VAR_ID 277
+#define LABELSTR 278
+#define STRINGCONSTANT 279
+#define IMPLEMENTATION 280
+#define ZEROINITIALIZER 281
+#define TRUETOK 282
+#define FALSETOK 283
+#define BEGINTOK 284
+#define ENDTOK 285
+#define DECLARE 286
+#define GLOBAL 287
+#define CONSTANT 288
+#define SECTION 289
+#define VOLATILE 290
+#define TO 291
+#define DOTDOTDOT 292
+#define NULL_TOK 293
+#define UNDEF 294
+#define CONST 295
+#define INTERNAL 296
+#define LINKONCE 297
+#define WEAK 298
+#define APPENDING 299
 #define DLLIMPORT 300
 #define DLLEXPORT 301
 #define EXTERN_WEAK 302
-#define APPENDING 303
-#define EXTERNAL 304
-#define TARGET 305
-#define TRIPLE 306
-#define ENDIAN 307
-#define POINTERSIZE 308
-#define LITTLE 309
-#define BIG 310
-#define ALIGN 311
-#define UNINITIALIZED 312
+#define OPAQUE 303
+#define NOT 304
+#define EXTERNAL 305
+#define TARGET 306
+#define TRIPLE 307
+#define ENDIAN 308
+#define POINTERSIZE 309
+#define LITTLE 310
+#define BIG 311
+#define ALIGN 312
 #define DEPLIBS 313
 #define CALL 314
 #define TAIL 315
@@ -254,9 +254,9 @@
 #define BR 328
 #define SWITCH 329
 #define INVOKE 330
-#define EXCEPT 331
+#define UNREACHABLE 331
 #define UNWIND 332
-#define UNREACHABLE 333
+#define EXCEPT 333
 #define ADD 334
 #define SUB 335
 #define MUL 336
@@ -279,76 +279,112 @@
 #define SETNE 353
 #define ICMP 354
 #define FCMP 355
-#define EQ 356
-#define NE 357
-#define SLT 358
-#define SGT 359
-#define SLE 360
-#define SGE 361
-#define OEQ 362
-#define ONE 363
-#define OLT 364
-#define OGT 365
-#define OLE 366
-#define OGE 367
-#define ORD 368
-#define UNO 369
-#define UEQ 370
-#define UNE 371
-#define ULT 372
-#define UGT 373
-#define ULE 374
-#define UGE 375
-#define MALLOC 376
-#define ALLOCA 377
-#define FREE 378
-#define LOAD 379
-#define STORE 380
-#define GETELEMENTPTR 381
-#define PHI_TOK 382
-#define SELECT 383
-#define SHL 384
-#define SHR 385
-#define ASHR 386
-#define LSHR 387
-#define VAARG 388
-#define EXTRACTELEMENT 389
-#define INSERTELEMENT 390
-#define SHUFFLEVECTOR 391
-#define CAST 392
-#define TRUNC 393
-#define ZEXT 394
-#define SEXT 395
-#define FPTRUNC 396
-#define FPEXT 397
-#define FPTOUI 398
-#define FPTOSI 399
-#define UITOFP 400
-#define SITOFP 401
-#define PTRTOINT 402
-#define INTTOPTR 403
-#define BITCAST 404
-
-
-
-
-#ifndef YYSTYPE
-#line 971 "/usr/home/jeffc/llvm/tools/llvm-upgrade/UpgradeParser.y"
-typedef union {
-  std::string*    String;
-  const Type*     Ty;
-  Value*          Val;
-  Constant*       Const;
-  ValueList*      ValList;
-  TypeList*       TypeVec;
-} yystype;
-/* Line 1237 of /usr/local/share/bison/yacc.c.  */
-#line 347 "UpgradeParser.tab.h"
-# define YYSTYPE yystype
+#define MALLOC 356
+#define ALLOCA 357
+#define FREE 358
+#define LOAD 359
+#define STORE 360
+#define GETELEMENTPTR 361
+#define PHI_TOK 362
+#define SELECT 363
+#define SHL 364
+#define SHR 365
+#define ASHR 366
+#define LSHR 367
+#define VAARG 368
+#define EXTRACTELEMENT 369
+#define INSERTELEMENT 370
+#define SHUFFLEVECTOR 371
+#define VAARG_old 372
+#define VANEXT_old 373
+#define EQ 374
+#define NE 375
+#define SLT 376
+#define SGT 377
+#define SLE 378
+#define SGE 379
+#define ULT 380
+#define UGT 381
+#define ULE 382
+#define UGE 383
+#define OEQ 384
+#define ONE 385
+#define OLT 386
+#define OGT 387
+#define OLE 388
+#define OGE 389
+#define ORD 390
+#define UNO 391
+#define UEQ 392
+#define UNE 393
+#define CAST 394
+#define TRUNC 395
+#define ZEXT 396
+#define SEXT 397
+#define FPTRUNC 398
+#define FPEXT 399
+#define FPTOUI 400
+#define FPTOSI 401
+#define UITOFP 402
+#define SITOFP 403
+#define PTRTOINT 404
+#define INTTOPTR 405
+#define BITCAST 406
+
+
+
+
+#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
+#line 1469 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+typedef union YYSTYPE {
+  llvm::Module                           *ModuleVal;
+  llvm::Function                         *FunctionVal;
+  std::pair     *ArgVal;
+  llvm::BasicBlock                       *BasicBlockVal;
+  llvm::TerminatorInst                   *TermInstVal;
+  llvm::InstrInfo                        InstVal;
+  llvm::ConstInfo                        ConstVal;
+  llvm::ValueInfo                        ValueVal;
+  llvm::PATypeInfo                       TypeVal;
+  llvm::TypeInfo                         PrimType;
+  llvm::PHIListInfo                      PHIList;
+  std::list            *TypeList;
+  std::vector           *ValueList;
+  std::vector           *ConstVector;
+
+
+  std::vector > *ArgList;
+  // Represent the RHS of PHI node
+  std::vector > *JumpTable;
+
+  llvm::GlobalValue::LinkageTypes         Linkage;
+  int64_t                           SInt64Val;
+  uint64_t                          UInt64Val;
+  int                               SIntVal;
+  unsigned                          UIntVal;
+  double                            FPVal;
+  bool                              BoolVal;
+
+  char                             *StrVal;   // This memory is strdup'd!
+  llvm::ValID                       ValIDVal; // strdup'd memory maybe!
+
+  llvm::BinaryOps                   BinaryOpVal;
+  llvm::TermOps                     TermOpVal;
+  llvm::MemoryOps                   MemOpVal;
+  llvm::OtherOps                    OtherOpVal;
+  llvm::CastOps                     CastOpVal;
+  llvm::ICmpInst::Predicate         IPred;
+  llvm::FCmpInst::Predicate         FPred;
+  llvm::Module::Endianness          Endianness;
+} YYSTYPE;
+/* Line 1447 of yacc.c.  */
+#line 382 "UpgradeParser.tab.h"
+# define yystype YYSTYPE /* obsolescent; will be withdrawn */
+# define YYSTYPE_IS_DECLARED 1
+# define YYSTYPE_IS_TRIVIAL 1
 #endif
 
 extern YYSTYPE Upgradelval;
 
 
-#endif /* not BISON_UPGRADEPARSER_TAB_H */
 


Index: llvm/tools/llvm-upgrade/UpgradeParser.y.cvs
diff -u llvm/tools/llvm-upgrade/UpgradeParser.y.cvs:1.43 llvm/tools/llvm-upgrade/UpgradeParser.y.cvs:1.44
--- llvm/tools/llvm-upgrade/UpgradeParser.y.cvs:1.43	Sun Jan 21 13:30:52 2007
+++ llvm/tools/llvm-upgrade/UpgradeParser.y.cvs	Fri Jan 26 02:19:09 2007
@@ -1,1127 +1,1775 @@
-//===-- UpgradeParser.y - Upgrade parser for llvm assmbly -------*- C++ -*-===//
+//===-- llvmAsmParser.y - Parser for llvm assembly files --------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file was developed by Reid Spencer and is distributed under the
-// University of Illinois Open Source License. See LICENSE.TXT for details.
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
-//  This file implements the bison parser for LLVM 1.9 assembly language.
+//  This file implements the bison parser for LLVM assembly languages files.
 //
 //===----------------------------------------------------------------------===//
 
 %{
 #include "UpgradeInternals.h"
+#include "llvm/CallingConv.h"
+#include "llvm/InlineAsm.h"
+#include "llvm/Instructions.h"
+#include "llvm/Module.h"
+#include "llvm/SymbolTable.h"
+#include "llvm/Support/GetElementPtrTypeIterator.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/Support/MathExtras.h"
 #include 
-#include 
-#include 
 #include 
+#include 
+#include 
+
+// DEBUG_UPREFS - Define this symbol if you want to enable debugging output
+// relating to upreferences in the input stream.
+//
+//#define DEBUG_UPREFS 1
+#ifdef DEBUG_UPREFS
+#define UR_OUT(X) std::cerr << X
+#else
+#define UR_OUT(X)
+#endif
 
 #define YYERROR_VERBOSE 1
 #define YYINCLUDED_STDLIB_H
 #define YYDEBUG 1
 
-int yylex();                       // declaration" of xxx warnings.
+int yylex();
 int yyparse();
-extern int yydebug;
 
-static std::string CurFilename;
-static std::ostream *O = 0;
-std::istream* LexInput = 0;
-unsigned SizeOfPointer = 32;
+int yyerror(const char*);
+static void warning(const std::string& WarningMsg);
 
+namespace llvm {
 
-// This bool controls whether attributes are ever added to function declarations
-// definitions and calls.
-static bool AddAttributes = false;
 
-static void warning(const std::string& msg);
+SignedType *SignedType::SByteTy = 0;
+SignedType *SignedType::SShortTy = 0;
+SignedType *SignedType::SIntTy = 0;
+SignedType *SignedType::SLongTy = 0;
+
+inline bool SignedType::classof(const Type *T) {
+  if (T->getTypeID() != IntegerTyID)
+    return false;
+  return (T == SByteTy || T == SShortTy || T == SIntTy || T == SLongTy );
+}
 
-void UpgradeAssembly(const std::string &infile, std::istream& in, 
-                     std::ostream &out, bool debug, bool addAttrs)
+SignedType::SignedType(const IntegerType* ITy) 
+  : IntegerType(ITy->getBitWidth()), base_type(ITy)
 {
-  Upgradelineno = 1; 
-  CurFilename = infile;
-  LexInput = ∈
-  yydebug = debug;
-  AddAttributes = addAttrs;
-  O = &out;
+}
 
-  if (yyparse()) {
-    std::cerr << "llvm-upgrade: parse failed.\n";
-    out << "llvm-upgrade: parse failed.\n";
-    exit(1);
+const SignedType *SignedType::get(const IntegerType* ITy) {
+  if (ITy == Type::Int8Ty) {
+    if (!SByteTy)
+      SByteTy = new SignedType(IntegerType::get(8));
+    return SByteTy;
+  } else if (ITy == Type::Int16Ty) {
+    if (!SShortTy)
+      SShortTy = new SignedType(IntegerType::get(16));
+    return SShortTy;
+  } else if (ITy == Type::Int32Ty) {
+    if (!SIntTy)
+      SIntTy = new SignedType(IntegerType::get(32));
+    return SIntTy;
+  } else if (ITy == Type::Int64Ty) {
+    if (!SLongTy)
+      SLongTy = new SignedType(IntegerType::get(64));
+    return SLongTy;
+  } else
+    assert(0 && "Invalid integer type for SignedType::get");
+}
+
+static inline Signedness getSign(const Type *&Ty) {
+  if (const SignedType *STy = dyn_cast(Ty)) {
+    Ty = STy->getBaseType();
+    return Signed;
+  } else if (isa(Ty))
+    return Unsigned;
+  return Signless;
+}
+
+static const Type*
+resolveTypeImpl(const Type* Ty, std::vector& TyStack)
+{
+  // Nothing to resolve if it isn't a derived type
+  if (!Ty->isDerivedType())
+    return Ty;
+
+  // Prevent infinite recursion for recursive types
+  for (std::vector::const_iterator I = TyStack.begin(), 
+       E = TyStack.end(); I != E; ++I)
+    if (Ty == *I)
+      return Ty;
+
+  // Okay, haven't seen this derived type yet, push it on the stack.
+  const Type* Result = Ty;
+  TyStack.push_back(Ty);
+
+  // Process the type
+  switch (Ty->getTypeID()) {
+    default: assert(0 && "Invalid derived type");
+    case Type::IntegerTyID:
+      break;
+    case Type::FunctionTyID: {
+      const FunctionType* FTy = cast(Ty);
+      const Type* RetTy = resolveTypeImpl(FTy->getReturnType(), TyStack);
+      std::vector Types;
+      FunctionType::ParamAttrsList Attrs;
+      Attrs.push_back(FTy->getParamAttrs(0));
+      for (unsigned i = 0; i < FTy->getNumParams(); ++i) {
+        Types.push_back(resolveTypeImpl(FTy->getParamType(i), TyStack));
+        Attrs.push_back(FTy->getParamAttrs(i+1));
+      }
+      Result = FunctionType::get(RetTy, Types, FTy->isVarArg(), Attrs);
+      break;
+    }
+    case Type::StructTyID:
+    case Type::PackedStructTyID: {
+      const StructType *STy = cast(Ty);
+      std::vector FieldTypes;
+      for (unsigned i = 0; i < STy->getNumElements(); ++i)
+        FieldTypes.push_back(resolveTypeImpl(STy->getElementType(i), TyStack));
+      Result = StructType::get(FieldTypes, STy->isPacked());
+      break;
+    }
+    case Type::ArrayTyID: {
+      const ArrayType *ATy = cast(Ty);
+      uint64_t NElems = ATy->getNumElements();
+      const Type *ElemTy = resolveTypeImpl(ATy->getElementType(), TyStack);
+      Result = ArrayType::get(ElemTy, NElems);
+      break;
+    }
+    case Type::PointerTyID: {
+      const PointerType *PTy = cast(Ty);
+      const Type *ElemTy = resolveTypeImpl(PTy->getElementType(), TyStack);
+      Result = PointerType::get(ElemTy);
+      break;
+    }
+    case Type::PackedTyID: {
+      const PackedType *PTy = cast(Ty);
+      unsigned NElems = PTy->getNumElements();
+      const Type *ElemTy = resolveTypeImpl(PTy->getElementType(), TyStack);
+      Result = PackedType::get(ElemTy, NElems);
+      break;
+    }
   }
+  // Done with it, pop it off.
+  TyStack.pop_back();
+  return Result;
 }
 
-namespace { // Anonymous namespace to keep our implementation local
+static inline const Type* resolveType(const Type* Ty) {
+  if (!Ty)
+    return 0;
+  if (const SignedType* STy = dyn_cast(Ty))
+    return STy->getBaseType();
+  std::vector TyStack;
+  return resolveTypeImpl(Ty, TyStack);
+}
 
+std::istream* LexInput;
+static std::string CurFilename;
 
-/// This type is used to keep track of the signedness of values. Instead
-/// of creating llvm::Value directly, the parser will create Value which
-/// associates a Value* with a Signedness indication.
-struct Value {
-  std::string* val;
-  const Type* type;
-  bool constant;
-  bool isConstant() const { return constant; }
-  ~Value() { delete val; }
-};
+// This bool controls whether attributes are ever added to function declarations
+// definitions and calls.
+static bool AddAttributes = false;
 
+static Module *ParserResult;
+static bool ObsoleteVarArgs;
+static bool NewVarArgs;
+static BasicBlock *CurBB;
+static GlobalVariable *CurGV;
 
-/// This type is used to keep track of the signedness of the obsolete
-/// integer types. Instead of creating an llvm::Type directly, the Lexer will
-/// create instances of Type which retains the signedness indication so
-/// it can be used by the parser for upgrade decisions.
-/// For example if "uint" is encountered then the "first" field will be set 
-/// to "int32" and the "second" field will be set to "isUnsigned".  If the 
-/// type is not obsolete then "second" will be set to "isSignless".
-class Type {
-public:
-  static const Type* get(const std::string &newType, TypeIDs oldType);
-  static const Type* get(const std::string& newType, TypeIDs oldType, 
-                             const Type* eTy, const Type* rTy);
 
-  static const Type* get(const std::string& newType, TypeIDs oldType, 
-                             const Type *eTy, uint64_t elems);
 
-  static const Type* get(const std::string& newType, TypeIDs oldType, 
-                             TypeList* TL);
+// This contains info used when building the body of a function.  It is
+// destroyed when the function is completed.
+//
+typedef std::vector ValueList;           // Numbered defs
 
-  static const Type* get(const std::string& newType, const Type* resTy, 
-                             TypeList* TL);
+typedef std::pair RenameMapKey;
+typedef std::map RenameMapType;
 
-  const Type* resolve() const;
-  bool operator<(const Type& that) const;
+static void 
+ResolveDefinitions(std::map &LateResolvers,
+                   std::map *FutureLateResolvers = 0);
+
+static struct PerModuleInfo {
+  Module *CurrentModule;
+  std::map Values; // Module level numbered definitions
+  std::map LateResolveValues;
+  std::vector    Types;
+  std::map LateResolveTypes;
+  static Module::Endianness Endian;
+  static Module::PointerSize PointerSize;
+  RenameMapType RenameMap;
+
+  /// PlaceHolderInfo - When temporary placeholder objects are created, remember
+  /// how they were referenced and on which line of the input they came from so
+  /// that we can resolve them later and print error messages as appropriate.
+  std::map > PlaceHolderInfo;
+
+  // GlobalRefs - This maintains a mapping between 's and forward
+  // references to global values.  Global values may be referenced before they
+  // are defined, and if so, the temporary object that they represent is held
+  // here.  This is used for forward references of GlobalValues.
+  //
+  typedef std::map, GlobalValue*> 
+    GlobalRefsType;
+  GlobalRefsType GlobalRefs;
+
+  void ModuleDone() {
+    // If we could not resolve some functions at function compilation time
+    // (calls to functions before they are defined), resolve them now...  Types
+    // are resolved when the constant pool has been completely parsed.
+    //
+    ResolveDefinitions(LateResolveValues);
+
+    // Check to make sure that all global value forward references have been
+    // resolved!
+    //
+    if (!GlobalRefs.empty()) {
+      std::string UndefinedReferences = "Unresolved global references exist:\n";
+
+      for (GlobalRefsType::iterator I = GlobalRefs.begin(), E =GlobalRefs.end();
+           I != E; ++I) {
+        UndefinedReferences += "  " + I->first.first->getDescription() + " " +
+                               I->first.second.getName() + "\n";
+      }
+      error(UndefinedReferences);
+      return;
+    }
 
-  bool sameNewTyAs(const Type* that) const {
-    return this->newTy == that->newTy;
-  }
+    if (CurrentModule->getDataLayout().empty()) {
+      std::string dataLayout;
+      if (Endian != Module::AnyEndianness)
+        dataLayout.append(Endian == Module::BigEndian ? "E" : "e");
+      if (PointerSize != Module::AnyPointerSize) {
+        if (!dataLayout.empty())
+          dataLayout += "-";
+        dataLayout.append(PointerSize == Module::Pointer64 ? 
+                          "p:64:64" : "p:32:32");
+      }
+      CurrentModule->setDataLayout(dataLayout);
+    }
 
-  bool sameOldTyAs(const Type* that) const;
+    Values.clear();         // Clear out function local definitions
+    Types.clear();
+    CurrentModule = 0;
+  }
+
+  // GetForwardRefForGlobal - Check to see if there is a forward reference
+  // for this global.  If so, remove it from the GlobalRefs map and return it.
+  // If not, just return null.
+  GlobalValue *GetForwardRefForGlobal(const PointerType *PTy, ValID ID) {
+    // Check to see if there is a forward reference to this global variable...
+    // if there is, eliminate it and patch the reference to use the new def'n.
+    GlobalRefsType::iterator I = GlobalRefs.find(std::make_pair(PTy, ID));
+    GlobalValue *Ret = 0;
+    if (I != GlobalRefs.end()) {
+      Ret = I->second;
+      GlobalRefs.erase(I);
+    }
+    return Ret;
+  }
+  void setEndianness(Module::Endianness E) { Endian = E; }
+  void setPointerSize(Module::PointerSize sz) { PointerSize = sz; }
+} CurModule;
+
+Module::Endianness  PerModuleInfo::Endian = Module::AnyEndianness;
+Module::PointerSize PerModuleInfo::PointerSize = Module::AnyPointerSize;
+
+static struct PerFunctionInfo {
+  Function *CurrentFunction;     // Pointer to current function being created
+
+  std::map Values; // Keep track of #'d definitions
+  std::map LateResolveValues;
+  bool isDeclare;                   // Is this function a forward declararation?
+  GlobalValue::LinkageTypes Linkage;// Linkage for forward declaration.
+
+  /// BBForwardRefs - When we see forward references to basic blocks, keep
+  /// track of them here.
+  std::map > BBForwardRefs;
+  std::vector NumberedBlocks;
+  RenameMapType RenameMap;
+  std::set SignedValues;
+  unsigned NextBBNum;
 
-  TypeIDs getElementTy() const {
-    if (elemTy) {
-      return elemTy->oldTy;
-    }
-    return UnresolvedTy;
+  inline PerFunctionInfo() {
+    CurrentFunction = 0;
+    isDeclare = false;
+    Linkage = GlobalValue::ExternalLinkage;    
   }
 
-  unsigned getUpRefNum() const {
-    assert(oldTy == UpRefTy && "Can't getUpRefNum on non upreference");
-    return atoi(&((getNewTy().c_str())[1])); // skip the slash
+  inline void FunctionStart(Function *M) {
+    CurrentFunction = M;
+    NextBBNum = 0;
   }
 
-  typedef std::vector UpRefStack;
-  void getSignedness(unsigned &sNum, unsigned &uNum, UpRefStack& stk) const;
-  std::string makeUniqueName(const std::string& BaseName) const;
+  void FunctionDone() {
+    NumberedBlocks.clear();
 
-  const std::string& getNewTy() const { return newTy; }
-  const Type* getResultType() const { return resultTy; }
-  const Type* getElementType() const { return elemTy; }
+    // Any forward referenced blocks left?
+    if (!BBForwardRefs.empty()) {
+      error("Undefined reference to label " + 
+            BBForwardRefs.begin()->first->getName());
+      return;
+    }
 
-  const Type* getPointerType() const {
-    return get(newTy + "*", PointerTy, this, (Type*)0);
-  }
+    // Resolve all forward references now.
+    ResolveDefinitions(LateResolveValues, &CurModule.LateResolveValues);
 
-  bool isUnresolved() const { return oldTy == UnresolvedTy; }
-  bool isUpReference() const { return oldTy == UpRefTy; }
-  bool isVoid() const { return oldTy == VoidTy; }
-  bool isBool() const { return oldTy == BoolTy; }
-  bool isSigned() const {
-    return oldTy == SByteTy || oldTy == ShortTy || 
-           oldTy == IntTy || oldTy == LongTy;
+    Values.clear();         // Clear out function local definitions
+    RenameMap.clear();
+    SignedValues.clear();
+    CurrentFunction = 0;
+    isDeclare = false;
+    Linkage = GlobalValue::ExternalLinkage;
   }
+} CurFun;  // Info for the current function...
 
-  bool isUnsigned() const {
-    return oldTy == UByteTy || oldTy == UShortTy || 
-           oldTy == UIntTy || oldTy == ULongTy;
-  }
-  bool isSignless() const { return !isSigned() && !isUnsigned(); }
-  bool isInteger() const { return isSigned() || isUnsigned(); }
-  bool isIntegral() const { return oldTy == BoolTy || isInteger(); }
-  bool isFloatingPoint() const { return oldTy == DoubleTy || oldTy == FloatTy; }
-  bool isPacked() const { return oldTy == PackedTy; }
-  bool isPointer() const { return oldTy == PointerTy; }
-  bool isStruct() const { return oldTy == StructTy || oldTy == PackedStructTy; }
-  bool isArray() const { return oldTy == ArrayTy; }
-  bool isOther() const { 
-    return !isPacked() && !isPointer() && !isFloatingPoint() && !isIntegral(); }
-  bool isFunction() const { return oldTy == FunctionTy; }
-  bool isComposite() const {
-    return isStruct() || isPointer() || isArray() || isPacked();
-  }
+static bool inFunctionScope() { return CurFun.CurrentFunction != 0; }
 
-  bool isAttributeCandidate() const {
-    return isIntegral() && getBitWidth() < 32;
-  }
 
-  bool isUnresolvedDeep() const;
+//===----------------------------------------------------------------------===//
+//               Code to handle definitions of all the types
+//===----------------------------------------------------------------------===//
 
-  unsigned getBitWidth() const;
+static int InsertValue(Value *V,
+                  std::map &ValueTab = CurFun.Values) {
+  if (V->hasName()) return -1;           // Is this a numbered definition?
+
+  // Yes, insert the value into the value table...
+  ValueList &List = ValueTab[V->getType()];
+  List.push_back(V);
+  return List.size()-1;
+}
+
+static const Type *getTypeVal(const ValID &D, bool DoNotImprovise = false) {
+  switch (D.Type) {
+  case ValID::NumberVal:               // Is it a numbered definition?
+    // Module constants occupy the lowest numbered slots...
+    if ((unsigned)D.Num < CurModule.Types.size()) {
+      return CurModule.Types[(unsigned)D.Num];
+    }
+    break;
+  case ValID::NameVal:                 // Is it a named definition?
+    if (const Type *N = CurModule.CurrentModule->getTypeByName(D.Name)) {
+      D.destroy();  // Free old strdup'd memory...
+      return N;
+    }
+    break;
+  default:
+    error("Internal parser error: Invalid symbol type reference");
+    return 0;
+  }
 
-  const Type* getIndexedType(const Value*  V) const;
+  // If we reached here, we referenced either a symbol that we don't know about
+  // or an id number that hasn't been read yet.  We may be referencing something
+  // forward, so just create an entry to be resolved later and get to it...
+  //
+  if (DoNotImprovise) return 0;  // Do we just want a null to be returned?
 
-  unsigned getNumStructElements() const { 
-    return (elements ? elements->size() : 0);
-  }
 
-  const Type* getElement(unsigned idx) const {
-    if (elements)
-      if (idx < elements->size())
-        return (*elements)[idx];
-    return 0;
+  if (inFunctionScope()) {
+    if (D.Type == ValID::NameVal) {
+      error("Reference to an undefined type: '" + D.getName() + "'");
+      return 0;
+    } else {
+      error("Reference to an undefined type: #" + itostr(D.Num));
+      return 0;
+    }
   }
 
-private:
-  Type() 
-    : newTy(), oldTy(UnresolvedTy), elemTy(0), resultTy(0), elements(0),
-      nelems(0) {
+  std::map::iterator I =CurModule.LateResolveTypes.find(D);
+  if (I != CurModule.LateResolveTypes.end())
+    return I->second;
+
+  Type *Typ = OpaqueType::get();
+  CurModule.LateResolveTypes.insert(std::make_pair(D, Typ));
+  return Typ;
+ }
+
+// getExistingValue - Look up the value specified by the provided type and
+// the provided ValID.  If the value exists and has already been defined, return
+// it.  Otherwise return null.
+//
+static Value *getExistingValue(const Type *Ty, const ValID &D) {
+  if (isa(Ty)) {
+    error("Functions are not values and must be referenced as pointers");
+  }
+
+  switch (D.Type) {
+  case ValID::NumberVal: {                 // Is it a numbered definition?
+    unsigned Num = (unsigned)D.Num;
+
+    // Module constants occupy the lowest numbered slots...
+    std::map::iterator VI = CurModule.Values.find(Ty);
+    if (VI != CurModule.Values.end()) {
+      if (Num < VI->second.size())
+        return VI->second[Num];
+      Num -= VI->second.size();
+    }
+
+    // Make sure that our type is within bounds
+    VI = CurFun.Values.find(Ty);
+    if (VI == CurFun.Values.end()) return 0;
+
+    // Check that the number is within bounds...
+    if (VI->second.size() <= Num) return 0;
+
+    return VI->second[Num];
+  }
+
+  case ValID::NameVal: {                // Is it a named definition?
+    // Get the name out of the ID
+    std::string Name(D.Name);
+    Value* V = 0;
+    RenameMapKey Key = std::make_pair(Name, Ty);
+    if (inFunctionScope()) {
+      // See if the name was renamed
+      RenameMapType::const_iterator I = CurFun.RenameMap.find(Key);
+      std::string LookupName;
+      if (I != CurFun.RenameMap.end())
+        LookupName = I->second;
+      else
+        LookupName = Name;
+      SymbolTable &SymTab = CurFun.CurrentFunction->getValueSymbolTable();
+      V = SymTab.lookup(Ty, LookupName);
+    }
+    if (!V) {
+      RenameMapType::const_iterator I = CurModule.RenameMap.find(Key);
+      std::string LookupName;
+      if (I != CurModule.RenameMap.end())
+        LookupName = I->second;
+      else
+        LookupName = Name;
+      V = CurModule.CurrentModule->getValueSymbolTable().lookup(Ty, LookupName);
+    }
+    if (V == 0) 
+      return 0;
+
+    D.destroy();  // Free old strdup'd memory...
+    return V;
   }
 
-  Type(const Type& that); // do not implement
-  Type& operator=(const Type& that); // do not implement
+  // Check to make sure that "Ty" is an integral type, and that our
+  // value will fit into the specified type...
+  case ValID::ConstSIntVal:    // Is it a constant pool reference??
+    if (!ConstantInt::isValueValidForType(Ty, D.ConstPool64)) {
+      error("Signed integral constant '" + itostr(D.ConstPool64) + 
+            "' is invalid for type '" + Ty->getDescription() + "'");
+    }
+    return ConstantInt::get(Ty, D.ConstPool64);
+
+  case ValID::ConstUIntVal:     // Is it an unsigned const pool reference?
+    if (!ConstantInt::isValueValidForType(Ty, D.UConstPool64)) {
+      if (!ConstantInt::isValueValidForType(Ty, D.ConstPool64))
+        error("Integral constant '" + utostr(D.UConstPool64) + 
+              "' is invalid or out of range");
+      else     // This is really a signed reference.  Transmogrify.
+        return ConstantInt::get(Ty, D.ConstPool64);
+    } else
+      return ConstantInt::get(Ty, D.UConstPool64);
 
-  ~Type() { delete elements; }
+  case ValID::ConstFPVal:        // Is it a floating point const pool reference?
+    if (!ConstantFP::isValueValidForType(Ty, D.ConstPoolFP))
+      error("FP constant invalid for type");
+    return ConstantFP::get(Ty, D.ConstPoolFP);
+
+  case ValID::ConstNullVal:      // Is it a null value?
+    if (!isa(Ty))
+      error("Cannot create a a non pointer null");
+    return ConstantPointerNull::get(cast(Ty));
+
+  case ValID::ConstUndefVal:      // Is it an undef value?
+    return UndefValue::get(Ty);
+
+  case ValID::ConstZeroVal:      // Is it a zero value?
+    return Constant::getNullValue(Ty);
+    
+  case ValID::ConstantVal:       // Fully resolved constant?
+    if (D.ConstantValue->getType() != Ty) 
+      error("Constant expression type different from required type");
+    return D.ConstantValue;
+
+  case ValID::InlineAsmVal: {    // Inline asm expression
+    const PointerType *PTy = dyn_cast(Ty);
+    const FunctionType *FTy =
+      PTy ? dyn_cast(PTy->getElementType()) : 0;
+    if (!FTy || !InlineAsm::Verify(FTy, D.IAD->Constraints))
+      error("Invalid type for asm constraint string");
+    InlineAsm *IA = InlineAsm::get(FTy, D.IAD->AsmString, D.IAD->Constraints,
+                                   D.IAD->HasSideEffects);
+    D.destroy();   // Free InlineAsmDescriptor.
+    return IA;
+  }
+  default:
+    assert(0 && "Unhandled case");
+    return 0;
+  }   // End of switch
 
-  struct ltfunctor
-  {
-    bool operator()(const Type* X, const Type* Y) const {
-      assert(X && "Can't compare null pointer");
-      assert(Y && "Can't compare null pointer");
-      return *X < *Y;
-    }
-  };
+  assert(0 && "Unhandled case");
+  return 0;
+}
 
-  typedef std::set TypeRegMap;
+// getVal - This function is identical to getExistingValue, except that if a
+// value is not already defined, it "improvises" by creating a placeholder var
+// that looks and acts just like the requested variable.  When the value is
+// defined later, all uses of the placeholder variable are replaced with the
+// real thing.
+//
+static Value *getVal(const Type *Ty, const ValID &ID) {
+  if (Ty == Type::LabelTy)
+    error("Cannot use a basic block here");
+
+  // See if the value has already been defined.
+  Value *V = getExistingValue(Ty, ID);
+  if (V) return V;
+
+  if (!Ty->isFirstClassType() && !isa(Ty))
+    error("Invalid use of a composite type");
+
+  // If we reached here, we referenced either a symbol that we don't know about
+  // or an id number that hasn't been read yet.  We may be referencing something
+  // forward, so just create an entry to be resolved later and get to it...
+  assert(!isa(Ty) && "Can't create value with SignedType");
+  V = new Argument(Ty);
+
+  // Remember where this forward reference came from.  FIXME, shouldn't we try
+  // to recycle these things??
+  CurModule.PlaceHolderInfo.insert(
+    std::make_pair(V, std::make_pair(ID, Upgradelineno-1)));
 
-  static const Type* add_new_type(Type* existing);
+  if (inFunctionScope())
+    InsertValue(V, CurFun.LateResolveValues);
+  else
+    InsertValue(V, CurModule.LateResolveValues);
+  return V;
+}
 
-  std::string newTy;
-  TypeIDs oldTy;
-  Type *elemTy;
-  Type *resultTy;
-  TypeList *elements;
-  uint64_t nelems;
-  static TypeRegMap registry;
-public:
-  typedef std::vector TypeVector;
-  typedef std::map TypeMap;
-  typedef std::map TypePlaneMap;
-  typedef std::map GlobalsTypeMap;
-  static TypeVector EnumeratedTypes;
-  static TypeMap NamedTypes;
-  static GlobalsTypeMap Globals;
-};
-
-Type::TypeRegMap     Type::registry;
-Type::TypeVector     Type::EnumeratedTypes;
-Type::TypeMap        Type::NamedTypes;
-Type::GlobalsTypeMap Type::Globals;
-
-const Type* Type::get(const std::string &newType, TypeIDs oldType) {
-  Type* Ty = new Type();
-  Ty->newTy = newType;
-  Ty->oldTy = oldType;
-  return add_new_type(Ty);
-}
-
-const Type* Type::get(const std::string& newType, TypeIDs oldType, 
-                              const Type* eTy, const Type* rTy) {
-  Type* Ty= new Type();
-  Ty->newTy = newType;
-  Ty->oldTy = oldType;
-  Ty->elemTy = const_cast(eTy);
-  Ty->resultTy = const_cast(rTy);
-  return add_new_type(Ty);
-}
-
-const Type* Type::get(const std::string& newType, TypeIDs oldType, 
-                              const Type *eTy, uint64_t elems) {
-  Type* Ty = new Type();
-  Ty->newTy = newType;
-  Ty->oldTy = oldType;
-  Ty->elemTy = const_cast(eTy);
-  Ty->nelems = elems;
-  return  add_new_type(Ty);
-}
-
-const Type* Type::get(const std::string& newType, TypeIDs oldType, 
-                              TypeList* TL) {
-  Type* Ty = new Type();
-  Ty->newTy = newType;
-  Ty->oldTy = oldType;
-  Ty->elements = TL;
-  return add_new_type(Ty);
-}
-
-const Type* Type::get(const std::string& newType, const Type* resTy,
-                              TypeList* TL) {
-  Type* Ty = new Type();
-  Ty->newTy = newType;
-  Ty->oldTy = FunctionTy;
-  Ty->resultTy = const_cast(resTy);
-  Ty->elements = TL;
-  return add_new_type(Ty);
-}
-
-const Type* Type::resolve() const {
-  if (isUnresolved()) {
-    if (getNewTy()[0] == '%' && isdigit(newTy[1])) {
-      unsigned ref = atoi(&((newTy.c_str())[1])); // skip the %
-      if (ref < EnumeratedTypes.size()) {
-        return EnumeratedTypes[ref];
-      } else {
-        std::string msg("Can't resolve numbered type: ");
-        msg += getNewTy();
-        yyerror(msg.c_str());
-      }
-    } else {
-      Type::TypeMap::iterator I = NamedTypes.find(newTy);
-      if (I != NamedTypes.end()) {
-        return I->second;
-      } else {
-        std::string msg("Cannot resolve type: ");
-        msg += getNewTy();
-        yyerror(msg.c_str());
-      }
-    }
+/// getBBVal - This is used for two purposes:
+///  * If isDefinition is true, a new basic block with the specified ID is being
+///    defined.
+///  * If isDefinition is true, this is a reference to a basic block, which may
+///    or may not be a forward reference.
+///
+static BasicBlock *getBBVal(const ValID &ID, bool isDefinition = false) {
+  assert(inFunctionScope() && "Can't get basic block at global scope");
+
+  std::string Name;
+  BasicBlock *BB = 0;
+  switch (ID.Type) {
+  default: 
+    error("Illegal label reference " + ID.getName());
+    break;
+  case ValID::NumberVal:                // Is it a numbered definition?
+    if (unsigned(ID.Num) >= CurFun.NumberedBlocks.size())
+      CurFun.NumberedBlocks.resize(ID.Num+1);
+    BB = CurFun.NumberedBlocks[ID.Num];
+    break;
+  case ValID::NameVal:                  // Is it a named definition?
+    Name = ID.Name;
+    if (Value *N = CurFun.CurrentFunction->
+                   getValueSymbolTable().lookup(Type::LabelTy, Name)) {
+      if (N->getType() != Type::LabelTy)
+        error("Name '" + Name + "' does not refer to a BasicBlock");
+      BB = cast(N);
+    }
+    break;
+  }
+
+  // See if the block has already been defined.
+  if (BB) {
+    // If this is the definition of the block, make sure the existing value was
+    // just a forward reference.  If it was a forward reference, there will be
+    // an entry for it in the PlaceHolderInfo map.
+    if (isDefinition && !CurFun.BBForwardRefs.erase(BB))
+      // The existing value was a definition, not a forward reference.
+      error("Redefinition of label " + ID.getName());
+
+    ID.destroy();                       // Free strdup'd memory.
+    return BB;
+  }
+
+  // Otherwise this block has not been seen before.
+  BB = new BasicBlock("", CurFun.CurrentFunction);
+  if (ID.Type == ValID::NameVal) {
+    BB->setName(ID.Name);
+  } else {
+    CurFun.NumberedBlocks[ID.Num] = BB;
   }
-  // otherwise its already resolved.
-  return this;
-}
 
-bool Type::operator<(const Type& that) const {
-  if (this == &that)
-    return false;
-  if (oldTy != that.oldTy)
-    return oldTy < that.oldTy;
-  switch (oldTy) {
-    case UpRefTy: {
-      unsigned thisUp = this->getUpRefNum();
-      unsigned thatUp = that.getUpRefNum();
-      return thisUp < thatUp;
-    }
-    case PackedTy:
-    case ArrayTy:
-      if (this->nelems != that.nelems)
-        return nelems < that.nelems;
-    case PointerTy: {
-      const Type* thisTy = this->elemTy;
-      const Type* thatTy = that.elemTy;
-      return *thisTy < *thatTy;
-    }
-    case FunctionTy: {
-      const Type* thisTy = this->resultTy;
-      const Type* thatTy = that.resultTy;
-      if (!thisTy->sameOldTyAs(thatTy))
-        return *thisTy < *thatTy;
-      /* FALL THROUGH */
-    }
-    case StructTy:
-    case PackedStructTy: {
-      if (elements->size() != that.elements->size())
-        return elements->size() < that.elements->size();
-      for (unsigned i = 0; i < elements->size(); i++) {
-        const Type* thisTy = (*this->elements)[i];
-        const Type* thatTy = (*that.elements)[i];
-        if (!thisTy->sameOldTyAs(thatTy))
-          return *thisTy < *thatTy;
-      }
-      break;
-    }
-    case UnresolvedTy:
-      return this->newTy < that.newTy;
-    default:
-      break;
+  // If this is not a definition, keep track of it so we can use it as a forward
+  // reference.
+  if (!isDefinition) {
+    // Remember where this forward reference came from.
+    CurFun.BBForwardRefs[BB] = std::make_pair(ID, Upgradelineno);
+  } else {
+    // The forward declaration could have been inserted anywhere in the
+    // function: insert it into the correct place now.
+    CurFun.CurrentFunction->getBasicBlockList().remove(BB);
+    CurFun.CurrentFunction->getBasicBlockList().push_back(BB);
   }
-  return false; 
+  ID.destroy();
+  return BB;
 }
 
-bool Type::sameOldTyAs(const Type* that) const {
-  if (that == 0)
-    return false;
-  if ( this == that ) 
-    return true;
-  if (oldTy != that->oldTy)
-    return false;
-  switch (oldTy) {
-    case PackedTy:
-    case ArrayTy:
-      if (nelems != that->nelems)
-        return false;
-      /* FALL THROUGH */
-    case PointerTy: {
-      const Type* thisTy = this->elemTy;
-      const Type* thatTy = that->elemTy;
-      return thisTy->sameOldTyAs(thatTy);
-    }
-    case FunctionTy: {
-      const Type* thisTy = this->resultTy;
-      const Type* thatTy = that->resultTy;
-      if (!thisTy->sameOldTyAs(thatTy))
-        return false;
-      /* FALL THROUGH */
-    }
-    case StructTy:
-    case PackedStructTy: {
-      if (elements->size() != that->elements->size())
-        return false;
-      for (unsigned i = 0; i < elements->size(); i++) {
-        const Type* thisTy = (*this->elements)[i];
-        const Type* thatTy = (*that->elements)[i];
-        if (!thisTy->sameOldTyAs(thatTy))
-          return false;
+
+//===----------------------------------------------------------------------===//
+//              Code to handle forward references in instructions
+//===----------------------------------------------------------------------===//
+//
+// This code handles the late binding needed with statements that reference
+// values not defined yet... for example, a forward branch, or the PHI node for
+// a loop body.
+//
+// This keeps a table (CurFun.LateResolveValues) of all such forward references
+// and back patchs after we are done.
+//
+
+// ResolveDefinitions - If we could not resolve some defs at parsing
+// time (forward branches, phi functions for loops, etc...) resolve the
+// defs now...
+//
+static void 
+ResolveDefinitions(std::map &LateResolvers,
+                   std::map *FutureLateResolvers) {
+  // Loop over LateResolveDefs fixing up stuff that couldn't be resolved
+  for (std::map::iterator LRI = LateResolvers.begin(),
+         E = LateResolvers.end(); LRI != E; ++LRI) {
+    ValueList &List = LRI->second;
+    while (!List.empty()) {
+      Value *V = List.back();
+      List.pop_back();
+
+      std::map >::iterator PHI =
+        CurModule.PlaceHolderInfo.find(V);
+      assert(PHI != CurModule.PlaceHolderInfo.end() && "Placeholder error");
+
+      ValID &DID = PHI->second.first;
+
+      Value *TheRealValue = getExistingValue(LRI->first, DID);
+      if (TheRealValue) {
+        V->replaceAllUsesWith(TheRealValue);
+        delete V;
+        CurModule.PlaceHolderInfo.erase(PHI);
+      } else if (FutureLateResolvers) {
+        // Functions have their unresolved items forwarded to the module late
+        // resolver table
+        InsertValue(V, *FutureLateResolvers);
+      } else {
+        if (DID.Type == ValID::NameVal) {
+          error("Reference to an invalid definition: '" +DID.getName()+
+                "' of type '" + V->getType()->getDescription() + "'",
+                PHI->second.second);
+          return;
+        } else {
+          error("Reference to an invalid definition: #" +
+                itostr(DID.Num) + " of type '" + 
+                V->getType()->getDescription() + "'", PHI->second.second);
+          return;
+        }
       }
-      return true;
     }
-    case UnresolvedTy:
-      return this->newTy == that->newTy;
-    default:
-      return true; // for all others oldTy == that->oldTy is sufficient
   }
-  return true;
+
+  LateResolvers.clear();
 }
 
-bool Type::isUnresolvedDeep() const {
-  switch (oldTy) {
-    case UnresolvedTy: 
-      return true;
-    case PackedTy:
-    case ArrayTy:
-    case PointerTy:
-      return elemTy->isUnresolvedDeep();
-    case PackedStructTy:
-    case StructTy:
-      for (unsigned i = 0; i < elements->size(); i++)
-        if ((*elements)[i]->isUnresolvedDeep())
-          return true;
-      return false;
-    default:
-      return false;
+// ResolveTypeTo - A brand new type was just declared.  This means that (if
+// name is not null) things referencing Name can be resolved.  Otherwise, things
+// refering to the number can be resolved.  Do this now.
+//
+static void ResolveTypeTo(char *Name, const Type *ToTy) {
+  ValID D;
+  if (Name) D = ValID::create(Name);
+  else      D = ValID::create((int)CurModule.Types.size());
+
+  std::map::iterator I =
+    CurModule.LateResolveTypes.find(D);
+  if (I != CurModule.LateResolveTypes.end()) {
+    ((DerivedType*)I->second.get())->refineAbstractTypeTo(ToTy);
+    CurModule.LateResolveTypes.erase(I);
   }
 }
 
-unsigned Type::getBitWidth() const {
-  switch (oldTy) {
-    default:
-    case LabelTy:
-    case VoidTy : return 0;
-    case BoolTy : return 1;
-    case SByteTy: case UByteTy : return 8;
-    case ShortTy: case UShortTy : return 16;
-    case IntTy: case UIntTy: case FloatTy: return 32;
-    case LongTy: case ULongTy: case DoubleTy : return 64;
-    case PointerTy: return SizeOfPointer; // global var
-    case PackedTy: 
-    case ArrayTy: 
-      return nelems * elemTy->getBitWidth();
-    case StructTy:
-    case PackedStructTy: {
-      uint64_t size = 0;
-      for (unsigned i = 0; i < elements->size(); i++) {
-        size += (*elements)[i]->getBitWidth();
-      }
-      return size;
-    }
-  }
+static std::string makeNameUnique(const std::string& Name) {
+  static unsigned UniqueNameCounter = 1;
+  std::string Result(Name);
+  Result += ".upgrd." + llvm::utostr(UniqueNameCounter++);
+  return Result;
 }
 
-const Type* Type::getIndexedType(const Value*  V) const {
-  if (isStruct()) {
-    if (V->isConstant() && V->type->isInteger()) {
-      size_t pos = V->val->find(' ') + 1;
-      if (pos < V->val->size()) {
-        uint64_t idx = atoi(V->val->substr(pos).c_str());
-        return (*elements)[idx];
-      } else {
-        yyerror("Invalid value for constant integer");
-        return 0;
+// setValueName - Set the specified value to the name given.  The name may be
+// null potentially, in which case this is a noop.  The string passed in is
+// assumed to be a malloc'd string buffer, and is free'd by this function.
+//
+static void setValueName(Value *V, char *NameStr) {
+  if (NameStr) {
+    std::string Name(NameStr);      // Copy string
+    free(NameStr);                  // Free old string
+
+    if (V->getType() == Type::VoidTy) {
+      error("Can't assign name '" + Name + "' to value with void type");
+      return;
+    }
+
+    assert(!isa(V->getType()) && "Shouldn't have SignedType Value");
+    assert(inFunctionScope() && "Must be in function scope");
+
+    // Search the function's symbol table for an existing value of this name
+    Value* Existing = 0;
+    SymbolTable &ST = CurFun.CurrentFunction->getValueSymbolTable();
+    SymbolTable::plane_const_iterator PI = ST.plane_begin(), PE =ST.plane_end();
+    for ( ; PI != PE; ++PI) {
+      SymbolTable::value_const_iterator VI = PI->second.find(Name);
+      if (VI != PI->second.end()) {
+        Existing = VI->second;
+        break;
       }
-    } else {
-      yyerror("Structure requires constant index");
-      return 0;
     }
+    if (Existing) {
+      if (Existing->getType() == V->getType()) {
+        // The type of the Existing value and the new one are the same. This
+        // is probably a type plane collapsing error. If the types involved
+        // are both integer, just rename it. Otherwise it 
+        // is a redefinition error.
+        if (!Existing->getType()->isInteger()) {
+          error("Redefinition of value named '" + Name + "' in the '" +
+                V->getType()->getDescription() + "' type plane");
+          return;
+        }
+      } 
+      // In LLVM 2.0 we don't allow names to be re-used for any values in a 
+      // function, regardless of Type. Previously re-use of names was okay as 
+      // long as they were distinct types. With type planes collapsing because
+      // of the signedness change and because of PR411, this can no longer be
+      // supported. We must search the entire symbol table for a conflicting
+      // name and make the name unique. No warning is needed as this can't 
+      // cause a problem.
+      std::string NewName = makeNameUnique(Name);
+      // We're changing the name but it will probably be used by other 
+      // instructions as operands later on. Consequently we have to retain
+      // a mapping of the renaming that we're doing.
+      RenameMapKey Key = std::make_pair(Name,V->getType());
+      CurFun.RenameMap[Key] = NewName;
+      Name = NewName;
+    }
+
+    // Set the name.
+    V->setName(Name);
   }
-  if (isArray() || isPacked() || isPointer())
-    return elemTy;
-  yyerror("Invalid type for getIndexedType");
-  return 0;
 }
 
-void Type::getSignedness(unsigned &sNum, unsigned &uNum, 
-                             UpRefStack& stack) const {
-  switch (oldTy) {
-    default:
-    case OpaqueTy: case LabelTy: case VoidTy: case BoolTy: 
-    case FloatTy : case DoubleTy: case UpRefTy:
-      return;
-    case SByteTy: case ShortTy: case LongTy: case IntTy: 
-      sNum++;
-      return;
-    case UByteTy: case UShortTy: case UIntTy: case ULongTy: 
-      uNum++;
-      return;
-    case PointerTy:
-    case PackedTy: 
-    case ArrayTy:
-      stack.push_back(this);
-      elemTy->getSignedness(sNum, uNum, stack);
-      return;
-    case StructTy:
-    case PackedStructTy: {
-      stack.push_back(this);
-      for (unsigned i = 0; i < elements->size(); i++) {
-        (*elements)[i]->getSignedness(sNum, uNum, stack);
+/// ParseGlobalVariable - Handle parsing of a global.  If Initializer is null,
+/// this is a declaration, otherwise it is a definition.
+static GlobalVariable *
+ParseGlobalVariable(char *NameStr,GlobalValue::LinkageTypes Linkage,
+                    bool isConstantGlobal, const Type *Ty,
+                    Constant *Initializer) {
+  if (isa(Ty))
+    error("Cannot declare global vars of function type");
+
+  const PointerType *PTy = PointerType::get(Ty);
+
+  std::string Name;
+  if (NameStr) {
+    Name = NameStr;      // Copy string
+    free(NameStr);       // Free old string
+  }
+
+  // See if this global value was forward referenced.  If so, recycle the
+  // object.
+  ValID ID;
+  if (!Name.empty()) {
+    ID = ValID::create((char*)Name.c_str());
+  } else {
+    ID = ValID::create((int)CurModule.Values[PTy].size());
+  }
+
+  if (GlobalValue *FWGV = CurModule.GetForwardRefForGlobal(PTy, ID)) {
+    // Move the global to the end of the list, from whereever it was
+    // previously inserted.
+    GlobalVariable *GV = cast(FWGV);
+    CurModule.CurrentModule->getGlobalList().remove(GV);
+    CurModule.CurrentModule->getGlobalList().push_back(GV);
+    GV->setInitializer(Initializer);
+    GV->setLinkage(Linkage);
+    GV->setConstant(isConstantGlobal);
+    InsertValue(GV, CurModule.Values);
+    return GV;
+  }
+
+  // If this global has a name, check to see if there is already a definition
+  // of this global in the module and emit warnings if there are conflicts.
+  if (!Name.empty()) {
+    // The global has a name. See if there's an existing one of the same name.
+    if (CurModule.CurrentModule->getNamedGlobal(Name)) {
+      // We found an existing global ov the same name. This isn't allowed 
+      // in LLVM 2.0. Consequently, we must alter the name of the global so it
+      // can at least compile. This can happen because of type planes 
+      // There is alread a global of the same name which means there is a
+      // conflict. Let's see what we can do about it.
+      std::string NewName(makeNameUnique(Name));
+      if (Linkage == GlobalValue::InternalLinkage) {
+        // The linkage type is internal so just warn about the rename without
+        // invoking "scarey language" about linkage failures. GVars with
+        // InternalLinkage can be renamed at will.
+        warning("Global variable '" + Name + "' was renamed to '"+ 
+                NewName + "'");
+      } else {
+        // The linkage of this gval is external so we can't reliably rename 
+        // it because it could potentially create a linking problem.  
+        // However, we can't leave the name conflict in the output either or 
+        // it won't assemble with LLVM 2.0.  So, all we can do is rename 
+        // this one to something unique and emit a warning about the problem.
+        warning("Renaming global variable '" + Name + "' to '" + NewName + 
+                  "' may cause linkage errors");
       }
-      return;
-    }
-    case UnresolvedTy: {
-      const Type* Ty = this->resolve();
-      // Let's not recurse.
-      UpRefStack::const_iterator I = stack.begin(), E = stack.end();
-      for ( ; I != E && *I != Ty; ++I) 
-        ;
-      if (I == E)
-        Ty->getSignedness(sNum, uNum, stack);
-      return;
+
+      // Put the renaming in the global rename map
+      RenameMapKey Key = std::make_pair(Name,PointerType::get(Ty));
+      CurModule.RenameMap[Key] = NewName;
+
+      // Rename it
+      Name = NewName;
     }
   }
-}
 
-std::string AddSuffix(const std::string& Name, const std::string& Suffix) {
-  if (Name[Name.size()-1] == '"') {
-    std::string Result = Name;
-    Result.insert(Result.size()-1, Suffix);
-    return Result;
-  }
-  return Name + Suffix;
+  // Otherwise there is no existing GV to use, create one now.
+  GlobalVariable *GV =
+    new GlobalVariable(Ty, isConstantGlobal, Linkage, Initializer, Name,
+                       CurModule.CurrentModule);
+  InsertValue(GV, CurModule.Values);
+  return GV;
 }
 
-std::string Type::makeUniqueName(const std::string& BaseName) const {
-  if (BaseName == "\"alloca point\"")
-    return BaseName;
-  switch (oldTy) {
-    default:
-      break;
-    case OpaqueTy: case LabelTy: case VoidTy: case BoolTy: case UpRefTy:
-    case FloatTy : case DoubleTy: case UnresolvedTy:
-      return BaseName;
-    case SByteTy: case ShortTy: case LongTy: case IntTy: 
-      return AddSuffix(BaseName, ".s");
-    case UByteTy: case UShortTy: case UIntTy: case ULongTy: 
-      return AddSuffix(BaseName, ".u");
-  }
-
-  unsigned uNum = 0, sNum = 0;
-  std::string Suffix;
-  switch (oldTy) {
-    case PointerTy:
-    case PackedTy: 
-    case ArrayTy: {
-      Type::UpRefStack stack;
-      elemTy->resolve()->getSignedness(sNum, uNum, stack);
-      break;
-    }
-    case StructTy:
-    case PackedStructTy: {
-      for (unsigned i = 0; i < elements->size(); i++) {
-        Type::UpRefStack stack;
-        (*elements)[i]->resolve()->getSignedness(sNum, uNum, stack);
-      }
-      break;
-    }
-    default:
-      assert(0 && "Invalid Type");
-      break;
+// setTypeName - Set the specified type to the name given.  The name may be
+// null potentially, in which case this is a noop.  The string passed in is
+// assumed to be a malloc'd string buffer, and is freed by this function.
+//
+// This function returns true if the type has already been defined, but is
+// allowed to be redefined in the specified context.  If the name is a new name
+// for the type plane, it is inserted and false is returned.
+static bool setTypeName(const Type *T, char *NameStr) {
+  assert(!inFunctionScope() && "Can't give types function-local names");
+  if (NameStr == 0) return false;
+ 
+  std::string Name(NameStr);      // Copy string
+  free(NameStr);                  // Free old string
+
+  // We don't allow assigning names to void type
+  if (T == Type::VoidTy) {
+    error("Can't assign name '" + Name + "' to the void type");
+    return false;
   }
 
-  if (sNum == 0 && uNum == 0)
-    return BaseName;
+  // Set the type name, checking for conflicts as we do so.
+  bool AlreadyExists = CurModule.CurrentModule->addTypeName(Name, T);
 
-  switch (oldTy) {
-    default:             Suffix += ".nada"; break;
-    case PointerTy:      Suffix += ".pntr"; break;
-    case PackedTy:       Suffix += ".pckd"; break;
-    case ArrayTy:        Suffix += ".arry"; break;
-    case StructTy:       Suffix += ".strc"; break;
-    case PackedStructTy: Suffix += ".pstr"; break;
-  }
-
-  Suffix += ".s" + llvm::utostr(sNum);
-  Suffix += ".u" + llvm::utostr(uNum);
-  return AddSuffix(BaseName, Suffix);
-}
-
-Type& Type::operator=(const Type& that) {
-  oldTy = that.oldTy;
-  nelems = that.nelems;
-  newTy = that.newTy;
-  elemTy = that.elemTy;
-  resultTy = that.resultTy;
-  if (that.elements) {
-    elements = new TypeList(that.elements->size());
-    *elements = *that.elements;
-  } else {
-    elements = 0;
+  if (AlreadyExists) {   // Inserting a name that is already defined???
+    const Type *Existing = CurModule.CurrentModule->getTypeByName(Name);
+    assert(Existing && "Conflict but no matching type?");
+
+    // There is only one case where this is allowed: when we are refining an
+    // opaque type.  In this case, Existing will be an opaque type.
+    if (const OpaqueType *OpTy = dyn_cast(Existing)) {
+      // We ARE replacing an opaque type!
+      const_cast(OpTy)->refineAbstractTypeTo(T);
+      return true;
+    }
+
+    // Otherwise, this is an attempt to redefine a type. That's okay if
+    // the redefinition is identical to the original. This will be so if
+    // Existing and T point to the same Type object. In this one case we
+    // allow the equivalent redefinition.
+    if (Existing == T) return true;  // Yes, it's equal.
+
+    // Any other kind of (non-equivalent) redefinition is an error.
+    error("Redefinition of type named '" + Name + "' in the '" +
+          T->getDescription() + "' type plane");
   }
-  return *this;
+
+  return false;
 }
 
-const Type* Type::add_new_type(Type* newTy) {
-  TypeRegMap::iterator I = registry.find(newTy);
-  if (I != registry.end()) {
-    delete newTy;
-    return *I;
-  }
-  registry.insert(newTy);
-  return newTy;
-}
-
-class Instruction {
-};
-
-/// This type is used to keep track of the signedness of constants.
-struct Constant {
-  std::string *cnst;
-  const Type *type;
-  ~Constant() { delete cnst; }
-};
-
-/// This variable provides a counter for unique names. It is used in various
-/// productions to ensure a unique name is generated.
-static uint64_t UniqueNameCounter = 1;
-
-// This is set when a DECLARE keyword is recognized so that subsequent parsing
-// of a function prototype can know if its a declaration or definition.
-static bool isDeclare = false;
-
-// This bool is used to communicate between the InstVal and Inst rules about
-// whether or not a cast should be deleted. When the flag is set, InstVal has
-// determined that the cast is a candidate. However, it can only be deleted if
-// the value being casted is the same value name as the instruction. The Inst
-// rule makes that comparison if the flag is set and comments out the
-// instruction if they match.
-static bool deleteUselessCastFlag = false;
-static std::string* deleteUselessCastName = 0;
+//===----------------------------------------------------------------------===//
+// Code for handling upreferences in type names...
+//
 
+// TypeContains - Returns true if Ty directly contains E in it.
+//
+static bool TypeContains(const Type *Ty, const Type *E) {
+  return std::find(Ty->subtype_begin(), Ty->subtype_end(),
+                   E) != Ty->subtype_end();
+}
+
+namespace {
+  struct UpRefRecord {
+    // NestingLevel - The number of nesting levels that need to be popped before
+    // this type is resolved.
+    unsigned NestingLevel;
+
+    // LastContainedTy - This is the type at the current binding level for the
+    // type.  Every time we reduce the nesting level, this gets updated.
+    const Type *LastContainedTy;
+
+    // UpRefTy - This is the actual opaque type that the upreference is
+    // represented with.
+    OpaqueType *UpRefTy;
+
+    UpRefRecord(unsigned NL, OpaqueType *URTy)
+      : NestingLevel(NL), LastContainedTy(URTy), UpRefTy(URTy) {}
+  };
+}
 
+// UpRefs - A list of the outstanding upreferences that need to be resolved.
+static std::vector UpRefs;
+
+/// HandleUpRefs - Every time we finish a new layer of types, this function is
+/// called.  It loops through the UpRefs vector, which is a list of the
+/// currently active types.  For each type, if the up reference is contained in
+/// the newly completed type, we decrement the level count.  When the level
+/// count reaches zero, the upreferenced type is the type that is passed in:
+/// thus we can complete the cycle.
+///
+static PATypeHolder HandleUpRefs(const Type *ty) {
+  // If Ty isn't abstract, or if there are no up-references in it, then there is
+  // nothing to resolve here.
+  if (!ty->isAbstract() || UpRefs.empty()) return ty;
+  
+  PATypeHolder Ty(ty);
+  UR_OUT("Type '" << Ty->getDescription() <<
+         "' newly formed.  Resolving upreferences.\n" <<
+         UpRefs.size() << " upreferences active!\n");
+
+  // If we find any resolvable upreferences (i.e., those whose NestingLevel goes
+  // to zero), we resolve them all together before we resolve them to Ty.  At
+  // the end of the loop, if there is anything to resolve to Ty, it will be in
+  // this variable.
+  OpaqueType *TypeToResolve = 0;
+
+  for (unsigned i = 0; i != UpRefs.size(); ++i) {
+    UR_OUT("  UR#" << i << " - TypeContains(" << Ty->getDescription() << ", "
+           << UpRefs[i].second->getDescription() << ") = "
+           << (TypeContains(Ty, UpRefs[i].second) ? "true" : "false") << "\n");
+    if (TypeContains(Ty, UpRefs[i].LastContainedTy)) {
+      // Decrement level of upreference
+      unsigned Level = --UpRefs[i].NestingLevel;
+      UpRefs[i].LastContainedTy = Ty;
+      UR_OUT("  Uplevel Ref Level = " << Level << "\n");
+      if (Level == 0) {                     // Upreference should be resolved!
+        if (!TypeToResolve) {
+          TypeToResolve = UpRefs[i].UpRefTy;
+        } else {
+          UR_OUT("  * Resolving upreference for "
+                 << UpRefs[i].second->getDescription() << "\n";
+                 std::string OldName = UpRefs[i].UpRefTy->getDescription());
+          UpRefs[i].UpRefTy->refineAbstractTypeTo(TypeToResolve);
+          UR_OUT("  * Type '" << OldName << "' refined upreference to: "
+                 << (const void*)Ty << ", " << Ty->getDescription() << "\n");
+        }
+        UpRefs.erase(UpRefs.begin()+i);     // Remove from upreference list...
+        --i;                                // Do not skip the next element...
+      }
+    }
+  }
 
-const char* getCastOpcode(std::string& Source, const Type* SrcTy, 
-                          const Type* DstTy) {
-  unsigned SrcBits = SrcTy->getBitWidth();
-  unsigned DstBits = DstTy->getBitWidth();
-  const char* opcode = "bitcast";
-  // Run through the possibilities ...
-  if (DstTy->isIntegral()) {                        // Casting to integral
-    if (SrcTy->isIntegral()) {                      // Casting from integral
-      if (DstBits < SrcBits)
-        opcode = "trunc";
-      else if (DstBits > SrcBits) {                // its an extension
-        if (SrcTy->isSigned())
-          opcode ="sext";                          // signed -> SEXT
+  if (TypeToResolve) {
+    UR_OUT("  * Resolving upreference for "
+           << UpRefs[i].second->getDescription() << "\n";
+           std::string OldName = TypeToResolve->getDescription());
+    TypeToResolve->refineAbstractTypeTo(Ty);
+  }
+
+  return Ty;
+}
+
+static inline Instruction::TermOps 
+getTermOp(TermOps op) {
+  switch (op) {
+    default           : assert(0 && "Invalid OldTermOp");
+    case RetOp        : return Instruction::Ret;
+    case BrOp         : return Instruction::Br;
+    case SwitchOp     : return Instruction::Switch;
+    case InvokeOp     : return Instruction::Invoke;
+    case UnwindOp     : return Instruction::Unwind;
+    case UnreachableOp: return Instruction::Unreachable;
+  }
+}
+
+static inline Instruction::BinaryOps 
+getBinaryOp(BinaryOps op, const Type *Ty, Signedness Sign) {
+  switch (op) {
+    default     : assert(0 && "Invalid OldBinaryOps");
+    case SetEQ  : 
+    case SetNE  : 
+    case SetLE  :
+    case SetGE  :
+    case SetLT  :
+    case SetGT  : assert(0 && "Should use getCompareOp");
+    case AddOp  : return Instruction::Add;
+    case SubOp  : return Instruction::Sub;
+    case MulOp  : return Instruction::Mul;
+    case DivOp  : {
+      // This is an obsolete instruction so we must upgrade it based on the
+      // types of its operands.
+      bool isFP = Ty->isFloatingPoint();
+      if (const PackedType* PTy = dyn_cast(Ty))
+        // If its a packed type we want to use the element type
+        isFP = PTy->getElementType()->isFloatingPoint();
+      if (isFP)
+        return Instruction::FDiv;
+      else if (Sign == Signed)
+        return Instruction::SDiv;
+      return Instruction::UDiv;
+    }
+    case UDivOp : return Instruction::UDiv;
+    case SDivOp : return Instruction::SDiv;
+    case FDivOp : return Instruction::FDiv;
+    case RemOp  : {
+      // This is an obsolete instruction so we must upgrade it based on the
+      // types of its operands.
+      bool isFP = Ty->isFloatingPoint();
+      if (const PackedType* PTy = dyn_cast(Ty))
+        // If its a packed type we want to use the element type
+        isFP = PTy->getElementType()->isFloatingPoint();
+      // Select correct opcode
+      if (isFP)
+        return Instruction::FRem;
+      else if (Sign == Signed)
+        return Instruction::SRem;
+      return Instruction::URem;
+    }
+    case URemOp : return Instruction::URem;
+    case SRemOp : return Instruction::SRem;
+    case FRemOp : return Instruction::FRem;
+    case AndOp  : return Instruction::And;
+    case OrOp   : return Instruction::Or;
+    case XorOp  : return Instruction::Xor;
+  }
+}
+
+static inline Instruction::OtherOps 
+getCompareOp(BinaryOps op, unsigned short &predicate, const Type* &Ty,
+             Signedness Sign) {
+  bool isSigned = Sign == Signed;
+  bool isFP = Ty->isFloatingPoint();
+  switch (op) {
+    default     : assert(0 && "Invalid OldSetCC");
+    case SetEQ  : 
+      if (isFP) {
+        predicate = FCmpInst::FCMP_OEQ;
+        return Instruction::FCmp;
+      } else {
+        predicate = ICmpInst::ICMP_EQ;
+        return Instruction::ICmp;
+      }
+    case SetNE  : 
+      if (isFP) {
+        predicate = FCmpInst::FCMP_UNE;
+        return Instruction::FCmp;
+      } else {
+        predicate = ICmpInst::ICMP_NE;
+        return Instruction::ICmp;
+      }
+    case SetLE  : 
+      if (isFP) {
+        predicate = FCmpInst::FCMP_OLE;
+        return Instruction::FCmp;
+      } else {
+        if (isSigned)
+          predicate = ICmpInst::ICMP_SLE;
         else
-          opcode = "zext";                         // unsigned -> ZEXT
+          predicate = ICmpInst::ICMP_ULE;
+        return Instruction::ICmp;
+      }
+    case SetGE  : 
+      if (isFP) {
+        predicate = FCmpInst::FCMP_OGE;
+        return Instruction::FCmp;
       } else {
-        opcode = "bitcast";                        // Same size, No-op cast
+        if (isSigned)
+          predicate = ICmpInst::ICMP_SGE;
+        else
+          predicate = ICmpInst::ICMP_UGE;
+        return Instruction::ICmp;
+      }
+    case SetLT  : 
+      if (isFP) {
+        predicate = FCmpInst::FCMP_OLT;
+        return Instruction::FCmp;
+      } else {
+        if (isSigned)
+          predicate = ICmpInst::ICMP_SLT;
+        else
+          predicate = ICmpInst::ICMP_ULT;
+        return Instruction::ICmp;
+      }
+    case SetGT  : 
+      if (isFP) {
+        predicate = FCmpInst::FCMP_OGT;
+        return Instruction::FCmp;
+      } else {
+        if (isSigned)
+          predicate = ICmpInst::ICMP_SGT;
+        else
+          predicate = ICmpInst::ICMP_UGT;
+        return Instruction::ICmp;
       }
-    } else if (SrcTy->isFloatingPoint()) {          // Casting from floating pt
-      if (DstTy->isSigned()) 
-        opcode = "fptosi";                         // FP -> sint
-      else
-        opcode = "fptoui";                         // FP -> uint 
-    } else if (SrcTy->isPacked()) {
-      assert(DstBits == SrcTy->getBitWidth() &&
-               "Casting packed to integer of different width");
-        opcode = "bitcast";                        // same size, no-op cast
-    } else {
-      assert(SrcTy->isPointer() &&
-             "Casting from a value that is not first-class type");
-      opcode = "ptrtoint";                         // ptr -> int
-    }
-  } else if (DstTy->isFloatingPoint()) {           // Casting to floating pt
-    if (SrcTy->isIntegral()) {                     // Casting from integral
-      if (SrcTy->isSigned())
-        opcode = "sitofp";                         // sint -> FP
-      else
-        opcode = "uitofp";                         // uint -> FP
-    } else if (SrcTy->isFloatingPoint()) {         // Casting from floating pt
-      if (DstBits < SrcBits) {
-        opcode = "fptrunc";                        // FP -> smaller FP
-      } else if (DstBits > SrcBits) {
-        opcode = "fpext";                          // FP -> larger FP
-      } else  {
-        opcode ="bitcast";                         // same size, no-op cast
-      }
-    } else if (SrcTy->isPacked()) {
-      assert(DstBits == SrcTy->getBitWidth() &&
-             "Casting packed to floating point of different width");
-        opcode = "bitcast";                        // same size, no-op cast
-    } else {
-      assert(0 && "Casting pointer or non-first class to float");
-    }
-  } else if (DstTy->isPacked()) {
-    if (SrcTy->isPacked()) {
-      assert(DstTy->getBitWidth() == SrcTy->getBitWidth() &&
-             "Casting packed to packed of different widths");
-      opcode = "bitcast";                          // packed -> packed
-    } else if (DstTy->getBitWidth() == SrcBits) {
-      opcode = "bitcast";                          // float/int -> packed
-    } else {
-      assert(!"Illegal cast to packed (wrong type or size)");
-    }
-  } else if (DstTy->isPointer()) {
-    if (SrcTy->isPointer()) {
-      opcode = "bitcast";                          // ptr -> ptr
-    } else if (SrcTy->isIntegral()) {
-      opcode = "inttoptr";                         // int -> ptr
-    } else {
-      assert(!"Casting invalid type to pointer");
-    }
-  } else {
-    assert(!"Casting to type that is not first-class");
   }
-  return opcode;
 }
 
-std::string getCastUpgrade(const std::string& Src, const Type* SrcTy,
-                           const Type* DstTy, bool isConst) {
-  std::string Result;
-  std::string Source = Src;
-  if (SrcTy->isFloatingPoint() && DstTy->isPointer()) {
-    // fp -> ptr cast is no longer supported but we must upgrade this
-    // by doing a double cast: fp -> int -> ptr
-    if (isConst)
-      Source = "i64 fptoui(" + Source + " to i64)";
-    else {
-      *O << "    %cast_upgrade" << UniqueNameCounter << " = fptoui " 
-         << Source << " to i64\n";
-      Source = "i64 %cast_upgrade" + llvm::utostr(UniqueNameCounter++);
-    }
-    // Update the SrcTy for the getCastOpcode call below
-    SrcTy = Type::get("i64", ULongTy);
-  } else if (DstTy->isBool()) {
-    // cast type %x to bool was previously defined as setne type %x, null
-    // The cast semantic is now to truncate, not compare so we must retain
-    // the original intent by replacing the cast with a setne
-    const char* comparator = SrcTy->isPointer() ? ", null" : 
-      (SrcTy->isFloatingPoint() ? ", 0.0" : 
-       (SrcTy->isBool() ? ", false" : ", 0"));
-    const char* compareOp = SrcTy->isFloatingPoint() ? "fcmp one " : "icmp ne ";
-    if (isConst) { 
-      Result = "(" + Source + comparator + ")";
-      Result = compareOp + Result;
-    } else
-      Result = compareOp + Source + comparator;
-    return Result; // skip cast processing below
+static inline Instruction::MemoryOps getMemoryOp(MemoryOps op) {
+  switch (op) {
+    default              : assert(0 && "Invalid OldMemoryOps");
+    case MallocOp        : return Instruction::Malloc;
+    case FreeOp          : return Instruction::Free;
+    case AllocaOp        : return Instruction::Alloca;
+    case LoadOp          : return Instruction::Load;
+    case StoreOp         : return Instruction::Store;
+    case GetElementPtrOp : return Instruction::GetElementPtr;
   }
-  SrcTy = SrcTy->resolve();
-  DstTy = DstTy->resolve();
-  std::string Opcode(getCastOpcode(Source, SrcTy, DstTy));
-  if (isConst)
-    Result += Opcode + "( " + Source + " to " + DstTy->getNewTy() + ")";
-  else
-    Result += Opcode + " " + Source + " to " + DstTy->getNewTy();
-  return Result;
 }
 
-const char* getDivRemOpcode(const std::string& opcode, const Type* TI) {
-  const char* op = opcode.c_str();
-  const Type* Ty = TI->resolve();
-  if (Ty->isPacked())
-    Ty = Ty->getElementType();
-  if (opcode == "div")
-    if (Ty->isFloatingPoint())
-      op = "fdiv";
-    else if (Ty->isUnsigned())
-      op = "udiv";
-    else if (Ty->isSigned())
-      op = "sdiv";
-    else
-      yyerror("Invalid type for div instruction");
-  else if (opcode == "rem")
-    if (Ty->isFloatingPoint())
-      op = "frem";
-    else if (Ty->isUnsigned())
-      op = "urem";
-    else if (Ty->isSigned())
-      op = "srem";
-    else
-      yyerror("Invalid type for rem instruction");
-  return op;
-}
-
-std::string getCompareOp(const std::string& setcc, const Type* TI) {
-  assert(setcc.length() == 5);
-  char cc1 = setcc[3];
-  char cc2 = setcc[4];
-  assert(cc1 == 'e' || cc1 == 'n' || cc1 == 'l' || cc1 == 'g');
-  assert(cc2 == 'q' || cc2 == 'e' || cc2 == 'e' || cc2 == 't');
-  std::string result("xcmp xxx");
-  result[6] = cc1;
-  result[7] = cc2;
-  if (TI->isFloatingPoint()) {
-    result[0] = 'f';
-    result[5] = 'o';
-    if (cc1 == 'n')
-      result[5] = 'u'; // NE maps to unordered
-    else
-      result[5] = 'o'; // everything else maps to ordered
-  } else if (TI->isIntegral() || TI->isPointer()) {
-    result[0] = 'i';
-    if ((cc1 == 'e' && cc2 == 'q') || (cc1 == 'n' && cc2 == 'e'))
-      result.erase(5,1);
-    else if (TI->isSigned())
-      result[5] = 's';
-    else if (TI->isUnsigned() || TI->isPointer() || TI->isBool())
-      result[5] = 'u';
-    else
-      yyerror("Invalid integral type for setcc");
-  }
-  return result;
+static inline Instruction::OtherOps 
+getOtherOp(OtherOps op, Signedness Sign) {
+  switch (op) {
+    default               : assert(0 && "Invalid OldOtherOps");
+    case PHIOp            : return Instruction::PHI;
+    case CallOp           : return Instruction::Call;
+    case ShlOp            : return Instruction::Shl;
+    case ShrOp            : 
+      if (Sign == Signed)
+        return Instruction::AShr;
+      return Instruction::LShr;
+    case SelectOp         : return Instruction::Select;
+    case UserOp1          : return Instruction::UserOp1;
+    case UserOp2          : return Instruction::UserOp2;
+    case VAArg            : return Instruction::VAArg;
+    case ExtractElementOp : return Instruction::ExtractElement;
+    case InsertElementOp  : return Instruction::InsertElement;
+    case ShuffleVectorOp  : return Instruction::ShuffleVector;
+    case ICmpOp           : return Instruction::ICmp;
+    case FCmpOp           : return Instruction::FCmp;
+    case LShrOp           : return Instruction::LShr;
+    case AShrOp           : return Instruction::AShr;
+  };
 }
 
-const Type* getFunctionReturnType(const Type* PFTy) {
-  PFTy = PFTy->resolve();
-  if (PFTy->isPointer()) {
-    const Type* ElemTy = PFTy->getElementType();
-    ElemTy = ElemTy->resolve();
-    if (ElemTy->isFunction())
-      return ElemTy->getResultType();
-  } else if (PFTy->isFunction()) {
-    return PFTy->getResultType();
-  }
-  return PFTy;
-}
-
-const Type* ResolveUpReference(const Type* Ty, 
-                                   Type::UpRefStack* stack) {
-  assert(Ty->isUpReference() && "Can't resolve a non-upreference");
-  unsigned upref = Ty->getUpRefNum();
-  assert(upref < stack->size() && "Invalid up reference");
-  return (*stack)[upref - stack->size() - 1];
-}
-
-const Type* getGEPIndexedType(const Type* PTy, ValueList* idxs) {
-  const Type* Result = PTy = PTy->resolve();
-  assert(PTy->isPointer() && "GEP Operand is not a pointer?");
-  Type::UpRefStack stack;
-  for (unsigned i = 0; i < idxs->size(); ++i) {
-    if (Result->isComposite()) {
-      Result = Result->getIndexedType((*idxs)[i]);
-      Result = Result->resolve();
-      stack.push_back(Result);
-    } else
-      yyerror("Invalid type for index");
-  }
-  // Resolve upreferences so we can return a more natural type
-  if (Result->isPointer()) {
-    if (Result->getElementType()->isUpReference()) {
-      stack.push_back(Result);
-      Result = ResolveUpReference(Result->getElementType(), &stack);
+static inline Value*
+getCast(CastOps op, Value *Src, Signedness SrcSign, const Type *DstTy, 
+        Signedness DstSign, bool ForceInstruction = false) {
+  Instruction::CastOps Opcode;
+  const Type* SrcTy = Src->getType();
+  if (op == CastOp) {
+    if (SrcTy->isFloatingPoint() && isa(DstTy)) {
+      // fp -> ptr cast is no longer supported but we must upgrade this
+      // by doing a double cast: fp -> int -> ptr
+      SrcTy = Type::Int64Ty;
+      Opcode = Instruction::IntToPtr;
+      if (isa(Src)) {
+        Src = ConstantExpr::getCast(Instruction::FPToUI, 
+                                     cast(Src), SrcTy);
+      } else {
+        std::string NewName(makeNameUnique(Src->getName()));
+        Src = new FPToUIInst(Src, SrcTy, NewName, CurBB);
+      }
+    } else if (isa(DstTy) &&
+               cast(DstTy)->getBitWidth() == 1) {
+      // cast type %x to bool was previously defined as setne type %x, null
+      // The cast semantic is now to truncate, not compare so we must retain
+      // the original intent by replacing the cast with a setne
+      Constant* Null = Constant::getNullValue(SrcTy);
+      Instruction::OtherOps Opcode = Instruction::ICmp;
+      unsigned short predicate = ICmpInst::ICMP_NE;
+      if (SrcTy->isFloatingPoint()) {
+        Opcode = Instruction::FCmp;
+        predicate = FCmpInst::FCMP_ONE;
+      } else if (!SrcTy->isInteger() && !isa(SrcTy)) {
+        error("Invalid cast to bool");
+      }
+      if (isa(Src) && !ForceInstruction)
+        return ConstantExpr::getCompare(predicate, cast(Src), Null);
+      else
+        return CmpInst::create(Opcode, predicate, Src, Null);
+    }
+    // Determine the opcode to use by calling CastInst::getCastOpcode
+    Opcode = 
+      CastInst::getCastOpcode(Src, SrcSign == Signed, DstTy, DstSign == Signed);
+
+  } else switch (op) {
+    default: assert(0 && "Invalid cast token");
+    case TruncOp:    Opcode = Instruction::Trunc; break;
+    case ZExtOp:     Opcode = Instruction::ZExt; break;
+    case SExtOp:     Opcode = Instruction::SExt; break;
+    case FPTruncOp:  Opcode = Instruction::FPTrunc; break;
+    case FPExtOp:    Opcode = Instruction::FPExt; break;
+    case FPToUIOp:   Opcode = Instruction::FPToUI; break;
+    case FPToSIOp:   Opcode = Instruction::FPToSI; break;
+    case UIToFPOp:   Opcode = Instruction::UIToFP; break;
+    case SIToFPOp:   Opcode = Instruction::SIToFP; break;
+    case PtrToIntOp: Opcode = Instruction::PtrToInt; break;
+    case IntToPtrOp: Opcode = Instruction::IntToPtr; break;
+    case BitCastOp:  Opcode = Instruction::BitCast; break;
+  }
+
+  if (isa(Src) && !ForceInstruction)
+    return ConstantExpr::getCast(Opcode, cast(Src), DstTy);
+  return CastInst::create(Opcode, Src, DstTy);
+}
+
+static Instruction *
+upgradeIntrinsicCall(const Type* RetTy, const ValID &ID, 
+                     std::vector& Args) {
+
+  std::string Name = ID.Type == ValID::NameVal ? ID.Name : "";
+  if (Name == "llvm.isunordered.f32" || Name == "llvm.isunordered.f64") {
+    if (Args.size() != 2)
+      error("Invalid prototype for " + Name + " prototype");
+    return new FCmpInst(FCmpInst::FCMP_UNO, Args[0], Args[1]);
+  } else {
+    static unsigned upgradeCount = 1;
+    const Type* PtrTy = PointerType::get(Type::Int8Ty);
+    std::vector Params;
+    if (Name == "llvm.va_start" || Name == "llvm.va_end") {
+      if (Args.size() != 1)
+        error("Invalid prototype for " + Name + " prototype");
+      Params.push_back(PtrTy);
+      const FunctionType *FTy = FunctionType::get(Type::VoidTy, Params, false);
+      const PointerType *PFTy = PointerType::get(FTy);
+      Value* Func = getVal(PFTy, ID);
+      std::string InstName("va_upgrade");
+      InstName += llvm::utostr(upgradeCount++);
+      Args[0] = new BitCastInst(Args[0], PtrTy, InstName, CurBB);
+      return new CallInst(Func, Args);
+    } else if (Name == "llvm.va_copy") {
+      if (Args.size() != 2)
+        error("Invalid prototype for " + Name + " prototype");
+      Params.push_back(PtrTy);
+      Params.push_back(PtrTy);
+      const FunctionType *FTy = FunctionType::get(Type::VoidTy, Params, false);
+      const PointerType *PFTy = PointerType::get(FTy);
+      Value* Func = getVal(PFTy, ID);
+      std::string InstName0("va_upgrade");
+      InstName0 += llvm::utostr(upgradeCount++);
+      std::string InstName1("va_upgrade");
+      InstName1 += llvm::utostr(upgradeCount++);
+      Args[0] = new BitCastInst(Args[0], PtrTy, InstName0, CurBB);
+      Args[1] = new BitCastInst(Args[1], PtrTy, InstName1, CurBB);
+      return new CallInst(Func, Args);
     }
-  } else if (Result->isUpReference()) {
-    Result = ResolveUpReference(Result->getElementType(), &stack);
   }
-  return Result->getPointerType();
+  return 0;
 }
 
-// This function handles appending .u or .s to integer value names that
-// were previously unsigned or signed, respectively. This avoids name
-// collisions since the unsigned and signed type planes have collapsed
-// into a single signless type plane.
-std::string getUniqueName(const std::string *Name, const Type* Ty,
-                          bool isGlobal = false, bool isDef = false) {
+const Type* upgradeGEPIndices(const Type* PTy, 
+                       std::vector *Indices, 
+                       std::vector    &VIndices, 
+                       std::vector *CIndices = 0) {
+  // Traverse the indices with a gep_type_iterator so we can build the list
+  // of constant and value indices for use later. Also perform upgrades
+  VIndices.clear();
+  if (CIndices) CIndices->clear();
+  for (unsigned i = 0, e = Indices->size(); i != e; ++i)
+    VIndices.push_back((*Indices)[i].V);
+  generic_gep_type_iterator::iterator>
+    GTI = gep_type_begin(PTy, VIndices.begin(),  VIndices.end()),
+    GTE = gep_type_end(PTy,  VIndices.begin(),  VIndices.end());
+  for (unsigned i = 0, e = Indices->size(); i != e && GTI != GTE; ++i, ++GTI) {
+    Value *Index = VIndices[i];
+    if (CIndices && !isa(Index))
+      error("Indices to constant getelementptr must be constants");
+    // LLVM 1.2 and earlier used ubyte struct indices.  Convert any ubyte 
+    // struct indices to i32 struct indices with ZExt for compatibility.
+    else if (isa(*GTI)) {        // Only change struct indices
+      if (ConstantInt *CUI = dyn_cast(Index))
+        if (CUI->getType()->getBitWidth() == 8)
+          Index = 
+            ConstantExpr::getCast(Instruction::ZExt, CUI, Type::Int32Ty);
+    } else {
+      // Make sure that unsigned SequentialType indices are zext'd to 
+      // 64-bits if they were smaller than that because LLVM 2.0 will sext 
+      // all indices for SequentialType elements. We must retain the same 
+      // semantic (zext) for unsigned types.
+      if (const IntegerType *Ity = dyn_cast(Index->getType()))
+        if (Ity->getBitWidth() < 64 && (*Indices)[i].S == Unsigned)
+          if (CIndices)
+            Index = ConstantExpr::getCast(Instruction::ZExt, 
+              cast(Index), Type::Int64Ty);
+          else
+            Index = CastInst::create(Instruction::ZExt, Index, Type::Int64Ty,
+              "gep_upgrade", CurBB);
+    }
+    // Add to the CIndices list, if requested.
+    if (CIndices)
+      CIndices->push_back(cast(Index));
+  }
+
+  const Type *IdxTy =
+    GetElementPtrInst::getIndexedType(PTy, VIndices, true);
+    if (!IdxTy)
+      error("Index list invalid for constant getelementptr");
+  return IdxTy;
+}
 
-  // If its not a symbolic name, don't modify it, probably a constant val.
-  if ((*Name)[0] != '%' && (*Name)[0] != '"')
-    return *Name;
+Module* UpgradeAssembly(const std::string &infile, std::istream& in, 
+                              bool debug, bool addAttrs)
+{
+  Upgradelineno = 1; 
+  CurFilename = infile;
+  LexInput = ∈
+  yydebug = debug;
+  AddAttributes = addAttrs;
+  ObsoleteVarArgs = false;
+  NewVarArgs = false;
 
-  // If its a numeric reference, just leave it alone.
-  if (isdigit((*Name)[1]))
-    return *Name;
+  CurModule.CurrentModule = new Module(CurFilename);
 
-  // Resolve the type
-  Ty = Ty->resolve(); 
+  // Check to make sure the parser succeeded
+  if (yyparse()) {
+    if (ParserResult)
+      delete ParserResult;
+    std::cerr << "llvm-upgrade: parse failed.\n";
+    return 0;
+  }
 
-  // If its a global name, get its uniquified name, if any
-  Type::GlobalsTypeMap::iterator GI = Type::Globals.find(*Name);
-  if (GI != Type::Globals.end()) {
-    Type::TypePlaneMap::iterator TPI = GI->second.begin();
-    Type::TypePlaneMap::iterator TPE = GI->second.end();
-    for ( ; TPI != TPE ; ++TPI) {
-      if (TPI->first->sameNewTyAs(Ty)) 
-        return TPI->second;
-    }
+  // Check to make sure that parsing produced a result
+  if (!ParserResult) {
+    std::cerr << "llvm-upgrade: no parse result.\n";
+    return 0;
   }
 
-  if (isGlobal) {
-    // We didn't find a global name, but if its supposed to be global then all 
-    // we can do is return the name. This is probably a forward reference of a 
-    // global value that hasn't been defined yet. Since we have no definition
-    // we don't know its linkage class. Just assume its an external and the name
-    // shouldn't change.
-    return *Name;
+  // Reset ParserResult variable while saving its value for the result.
+  Module *Result = ParserResult;
+  ParserResult = 0;
+
+  //Not all functions use vaarg, so make a second check for ObsoleteVarArgs
+  {
+    Function* F;
+    if ((F = Result->getNamedFunction("llvm.va_start"))
+        && F->getFunctionType()->getNumParams() == 0)
+      ObsoleteVarArgs = true;
+    if((F = Result->getNamedFunction("llvm.va_copy"))
+       && F->getFunctionType()->getNumParams() == 1)
+      ObsoleteVarArgs = true;
   }
 
-  // Default the result to the current name
-  std::string Result = Ty->makeUniqueName(*Name);
+  if (ObsoleteVarArgs && NewVarArgs) {
+    error("This file is corrupt: it uses both new and old style varargs");
+    return 0;
+  }
 
-  return Result;
-}
+  if(ObsoleteVarArgs) {
+    if(Function* F = Result->getNamedFunction("llvm.va_start")) {
+      if (F->arg_size() != 0) {
+        error("Obsolete va_start takes 0 argument");
+        return 0;
+      }
+      
+      //foo = va_start()
+      // ->
+      //bar = alloca typeof(foo)
+      //va_start(bar)
+      //foo = load bar
+
+      const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID);
+      const Type* ArgTy = F->getFunctionType()->getReturnType();
+      const Type* ArgTyPtr = PointerType::get(ArgTy);
+      Function* NF = cast(Result->getOrInsertFunction(
+        "llvm.va_start", RetTy, ArgTyPtr, (Type *)0));
+
+      while (!F->use_empty()) {
+        CallInst* CI = cast(F->use_back());
+        AllocaInst* bar = new AllocaInst(ArgTy, 0, "vastart.fix.1", CI);
+        new CallInst(NF, bar, "", CI);
+        Value* foo = new LoadInst(bar, "vastart.fix.2", CI);
+        CI->replaceAllUsesWith(foo);
+        CI->getParent()->getInstList().erase(CI);
+      }
+      Result->getFunctionList().erase(F);
+    }
+    
+    if(Function* F = Result->getNamedFunction("llvm.va_end")) {
+      if(F->arg_size() != 1) {
+        error("Obsolete va_end takes 1 argument");
+        return 0;
+      }
 
-std::string getGlobalName(const std::string* Name, const std::string Linkage,
-                          const Type* Ty, bool isConstant) {
-  // Default to given name
-  std::string Result = *Name; 
-  // Look up the name in the Globals Map
-  Type::GlobalsTypeMap::iterator GI = Type::Globals.find(*Name);
-  // Did we see this global name before?
-  if (GI != Type::Globals.end()) {
-    if (Ty->isUnresolvedDeep()) {
-      // The Gval's type is unresolved. Consequently, we can't disambiguate it
-      // by type. We'll just change its name and emit a warning.
-      warning("Cannot disambiguate global value '" + *Name + 
-              "' because type '" + Ty->getNewTy() + "'is unresolved.\n");
-      Result = *Name + ".unique";
-      UniqueNameCounter++;
-      Result += llvm::utostr(UniqueNameCounter);
-      return Result;
-    } else {
-      Type::TypePlaneMap::iterator TPI = GI->second.find(Ty);
-      if (TPI != GI->second.end()) {
-        // We found an existing name of the same old type. This isn't allowed 
-        // in LLVM 2.0. Consequently, we must alter the name of the global so it
-        // can at least compile. References to the global will yield the first
-        // definition, which is okay. We also must warn about this.
-        Result = *Name + ".unique";
-        UniqueNameCounter++;
-        Result += llvm::utostr(UniqueNameCounter);
-        warning(std::string("Global variable '") + *Name + "' was renamed to '"+
-                Result + "'");
-      } else { 
-        // There isn't an existing definition for this name according to the
-        // old types. Now search the TypePlanMap for types with the same new
-        // name. 
-        Type::TypePlaneMap::iterator TPI = GI->second.begin();
-        Type::TypePlaneMap::iterator TPE = GI->second.end();
-        for ( ; TPI != TPE; ++TPI) {
-          if (TPI->first->sameNewTyAs(Ty)) {
-            // The new types are the same but the old types are different so 
-            // this is a global name collision resulting from type planes 
-            // collapsing. 
-            if (Linkage == "external" || Linkage == "dllimport" || 
-                Linkage == "extern_weak" || Linkage == "") {
-              // The linkage of this gval is external so we can't reliably 
-              // rename it because it could potentially create a linking 
-              // problem.  However, we can't leave the name conflict in the 
-              // output either or it won't assemble with LLVM 2.0.  So, all we 
-              // can do is rename this one to something unique and emit a 
-              // warning about the problem.
-              Result = *Name + ".unique";
-              UniqueNameCounter++;
-              Result += llvm::utostr(UniqueNameCounter);
-              warning("Renaming global value '" + *Name + "' to '" + Result + 
-                      "' may cause linkage errors.");
-              return Result;
-            } else {
-              // Its linkage is internal and its type is known so we can 
-              // disambiguate the name collision successfully based on the type.
-              Result = getUniqueName(Name, Ty);
-              TPI->second = Result;
-              return Result;
-            }
-          }
-        }
-        // We didn't find an entry in the type plane with the same new type and
-        // the old types differ so this is a new type plane for this global 
-        // variable. We just fall through to the logic below which inserts
-        // the global.
+      //vaend foo
+      // ->
+      //bar = alloca 1 of typeof(foo)
+      //vaend bar
+      const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID);
+      const Type* ArgTy = F->getFunctionType()->getParamType(0);
+      const Type* ArgTyPtr = PointerType::get(ArgTy);
+      Function* NF = cast(Result->getOrInsertFunction(
+        "llvm.va_end", RetTy, ArgTyPtr, (Type *)0));
+
+      while (!F->use_empty()) {
+        CallInst* CI = cast(F->use_back());
+        AllocaInst* bar = new AllocaInst(ArgTy, 0, "vaend.fix.1", CI);
+        new StoreInst(CI->getOperand(1), bar, CI);
+        new CallInst(NF, bar, "", CI);
+        CI->getParent()->getInstList().erase(CI);
       }
+      Result->getFunctionList().erase(F);
     }
-  }
 
-  // Its a new global name, if it is external we can't change it
-  if (isConstant || Linkage == "external" || Linkage == "dllimport" || 
-      Linkage == "extern_weak" || Linkage == "") {
-    Type::Globals[Result][Ty] = Result;
-    return Result;
+    if(Function* F = Result->getNamedFunction("llvm.va_copy")) {
+      if(F->arg_size() != 1) {
+        error("Obsolete va_copy takes 1 argument");
+        return 0;
+      }
+      //foo = vacopy(bar)
+      // ->
+      //a = alloca 1 of typeof(foo)
+      //b = alloca 1 of typeof(foo)
+      //store bar -> b
+      //vacopy(a, b)
+      //foo = load a
+      
+      const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID);
+      const Type* ArgTy = F->getFunctionType()->getReturnType();
+      const Type* ArgTyPtr = PointerType::get(ArgTy);
+      Function* NF = cast(Result->getOrInsertFunction(
+        "llvm.va_copy", RetTy, ArgTyPtr, ArgTyPtr, (Type *)0));
+
+      while (!F->use_empty()) {
+        CallInst* CI = cast(F->use_back());
+        AllocaInst* a = new AllocaInst(ArgTy, 0, "vacopy.fix.1", CI);
+        AllocaInst* b = new AllocaInst(ArgTy, 0, "vacopy.fix.2", CI);
+        new StoreInst(CI->getOperand(1), b, CI);
+        new CallInst(NF, a, b, "", CI);
+        Value* foo = new LoadInst(a, "vacopy.fix.3", CI);
+        CI->replaceAllUsesWith(foo);
+        CI->getParent()->getInstList().erase(CI);
+      }
+      Result->getFunctionList().erase(F);
+    }
   }
 
-  // Its a new global name, and it is internal, change the name to make it
-  // unique for its type.
-  // Result = getUniqueName(Name, Ty);
-  Type::Globals[*Name][Ty] = Result;
   return Result;
 }
 
-} // End anonymous namespace
+} // end llvm namespace
 
-// This function is used by the Lexer to create a Type. It can't be
-// in the anonymous namespace.
-const Type* getType(const std::string& newTy, TypeIDs oldTy) {
-  return Type::get(newTy, oldTy);
-}
+using namespace llvm;
 
 %}
 
-// %file-prefix="UpgradeParser"
-
 %union {
-  std::string*    String;
-  const Type*     Ty;
-  Value*          Val;
-  Constant*       Const;
-  ValueList*      ValList;
-  TypeList*       TypeVec;
-}
-
-%token      VOID BOOL SBYTE UBYTE SHORT USHORT INT UINT LONG ULONG
-%token      FLOAT DOUBLE LABEL 
-%token  OPAQUE ESINT64VAL EUINT64VAL SINTVAL UINTVAL FPVAL
-%token  NULL_TOK UNDEF ZEROINITIALIZER TRUETOK FALSETOK
-%token  TYPE VAR_ID LABELSTR STRINGCONSTANT
-%token  IMPLEMENTATION BEGINTOK ENDTOK
-%token  DECLARE GLOBAL CONSTANT SECTION VOLATILE
-%token  TO DOTDOTDOT CONST INTERNAL LINKONCE WEAK 
-%token  DLLIMPORT DLLEXPORT EXTERN_WEAK APPENDING
-%token  EXTERNAL TARGET TRIPLE ENDIAN POINTERSIZE LITTLE BIG
-%token  ALIGN UNINITIALIZED
-%token  DEPLIBS CALL TAIL ASM_TOK MODULE SIDEEFFECT
-%token  CC_TOK CCC_TOK CSRETCC_TOK FASTCC_TOK COLDCC_TOK
-%token  X86_STDCALLCC_TOK X86_FASTCALLCC_TOK
-%token  DATALAYOUT
-%token  RET BR SWITCH INVOKE EXCEPT UNWIND UNREACHABLE
-%token  ADD SUB MUL DIV UDIV SDIV FDIV REM UREM SREM FREM AND OR XOR
-%token  SETLE SETGE SETLT SETGT SETEQ SETNE  // Binary Comparators
-%token  ICMP FCMP EQ NE SLT SGT SLE SGE OEQ ONE OLT OGT OLE OGE 
-%token  ORD UNO UEQ UNE ULT UGT ULE UGE
-%token  MALLOC ALLOCA FREE LOAD STORE GETELEMENTPTR
-%token  PHI_TOK SELECT SHL SHR ASHR LSHR VAARG
-%token  EXTRACTELEMENT INSERTELEMENT SHUFFLEVECTOR
-%token  CAST TRUNC ZEXT SEXT FPTRUNC FPEXT FPTOUI FPTOSI UITOFP SITOFP 
-%token  PTRTOINT INTTOPTR BITCAST
-
-%type  OptAssign OptLinkage OptCallingConv OptAlign OptCAlign 
-%type  SectionString OptSection GlobalVarAttributes GlobalVarAttribute
-%type  ConstExpr DefinitionList
-%type  ConstPool TargetDefinition LibrariesDefinition LibList OptName
-%type  ArgVal ArgListH ArgList FunctionHeaderH BEGIN FunctionHeader END
-%type  Function FunctionProto BasicBlock 
-%type  InstructionList BBTerminatorInst JumpTable Inst
-%type  OptTailCall OptVolatile Unwind
-%type  SymbolicValueRef OptSideEffect GlobalType
-%type  FnDeclareLinkage BasicBlockList BigOrLittle AsmBlock
-%type  Name ConstValueRef ConstVector External
-%type  ShiftOps SetCondOps LogicalOps ArithmeticOps CastOps
-%type  IPredicates FPredicates
-
-%type  ValueRefList ValueRefListE IndexList
-%type  TypeListI ArgTypeListI
-
-%type  IntType SIntType UIntType FPType TypesV Types 
-%type  PrimType UpRTypesV UpRTypes
-
-%type  IntVal EInt64Val 
-%type   ConstVal
+  llvm::Module                           *ModuleVal;
+  llvm::Function                         *FunctionVal;
+  std::pair     *ArgVal;
+  llvm::BasicBlock                       *BasicBlockVal;
+  llvm::TerminatorInst                   *TermInstVal;
+  llvm::InstrInfo                        InstVal;
+  llvm::ConstInfo                        ConstVal;
+  llvm::ValueInfo                        ValueVal;
+  llvm::PATypeInfo                       TypeVal;
+  llvm::TypeInfo                         PrimType;
+  llvm::PHIListInfo                      PHIList;
+  std::list            *TypeList;
+  std::vector           *ValueList;
+  std::vector           *ConstVector;
+
+
+  std::vector > *ArgList;
+  // Represent the RHS of PHI node
+  std::vector > *JumpTable;
+
+  llvm::GlobalValue::LinkageTypes         Linkage;
+  int64_t                           SInt64Val;
+  uint64_t                          UInt64Val;
+  int                               SIntVal;
+  unsigned                          UIntVal;
+  double                            FPVal;
+  bool                              BoolVal;
+
+  char                             *StrVal;   // This memory is strdup'd!
+  llvm::ValID                       ValIDVal; // strdup'd memory maybe!
+
+  llvm::BinaryOps                   BinaryOpVal;
+  llvm::TermOps                     TermOpVal;
+  llvm::MemoryOps                   MemOpVal;
+  llvm::OtherOps                    OtherOpVal;
+  llvm::CastOps                     CastOpVal;
+  llvm::ICmpInst::Predicate         IPred;
+  llvm::FCmpInst::Predicate         FPred;
+  llvm::Module::Endianness          Endianness;
+}
+
+%type      Module FunctionList
+%type    Function FunctionProto FunctionHeader BasicBlockList
+%type  BasicBlock InstructionList
+%type    BBTerminatorInst
+%type        Inst InstVal MemoryInst
+%type       ConstVal ConstExpr
+%type    ConstVector
+%type        ArgList ArgListH
+%type         ArgVal
+%type        PHIList
+%type      ValueRefList ValueRefListE  // For call param lists
+%type      IndexList                   // For GEP derived indices
+%type       TypeListI ArgTypeListI
+%type      JumpTable
+%type        GlobalType                  // GLOBAL or CONSTANT?
+%type        OptVolatile                 // 'volatile' or not
+%type        OptTailCall                 // TAIL CALL or plain CALL.
+%type        OptSideEffect               // 'sideeffect' or not.
+%type        OptLinkage
+%type     BigOrLittle
+
+// ValueRef - Unresolved reference to a definition or BB
+%type       ValueRef ConstValueRef SymbolicValueRef
+%type       ResolvedVal            //   pair
+// Tokens and types for handling constant integer values
+//
+// ESINT64VAL - A negative number within long long range
+%token  ESINT64VAL
 
-%type  ValueRef ResolvedVal InstVal PHIList MemoryInst
+// EUINT64VAL - A positive number within uns. long long range
+%token  EUINT64VAL
+%type   EINT64VAL
+
+%token     SINTVAL   // Signed 32 bit ints...
+%token     UINTVAL   // Unsigned 32 bit ints...
+%type      INTVAL
+%token       FPVAL     // Float or Double constant
+
+// Built in types...
+%type   Types TypesV UpRTypes UpRTypesV
+%type   SIntType UIntType IntType FPType PrimType // Classifications
+%token  VOID BOOL SBYTE UBYTE SHORT USHORT INT UINT LONG ULONG
+%token  FLOAT DOUBLE TYPE LABEL
+
+%token  VAR_ID LABELSTR STRINGCONSTANT
+%type   Name OptName OptAssign
+%type   OptAlign OptCAlign
+%type  OptSection SectionString
+
+%token IMPLEMENTATION ZEROINITIALIZER TRUETOK FALSETOK BEGINTOK ENDTOK
+%token DECLARE GLOBAL CONSTANT SECTION VOLATILE
+%token TO DOTDOTDOT NULL_TOK UNDEF CONST INTERNAL LINKONCE WEAK APPENDING
+%token DLLIMPORT DLLEXPORT EXTERN_WEAK
+%token OPAQUE NOT EXTERNAL TARGET TRIPLE ENDIAN POINTERSIZE LITTLE BIG ALIGN
+%token DEPLIBS CALL TAIL ASM_TOK MODULE SIDEEFFECT
+%token CC_TOK CCC_TOK CSRETCC_TOK FASTCC_TOK COLDCC_TOK
+%token X86_STDCALLCC_TOK X86_FASTCALLCC_TOK
+%token DATALAYOUT
+%type  OptCallingConv
+
+// Basic Block Terminating Operators
+%token  RET BR SWITCH INVOKE UNREACHABLE
+%token UNWIND EXCEPT
+
+// Binary Operators
+%type   ArithmeticOps LogicalOps SetCondOps // Binops Subcatagories
+%token  ADD SUB MUL DIV UDIV SDIV FDIV REM UREM SREM FREM 
+%token  AND OR XOR
+%token  SETLE SETGE SETLT SETGT SETEQ SETNE  // Binary Comparators
+%token  ICMP FCMP
+
+// Memory Instructions
+%token  MALLOC ALLOCA FREE LOAD STORE GETELEMENTPTR
+
+// Other Operators
+%type   ShiftOps
+%token  PHI_TOK SELECT SHL SHR ASHR LSHR VAARG
+%token  EXTRACTELEMENT INSERTELEMENT SHUFFLEVECTOR
+%token VAARG_old VANEXT_old //OBSOLETE
+
+%type   IPredicates
+%type   FPredicates
+%token  EQ NE SLT SGT SLE SGE ULT UGT ULE UGE 
+%token  OEQ ONE OLT OGT OLE OGE ORD UNO UEQ UNE
+
+%token  CAST TRUNC ZEXT SEXT FPTRUNC FPEXT FPTOUI FPTOSI 
+%token  UITOFP SITOFP PTRTOINT INTTOPTR BITCAST 
+%type   CastOps
 
 %start Module
 
 %%
 
 // Handle constant integer size restriction and conversion...
-IntVal : SINTVAL | UINTVAL ;
-EInt64Val : ESINT64VAL | EUINT64VAL;
+//
+INTVAL 
+  : SINTVAL;
+  | UINTVAL {
+    if ($1 > (uint32_t)INT32_MAX)     // Outside of my range!
+      error("Value too large for type");
+    $$ = (int32_t)$1;
+  }
+  ;
+
+EINT64VAL 
+  : ESINT64VAL;      // These have same type and can't cause problems...
+  | EUINT64VAL {
+    if ($1 > (uint64_t)INT64_MAX)     // Outside of my range!
+      error("Value too large for type");
+    $$ = (int64_t)$1;
+  };
 
 // Operations that are notably excluded from this list include:
 // RET, BR, & SWITCH because they end basic blocks and are treated specially.
-ArithmeticOps: ADD | SUB | MUL | DIV | UDIV | SDIV | FDIV 
-             | REM | UREM | SREM | FREM;
-LogicalOps   : AND | OR | XOR;
-SetCondOps   : SETLE | SETGE | SETLT | SETGT | SETEQ | SETNE;
-IPredicates  : EQ | NE | SLT | SGT | SLE | SGE | ULT | UGT | ULE | UGE;
-FPredicates  : OEQ | ONE | OLT | OGT | OLE | OGE | ORD | UNO | UEQ | UNE
-             | ULT | UGT | ULE | UGE | TRUETOK | FALSETOK;
-ShiftOps     : SHL | SHR | ASHR | LSHR;
-CastOps      : TRUNC | ZEXT | SEXT | FPTRUNC | FPEXT | FPTOUI | FPTOSI | 
-               UITOFP | SITOFP | PTRTOINT | INTTOPTR | BITCAST | CAST
-             ;
+//
+ArithmeticOps
+  : ADD | SUB | MUL | DIV | UDIV | SDIV | FDIV | REM | UREM | SREM | FREM
+  ;
+
+LogicalOps   
+  : AND | OR | XOR
+  ;
+
+SetCondOps   
+  : SETLE | SETGE | SETLT | SETGT | SETEQ | SETNE
+  ;
+
+IPredicates  
+  : EQ   { $$ = ICmpInst::ICMP_EQ; }  | NE   { $$ = ICmpInst::ICMP_NE; }
+  | SLT  { $$ = ICmpInst::ICMP_SLT; } | SGT  { $$ = ICmpInst::ICMP_SGT; }
+  | SLE  { $$ = ICmpInst::ICMP_SLE; } | SGE  { $$ = ICmpInst::ICMP_SGE; }
+  | ULT  { $$ = ICmpInst::ICMP_ULT; } | UGT  { $$ = ICmpInst::ICMP_UGT; }
+  | ULE  { $$ = ICmpInst::ICMP_ULE; } | UGE  { $$ = ICmpInst::ICMP_UGE; } 
+  ;
+
+FPredicates  
+  : OEQ  { $$ = FCmpInst::FCMP_OEQ; } | ONE  { $$ = FCmpInst::FCMP_ONE; }
+  | OLT  { $$ = FCmpInst::FCMP_OLT; } | OGT  { $$ = FCmpInst::FCMP_OGT; }
+  | OLE  { $$ = FCmpInst::FCMP_OLE; } | OGE  { $$ = FCmpInst::FCMP_OGE; }
+  | ORD  { $$ = FCmpInst::FCMP_ORD; } | UNO  { $$ = FCmpInst::FCMP_UNO; }
+  | UEQ  { $$ = FCmpInst::FCMP_UEQ; } | UNE  { $$ = FCmpInst::FCMP_UNE; }
+  | ULT  { $$ = FCmpInst::FCMP_ULT; } | UGT  { $$ = FCmpInst::FCMP_UGT; }
+  | ULE  { $$ = FCmpInst::FCMP_ULE; } | UGE  { $$ = FCmpInst::FCMP_UGE; }
+  | TRUETOK { $$ = FCmpInst::FCMP_TRUE; }
+  | FALSETOK { $$ = FCmpInst::FCMP_FALSE; }
+  ;
+ShiftOps  
+  : SHL | SHR | ASHR | LSHR
+  ;
+
+CastOps      
+  : TRUNC | ZEXT | SEXT | FPTRUNC | FPEXT | FPTOUI | FPTOSI 
+  | UITOFP | SITOFP | PTRTOINT | INTTOPTR | BITCAST | CAST
+  ;
 
 // These are some types that allow classification if we only want a particular 
 // thing... for example, only a signed, unsigned, or integral type.
-SIntType :  LONG |  INT |  SHORT | SBYTE;
-UIntType : ULONG | UINT | USHORT | UBYTE;
-IntType  : SIntType | UIntType;
-FPType   : FLOAT | DOUBLE;
+SIntType 
+  :  LONG |  INT |  SHORT | SBYTE
+  ;
+
+UIntType 
+  : ULONG | UINT | USHORT | UBYTE
+  ;
+
+IntType  
+  : SIntType | UIntType
+  ;
+
+FPType   
+  : FLOAT | DOUBLE
+  ;
 
 // OptAssign - Value producing statements have an optional assignment component
-OptAssign : Name '=' {
+OptAssign 
+  : Name '=' {
     $$ = $1;
   }
   | /*empty*/ {
-    $$ = new std::string(""); 
+    $$ = 0;
   };
 
 OptLinkage 
-  : INTERNAL | LINKONCE | WEAK | APPENDING | DLLIMPORT | DLLEXPORT 
-  | EXTERN_WEAK 
-  | /*empty*/   { $$ = new std::string(""); } ;
+  : INTERNAL    { $$ = GlobalValue::InternalLinkage; } 
+  | LINKONCE    { $$ = GlobalValue::LinkOnceLinkage; } 
+  | WEAK        { $$ = GlobalValue::WeakLinkage; } 
+  | APPENDING   { $$ = GlobalValue::AppendingLinkage; } 
+  | DLLIMPORT   { $$ = GlobalValue::DLLImportLinkage; } 
+  | DLLEXPORT   { $$ = GlobalValue::DLLExportLinkage; } 
+  | EXTERN_WEAK { $$ = GlobalValue::ExternalWeakLinkage; } 
+  | /*empty*/   { $$ = GlobalValue::ExternalLinkage; }
+  ;
 
 OptCallingConv 
-  : CCC_TOK | CSRETCC_TOK | FASTCC_TOK | COLDCC_TOK | X86_STDCALLCC_TOK 
-  | X86_FASTCALLCC_TOK 
-  | CC_TOK EUINT64VAL { 
-    *$1 += *$2; 
-    delete $2;
-    $$ = $1; 
-    }
-  | /*empty*/ { $$ = new std::string(""); } ;
+  : /*empty*/          { $$ = CallingConv::C; } 
+  | CCC_TOK            { $$ = CallingConv::C; } 
+  | CSRETCC_TOK        { $$ = CallingConv::CSRet; } 
+  | FASTCC_TOK         { $$ = CallingConv::Fast; } 
+  | COLDCC_TOK         { $$ = CallingConv::Cold; } 
+  | X86_STDCALLCC_TOK  { $$ = CallingConv::X86_StdCall; } 
+  | X86_FASTCALLCC_TOK { $$ = CallingConv::X86_FastCall; } 
+  | CC_TOK EUINT64VAL  {
+    if ((unsigned)$2 != $2)
+      error("Calling conv too large");
+    $$ = $2;
+  }
+  ;
 
 // OptAlign/OptCAlign - An optional alignment, and an optional alignment with
 // a comma before it.
 OptAlign 
-  : /*empty*/        { $$ = new std::string(); }
-  | ALIGN EUINT64VAL { *$1 += " " + *$2; delete $2; $$ = $1; };
+  : /*empty*/        { $$ = 0; } 
+  | ALIGN EUINT64VAL {
+    $$ = $2;
+    if ($$ != 0 && !isPowerOf2_32($$))
+      error("Alignment must be a power of two");
+  }
+  ;
 
 OptCAlign 
-  : /*empty*/            { $$ = new std::string(); } 
-  | ',' ALIGN EUINT64VAL { 
-    $2->insert(0, ", "); 
-    *$2 += " " + *$3;
-    delete $3;
-    $$ = $2;
-  };
+  : /*empty*/ { $$ = 0; } 
+  | ',' ALIGN EUINT64VAL {
+    $$ = $3;
+    if ($$ != 0 && !isPowerOf2_32($$))
+      error("Alignment must be a power of two");
+  }
+  ;
 
 SectionString 
-  : SECTION STRINGCONSTANT { 
-    *$1 += " " + *$2;
-    delete $2;
-    $$ = $1;
-  };
+  : SECTION STRINGCONSTANT {
+    for (unsigned i = 0, e = strlen($2); i != e; ++i)
+      if ($2[i] == '"' || $2[i] == '\\')
+        error("Invalid character in section name");
+    $$ = $2;
+  }
+  ;
 
-OptSection : /*empty*/     { $$ = new std::string(); } 
-           | SectionString;
+OptSection 
+  : /*empty*/ { $$ = 0; } 
+  | SectionString { $$ = $1; }
+  ;
 
+// GlobalVarAttributes - Used to pass the attributes string on a global.  CurGV
+// is set to be the global we are processing.
+//
 GlobalVarAttributes 
-    : /* empty */ { $$ = new std::string(); } 
-    | ',' GlobalVarAttribute GlobalVarAttributes  {
-      $2->insert(0, ", ");
-      if (!$3->empty())
-        *$2 += " " + *$3;
-      delete $3;
-      $$ = $2;
-    };
+  : /* empty */ {} 
+  | ',' GlobalVarAttribute GlobalVarAttributes {}
+  ;
 
-GlobalVarAttribute 
-    : SectionString 
-    | ALIGN EUINT64VAL {
-      *$1 += " " + *$2;
-      delete $2;
-      $$ = $1;
-    };
+GlobalVarAttribute
+  : SectionString {
+    CurGV->setSection($1);
+    free($1);
+  } 
+  | ALIGN EUINT64VAL {
+    if ($2 != 0 && !isPowerOf2_32($2))
+      error("Alignment must be a power of two");
+    CurGV->setAlignment($2);
+    
+  }
+  ;
 
 //===----------------------------------------------------------------------===//
 // Types includes all predefined types... except void, because it can only be
@@ -1130,112 +1778,164 @@
 //
 
 // TypesV includes all of 'Types', but it also includes the void type.
-TypesV    : Types    | VOID ;
-UpRTypesV : UpRTypes | VOID ; 
-Types     : UpRTypes ;
+TypesV    
+  : Types
+  | VOID { 
+    $$.T = new PATypeHolder($1.T); 
+    $$.S = Signless;
+  }
+  ;
+
+UpRTypesV 
+  : UpRTypes 
+  | VOID { 
+    $$.T = new PATypeHolder($1.T); 
+    $$.S = Signless;
+  }
+  ;
+
+Types
+  : UpRTypes {
+    if (!UpRefs.empty())
+      error("Invalid upreference in type: " + (*$1.T)->getDescription());
+    $$ = $1;
+  }
+  ;
+
+PrimType
+  : BOOL | SBYTE | UBYTE | SHORT  | USHORT | INT   | UINT 
+  | LONG | ULONG | FLOAT | DOUBLE | LABEL
+  ;
 
 // Derived types are added later...
-//
-PrimType : BOOL | SBYTE | UBYTE | SHORT  | USHORT | INT   | UINT ;
-PrimType : LONG | ULONG | FLOAT | DOUBLE | LABEL;
 UpRTypes 
-  : OPAQUE { 
-    $$ = Type::get(*$1, OpaqueTy);
-  } 
-  | SymbolicValueRef { 
-    $$ = Type::get(*$1, UnresolvedTy);
-  }
-  | PrimType { 
-    $$ = $1; 
+  : PrimType { 
+    $$.T = new PATypeHolder($1.T);
+    $$.S = $1.S;
+  }
+  | OPAQUE {
+    $$.T = new PATypeHolder(OpaqueType::get());
+    $$.S = Signless;
+  }
+  | SymbolicValueRef {            // Named types are also simple types...
+    const Type* tmp = getTypeVal($1);
+    $$.T = new PATypeHolder(tmp);
+    $$.S = Signless; // FIXME: what if its signed?
   }
   | '\\' EUINT64VAL {                   // Type UpReference
-    $2->insert(0, "\\");
-    $$ = Type::get(*$2, UpRefTy);
+    if ($2 > (uint64_t)~0U) 
+      error("Value out of range");
+    OpaqueType *OT = OpaqueType::get();        // Use temporary placeholder
+    UpRefs.push_back(UpRefRecord((unsigned)$2, OT));  // Add to vector...
+    $$.T = new PATypeHolder(OT);
+    $$.S = Signless;
+    UR_OUT("New Upreference!\n");
   }
   | UpRTypesV '(' ArgTypeListI ')' {           // Function derived type?
-    std::string newTy( $1->getNewTy() + "(");
-    for (unsigned i = 0; i < $3->size(); ++i) {
-      if (i != 0)
-        newTy +=  ", ";
-      if ((*$3)[i]->isVoid())
-        newTy += "...";
-      else
-        newTy += (*$3)[i]->getNewTy();
-    }
-    newTy += ")";
-    $$ = Type::get(newTy, $1, $3);
+    std::vector Params;
+    for (std::list::iterator I = $3->begin(),
+           E = $3->end(); I != E; ++I) {
+      Params.push_back(I->T->get());
+      delete I->T;
+    }
+    bool isVarArg = Params.size() && Params.back() == Type::VoidTy;
+    if (isVarArg) Params.pop_back();
+
+    $$.T = new PATypeHolder(HandleUpRefs(
+                           FunctionType::get($1.T->get(),Params,isVarArg)));
+    $$.S = $1.S;
+    delete $1.T;    // Delete the return type handle
+    delete $3;      // Delete the argument list
   }
   | '[' EUINT64VAL 'x' UpRTypes ']' {          // Sized array type?
-    uint64_t elems = atoi($2->c_str());
-    $2->insert(0,"[ ");
-    *$2 += " x " + $4->getNewTy() + " ]";
-    $$ = Type::get(*$2, ArrayTy, $4, elems);
+    $$.T = new PATypeHolder(HandleUpRefs(ArrayType::get($4.T->get(), 
+                                                        (unsigned)$2)));
+    $$.S = $4.S;
+    delete $4.T;
   }
   | '<' EUINT64VAL 'x' UpRTypes '>' {          // Packed array type?
-    uint64_t elems = atoi($2->c_str());
-    $2->insert(0,"< ");
-    *$2 += " x " + $4->getNewTy() + " >";
-    $$ = Type::get(*$2, PackedTy, $4, elems);
+     const llvm::Type* ElemTy = $4.T->get();
+     if ((unsigned)$2 != $2)
+        error("Unsigned result not equal to signed result");
+     if (!(ElemTy->isInteger() || ElemTy->isFloatingPoint()))
+        error("Elements of a PackedType must be integer or floating point");
+     if (!isPowerOf2_32($2))
+       error("PackedType length should be a power of 2");
+     $$.T = new PATypeHolder(HandleUpRefs(PackedType::get(ElemTy, 
+                                          (unsigned)$2)));
+     $$.S = $4.S;
+     delete $4.T;
   }
   | '{' TypeListI '}' {                        // Structure type?
-    std::string newTy("{");
-    for (unsigned i = 0; i < $2->size(); ++i) {
-      if (i != 0)
-        newTy +=  ", ";
-      newTy += (*$2)[i]->getNewTy();
-    }
-    newTy += "}";
-    $$ = Type::get(newTy, StructTy, $2);
+    std::vector Elements;
+    for (std::list::iterator I = $2->begin(),
+           E = $2->end(); I != E; ++I)
+      Elements.push_back(I->T->get());
+    $$.T = new PATypeHolder(HandleUpRefs(StructType::get(Elements)));
+    $$.S = Signless;
+    delete $2;
   }
   | '{' '}' {                                  // Empty structure type?
-    $$ = Type::get("{}", StructTy, new TypeList());
+    $$.T = new PATypeHolder(StructType::get(std::vector()));
+    $$.S = Signless;
   }
   | '<' '{' TypeListI '}' '>' {                // Packed Structure type?
-    std::string newTy("<{");
-    for (unsigned i = 0; i < $3->size(); ++i) {
-      if (i != 0)
-        newTy +=  ", ";
-      newTy += (*$3)[i]->getNewTy();
+    std::vector Elements;
+    for (std::list::iterator I = $3->begin(),
+           E = $3->end(); I != E; ++I) {
+      Elements.push_back(I->T->get());
+      delete I->T;
     }
-    newTy += "}>";
-    $$ = Type::get(newTy, PackedStructTy, $3);
+    $$.T = new PATypeHolder(HandleUpRefs(StructType::get(Elements, true)));
+    $$.S = Signless;
+    delete $3;
   }
   | '<' '{' '}' '>' {                          // Empty packed structure type?
-    $$ = Type::get("<{}>", PackedStructTy, new TypeList());
+    $$.T = new PATypeHolder(StructType::get(std::vector(),true));
+    $$.S = Signless;
   }
   | UpRTypes '*' {                             // Pointer type?
-    $$ = $1->getPointerType();
-  };
+    if ($1.T->get() == Type::LabelTy)
+      error("Cannot form a pointer to a basic block");
+    $$.T = new PATypeHolder(HandleUpRefs(PointerType::get($1.T->get())));
+    $$.S = $1.S;
+    delete $1.T;
+  }
+  ;
 
 // TypeList - Used for struct declarations and as a basis for function type 
 // declaration type lists
 //
 TypeListI 
   : UpRTypes {
-    $$ = new TypeList();
-    $$->push_back($1);
+    $$ = new std::list();
+    $$->push_back($1); 
   }
   | TypeListI ',' UpRTypes {
-    $$ = $1;
-    $$->push_back($3);
-  };
+    ($$=$1)->push_back($3);
+  }
+  ;
 
 // ArgTypeList - List of types for a function type declaration...
 ArgTypeListI 
-  : TypeListI 
+  : TypeListI
   | TypeListI ',' DOTDOTDOT {
-    $$ = $1;
-    $$->push_back(Type::get("void",VoidTy));
-    delete $3;
+    PATypeInfo VoidTI;
+    VoidTI.T = new PATypeHolder(Type::VoidTy);
+    VoidTI.S = Signless;
+    ($$=$1)->push_back(VoidTI);
   }
   | DOTDOTDOT {
-    $$ = new TypeList();
-    $$->push_back(Type::get("void",VoidTy));
-    delete $1;
+    $$ = new std::list();
+    PATypeInfo VoidTI;
+    VoidTI.T = new PATypeHolder(Type::VoidTy);
+    VoidTI.S = Signless;
+    $$->push_back(VoidTI);
   }
   | /*empty*/ {
-    $$ = new TypeList();
-  };
+    $$ = new std::list();
+  }
+  ;
 
 // ConstVal - The various declarations that go into the constant pool.  This
 // production is used ONLY to represent constants that show up AFTER a 'const',
@@ -1243,215 +1943,429 @@
 // into other expressions (such as integers and constexprs) are handled by the
 // ResolvedVal, ValueRef and ConstValueRef productions.
 //
-ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr
-    $$ = new Constant;
-    $$->type = $1;
-    $$->cnst = new std::string($1->getNewTy());
-    *$$->cnst += " [ " + *$3 + " ]";
+ConstVal
+  : Types '[' ConstVector ']' { // Nonempty unsized arr
+    const ArrayType *ATy = dyn_cast($1.T->get());
+    if (ATy == 0)
+      error("Cannot make array constant with type: '" + 
+            $1.T->get()->getDescription() + "'");
+    const Type *ETy = ATy->getElementType();
+    int NumElements = ATy->getNumElements();
+
+    // Verify that we have the correct size...
+    if (NumElements != -1 && NumElements != (int)$3->size())
+      error("Type mismatch: constant sized array initialized with " +
+            utostr($3->size()) +  " arguments, but has size of " + 
+            itostr(NumElements) + "");
+
+    // Verify all elements are correct type!
+    std::vector Elems;
+    for (unsigned i = 0; i < $3->size(); i++) {
+      Constant *C = (*$3)[i].C;
+      const Type* ValTy = C->getType();
+      if (ETy != ValTy)
+        error("Element #" + utostr(i) + " is not of type '" + 
+              ETy->getDescription() +"' as required!\nIt is of type '"+
+              ValTy->getDescription() + "'");
+      Elems.push_back(C);
+    }
+    $$.C = ConstantArray::get(ATy, Elems);
+    $$.S = $1.S;
+    delete $1.T; 
     delete $3;
   }
   | Types '[' ']' {
-    $$ = new Constant;
-    $$->type = $1;
-    $$->cnst = new std::string($1->getNewTy());
-    *$$->cnst += "[ ]";
+    const ArrayType *ATy = dyn_cast($1.T->get());
+    if (ATy == 0)
+      error("Cannot make array constant with type: '" + 
+            $1.T->get()->getDescription() + "'");
+    int NumElements = ATy->getNumElements();
+    if (NumElements != -1 && NumElements != 0) 
+      error("Type mismatch: constant sized array initialized with 0"
+            " arguments, but has size of " + itostr(NumElements) +"");
+    $$.C = ConstantArray::get(ATy, std::vector());
+    $$.S = $1.S;
+    delete $1.T;
   }
   | Types 'c' STRINGCONSTANT {
-    $$ = new Constant;
-    $$->type = $1;
-    $$->cnst = new std::string($1->getNewTy());
-    *$$->cnst += " c" + *$3;
-    delete $3;
+    const ArrayType *ATy = dyn_cast($1.T->get());
+    if (ATy == 0)
+      error("Cannot make array constant with type: '" + 
+            $1.T->get()->getDescription() + "'");
+    int NumElements = ATy->getNumElements();
+    const Type *ETy = dyn_cast(ATy->getElementType());
+    if (!ETy || cast(ETy)->getBitWidth() != 8)
+      error("String arrays require type i8, not '" + ETy->getDescription() + 
+            "'");
+    char *EndStr = UnEscapeLexed($3, true);
+    if (NumElements != -1 && NumElements != (EndStr-$3))
+      error("Can't build string constant of size " + 
+            itostr((int)(EndStr-$3)) + " when array has size " + 
+            itostr(NumElements) + "");
+    std::vector Vals;
+    for (char *C = (char *)$3; C != (char *)EndStr; ++C)
+      Vals.push_back(ConstantInt::get(ETy, *C));
+    free($3);
+    $$.C = ConstantArray::get(ATy, Vals);
+    $$.S = $1.S;
+    delete $1.T;
   }
   | Types '<' ConstVector '>' { // Nonempty unsized arr
-    $$ = new Constant;
-    $$->type = $1;
-    $$->cnst = new std::string($1->getNewTy());
-    *$$->cnst += " < " + *$3 + " >";
+    const PackedType *PTy = dyn_cast($1.T->get());
+    if (PTy == 0)
+      error("Cannot make packed constant with type: '" + 
+            $1.T->get()->getDescription() + "'");
+    const Type *ETy = PTy->getElementType();
+    int NumElements = PTy->getNumElements();
+    // Verify that we have the correct size...
+    if (NumElements != -1 && NumElements != (int)$3->size())
+      error("Type mismatch: constant sized packed initialized with " +
+            utostr($3->size()) +  " arguments, but has size of " + 
+            itostr(NumElements) + "");
+    // Verify all elements are correct type!
+    std::vector Elems;
+    for (unsigned i = 0; i < $3->size(); i++) {
+      Constant *C = (*$3)[i].C;
+      const Type* ValTy = C->getType();
+      if (ETy != ValTy)
+        error("Element #" + utostr(i) + " is not of type '" + 
+              ETy->getDescription() +"' as required!\nIt is of type '"+
+              ValTy->getDescription() + "'");
+      Elems.push_back(C);
+    }
+    $$.C = ConstantPacked::get(PTy, Elems);
+    $$.S = $1.S;
+    delete $1.T;
     delete $3;
   }
   | Types '{' ConstVector '}' {
-    $$ = new Constant;
-    $$->type = $1;
-    $$->cnst = new std::string($1->getNewTy());
-    *$$->cnst += " { " + *$3 + " }";
+    const StructType *STy = dyn_cast($1.T->get());
+    if (STy == 0)
+      error("Cannot make struct constant with type: '" + 
+            $1.T->get()->getDescription() + "'");
+    if ($3->size() != STy->getNumContainedTypes())
+      error("Illegal number of initializers for structure type");
+
+    // Check to ensure that constants are compatible with the type initializer!
+    std::vector Fields;
+    for (unsigned i = 0, e = $3->size(); i != e; ++i) {
+      Constant *C = (*$3)[i].C;
+      if (C->getType() != STy->getElementType(i))
+        error("Expected type '" + STy->getElementType(i)->getDescription() +
+              "' for element #" + utostr(i) + " of structure initializer");
+      Fields.push_back(C);
+    }
+    $$.C = ConstantStruct::get(STy, Fields);
+    $$.S = $1.S;
+    delete $1.T;
     delete $3;
   }
   | Types '{' '}' {
-    $$ = new Constant;
-    $$->type = $1;
-    $$->cnst = new std::string($1->getNewTy());
-    *$$->cnst += " {}";
+    const StructType *STy = dyn_cast($1.T->get());
+    if (STy == 0)
+      error("Cannot make struct constant with type: '" + 
+              $1.T->get()->getDescription() + "'");
+    if (STy->getNumContainedTypes() != 0)
+      error("Illegal number of initializers for structure type");
+    $$.C = ConstantStruct::get(STy, std::vector());
+    $$.S = $1.S;
+    delete $1.T;
+  }
+  | Types '<' '{' ConstVector '}' '>' {
+    const StructType *STy = dyn_cast($1.T->get());
+    if (STy == 0)
+      error("Cannot make packed struct constant with type: '" + 
+            $1.T->get()->getDescription() + "'");
+    if ($4->size() != STy->getNumContainedTypes())
+      error("Illegal number of initializers for packed structure type");
+
+    // Check to ensure that constants are compatible with the type initializer!
+    std::vector Fields;
+    for (unsigned i = 0, e = $4->size(); i != e; ++i) {
+      Constant *C = (*$4)[i].C;
+      if (C->getType() != STy->getElementType(i))
+        error("Expected type '" + STy->getElementType(i)->getDescription() +
+              "' for element #" + utostr(i) + " of packed struct initializer");
+      Fields.push_back(C);
+    }
+    $$.C = ConstantStruct::get(STy, Fields);
+    $$.S = $1.S;
+    delete $1.T; 
+    delete $4;
+  }
+  | Types '<' '{' '}' '>' {
+    const StructType *STy = dyn_cast($1.T->get());
+    if (STy == 0)
+      error("Cannot make packed struct constant with type: '" + 
+              $1.T->get()->getDescription() + "'");
+    if (STy->getNumContainedTypes() != 0)
+      error("Illegal number of initializers for packed structure type");
+    $$.C = ConstantStruct::get(STy, std::vector());
+    $$.S = $1.S;
+    delete $1.T;
   }
   | Types NULL_TOK {
-    $$ = new Constant;
-    $$->type = $1;
-    $$->cnst = new std::string($1->getNewTy());
-    *$$->cnst +=  " " + *$2;
-    delete $2;
+    const PointerType *PTy = dyn_cast($1.T->get());
+    if (PTy == 0)
+      error("Cannot make null pointer constant with type: '" + 
+            $1.T->get()->getDescription() + "'");
+    $$.C = ConstantPointerNull::get(PTy);
+    $$.S = $1.S;
+    delete $1.T;
   }
   | Types UNDEF {
-    $$ = new Constant;
-    $$->type = $1;
-    $$->cnst = new std::string($1->getNewTy());
-    *$$->cnst += " " + *$2;
-    delete $2;
+    $$.C = UndefValue::get($1.T->get());
+    $$.S = $1.S;
+    delete $1.T;
   }
   | Types SymbolicValueRef {
-    $$ = new Constant;
-    std::string Name = getUniqueName($2, $1->resolve(), true);
-    $$->type = $1;
-    $$->cnst = new std::string($1->getNewTy());
-    *$$->cnst += " " + Name;
-    delete $2;
+    const PointerType *Ty = dyn_cast($1.T->get());
+    if (Ty == 0)
+      error("Global const reference must be a pointer type, not" +
+            $1.T->get()->getDescription());
+
+    // ConstExprs can exist in the body of a function, thus creating
+    // GlobalValues whenever they refer to a variable.  Because we are in
+    // the context of a function, getExistingValue will search the functions
+    // symbol table instead of the module symbol table for the global symbol,
+    // which throws things all off.  To get around this, we just tell
+    // getExistingValue that we are at global scope here.
+    //
+    Function *SavedCurFn = CurFun.CurrentFunction;
+    CurFun.CurrentFunction = 0;
+    Value *V = getExistingValue(Ty, $2);
+    CurFun.CurrentFunction = SavedCurFn;
+
+    // If this is an initializer for a constant pointer, which is referencing a
+    // (currently) undefined variable, create a stub now that shall be replaced
+    // in the future with the right type of variable.
+    //
+    if (V == 0) {
+      assert(isa(Ty) && "Globals may only be used as pointers");
+      const PointerType *PT = cast(Ty);
+
+      // First check to see if the forward references value is already created!
+      PerModuleInfo::GlobalRefsType::iterator I =
+        CurModule.GlobalRefs.find(std::make_pair(PT, $2));
+    
+      if (I != CurModule.GlobalRefs.end()) {
+        V = I->second;             // Placeholder already exists, use it...
+        $2.destroy();
+      } else {
+        std::string Name;
+        if ($2.Type == ValID::NameVal) Name = $2.Name;
+
+        // Create the forward referenced global.
+        GlobalValue *GV;
+        if (const FunctionType *FTy = 
+                 dyn_cast(PT->getElementType())) {
+          GV = new Function(FTy, GlobalValue::ExternalLinkage, Name,
+                            CurModule.CurrentModule);
+        } else {
+          GV = new GlobalVariable(PT->getElementType(), false,
+                                  GlobalValue::ExternalLinkage, 0,
+                                  Name, CurModule.CurrentModule);
+        }
+
+        // Keep track of the fact that we have a forward ref to recycle it
+        CurModule.GlobalRefs.insert(std::make_pair(std::make_pair(PT, $2), GV));
+        V = GV;
+      }
+    }
+    $$.C = cast(V);
+    $$.S = $1.S;
+    delete $1.T;            // Free the type handle
   }
   | Types ConstExpr {
-    $$ = new Constant;
-    $$->type = $1;
-    $$->cnst = new std::string($1->getNewTy());
-    *$$->cnst += " " + *$2;
-    delete $2;
+    if ($1.T->get() != $2.C->getType())
+      error("Mismatched types for constant expression");
+    $$ = $2;
+    $$.S = $1.S;
+    delete $1.T;
   }
   | Types ZEROINITIALIZER {
-    $$ = new Constant;
-    $$->type = $1;
-    $$->cnst = new std::string($1->getNewTy());
-    *$$->cnst += " " + *$2;
-    delete $2;
-  }
-  | SIntType EInt64Val {      // integral constants
-    $$ = new Constant;
-    $$->type = $1;
-    $$->cnst = new std::string($1->getNewTy());
-    *$$->cnst += " " + *$2;
-    delete $2;
-  }
-  | UIntType EInt64Val {            // integral constants
-    $$ = new Constant;
-    $$->type = $1;
-    $$->cnst = new std::string($1->getNewTy());
-    *$$->cnst += " " + *$2;
-    delete $2;
+    const Type *Ty = $1.T->get();
+    if (isa(Ty) || Ty == Type::LabelTy || isa(Ty))
+      error("Cannot create a null initialized value of this type");
+    $$.C = Constant::getNullValue(Ty);
+    $$.S = $1.S;
+    delete $1.T;
+  }
+  | SIntType EINT64VAL {      // integral constants
+    const Type *Ty = $1.T;
+    if (!ConstantInt::isValueValidForType(Ty, $2))
+      error("Constant value doesn't fit in type");
+    $$.C = ConstantInt::get(Ty, $2);
+    $$.S = Signed;
+  }
+  | UIntType EUINT64VAL {            // integral constants
+    const Type *Ty = $1.T;
+    if (!ConstantInt::isValueValidForType(Ty, $2))
+      error("Constant value doesn't fit in type");
+    $$.C = ConstantInt::get(Ty, $2);
+    $$.S = Unsigned;
   }
   | BOOL TRUETOK {                      // Boolean constants
-    $$ = new Constant;
-    $$->type = $1;
-    $$->cnst = new std::string($1->getNewTy());
-    *$$->cnst += " " + *$2;
-    delete $2;
+    $$.C = ConstantInt::get(Type::Int1Ty, true);
+    $$.S = Unsigned;
   }
   | BOOL FALSETOK {                     // Boolean constants
-    $$ = new Constant;
-    $$->type = $1;
-    $$->cnst = new std::string($1->getNewTy());
-    *$$->cnst += " " + *$2;
-    delete $2;
+    $$.C = ConstantInt::get(Type::Int1Ty, false);
+    $$.S = Unsigned;
   }
   | FPType FPVAL {                   // Float & Double constants
-    $$ = new Constant;
-    $$->type = $1;
-    $$->cnst = new std::string($1->getNewTy());
-    *$$->cnst += " " + *$2;
-    delete $2;
-  };
+    if (!ConstantFP::isValueValidForType($1.T, $2))
+      error("Floating point constant invalid for type");
+    $$.C = ConstantFP::get($1.T, $2);
+    $$.S = Signless;
+  }
+  ;
 
-ConstExpr: CastOps '(' ConstVal TO Types ')' {
-    std::string source = *$3->cnst;
-    const Type* SrcTy = $3->type->resolve();
-    const Type* DstTy = $5->resolve(); 
-    if (*$1 == "cast") {
-      // Call getCastUpgrade to upgrade the old cast
-      $$ = new std::string(getCastUpgrade(source, SrcTy, DstTy, true));
-    } else {
-      // Nothing to upgrade, just create the cast constant expr
-      $$ = new std::string(*$1);
-      *$$ += "( " + source + " to " + $5->getNewTy() + ")";
-    }
-    delete $1; delete $3; delete $4;
+ConstExpr
+  : CastOps '(' ConstVal TO Types ')' {
+    const Type* SrcTy = $3.C->getType();
+    const Type* DstTy = $5.T->get();
+    Signedness SrcSign = $3.S;
+    Signedness DstSign = $5.S;
+    if (!SrcTy->isFirstClassType())
+      error("cast constant expression from a non-primitive type: '" +
+            SrcTy->getDescription() + "'");
+    if (!DstTy->isFirstClassType())
+      error("cast constant expression to a non-primitive type: '" +
+            DstTy->getDescription() + "'");
+    $$.C = cast(getCast($1, $3.C, SrcSign, DstTy, DstSign));
+    $$.S = DstSign;
+    delete $5.T;
   }
   | GETELEMENTPTR '(' ConstVal IndexList ')' {
-    *$1 += "(" + *$3->cnst;
-    for (unsigned i = 0; i < $4->size(); ++i) {
-      Value* V = (*$4)[i];
-      *$1 += ", " + *V->val;
-      delete V;
-    }
-    *$1 += ")";
-    $$ = $1;
-    delete $3;
+    const Type *Ty = $3.C->getType();
+    if (!isa(Ty))
+      error("GetElementPtr requires a pointer operand");
+
+    std::vector VIndices;
+    std::vector CIndices;
+    upgradeGEPIndices($3.C->getType(), $4, VIndices, &CIndices);
+
     delete $4;
+    $$.C = ConstantExpr::getGetElementPtr($3.C, CIndices);
+    $$.S = Signless;
   }
   | SELECT '(' ConstVal ',' ConstVal ',' ConstVal ')' {
-    *$1 += "(" + *$3->cnst + "," + *$5->cnst + "," + *$7->cnst + ")";
-    delete $3; delete $5; delete $7;
-    $$ = $1;
+    if (!$3.C->getType()->isInteger() ||
+        cast($3.C->getType())->getBitWidth() != 1)
+      error("Select condition must be bool type");
+    if ($5.C->getType() != $7.C->getType())
+      error("Select operand types must match");
+    $$.C = ConstantExpr::getSelect($3.C, $5.C, $7.C);
+    $$.S = Unsigned;
   }
   | ArithmeticOps '(' ConstVal ',' ConstVal ')' {
-    const char* op = getDivRemOpcode(*$1, $3->type); 
-    $$ = new std::string(op);
-    *$$ += "(" + *$3->cnst + "," + *$5->cnst + ")";
-    delete $1; delete $3; delete $5;
+    const Type *Ty = $3.C->getType();
+    if (Ty != $5.C->getType())
+      error("Binary operator types must match");
+    // First, make sure we're dealing with the right opcode by upgrading from
+    // obsolete versions.
+    Instruction::BinaryOps Opcode = getBinaryOp($1, Ty, $3.S);
+
+    // HACK: llvm 1.3 and earlier used to emit invalid pointer constant exprs.
+    // To retain backward compatibility with these early compilers, we emit a
+    // cast to the appropriate integer type automatically if we are in the
+    // broken case.  See PR424 for more information.
+    if (!isa(Ty)) {
+      $$.C = ConstantExpr::get(Opcode, $3.C, $5.C);
+    } else {
+      const Type *IntPtrTy = 0;
+      switch (CurModule.CurrentModule->getPointerSize()) {
+      case Module::Pointer32: IntPtrTy = Type::Int32Ty; break;
+      case Module::Pointer64: IntPtrTy = Type::Int64Ty; break;
+      default: error("invalid pointer binary constant expr");
+      }
+      $$.C = ConstantExpr::get(Opcode, 
+             ConstantExpr::getCast(Instruction::PtrToInt, $3.C, IntPtrTy),
+             ConstantExpr::getCast(Instruction::PtrToInt, $5.C, IntPtrTy));
+      $$.C = ConstantExpr::getCast(Instruction::IntToPtr, $$.C, Ty);
+    }
+    $$.S = $3.S; 
   }
   | LogicalOps '(' ConstVal ',' ConstVal ')' {
-    *$1 += "(" + *$3->cnst + "," + *$5->cnst + ")";
-    delete $3; delete $5;
-    $$ = $1;
+    const Type* Ty = $3.C->getType();
+    if (Ty != $5.C->getType())
+      error("Logical operator types must match");
+    if (!Ty->isInteger()) {
+      if (!isa(Ty) || 
+          !cast(Ty)->getElementType()->isInteger())
+        error("Logical operator requires integer operands");
+    }
+    Instruction::BinaryOps Opcode = getBinaryOp($1, Ty, $3.S);
+    $$.C = ConstantExpr::get(Opcode, $3.C, $5.C);
+    $$.S = $3.S;
   }
   | SetCondOps '(' ConstVal ',' ConstVal ')' {
-    *$1 = getCompareOp(*$1, $3->type);
-    *$1 += "(" + *$3->cnst + "," + *$5->cnst + ")";
-    delete $3; delete $5;
-    $$ = $1;
+    const Type* Ty = $3.C->getType();
+    if (Ty != $5.C->getType())
+      error("setcc operand types must match");
+    unsigned short pred;
+    Instruction::OtherOps Opcode = getCompareOp($1, pred, Ty, $3.S);
+    $$.C = ConstantExpr::getCompare(Opcode, $3.C, $5.C);
+    $$.S = Unsigned;
   }
   | ICMP IPredicates '(' ConstVal ',' ConstVal ')' {
-    *$1 += " " + *$2 + " (" +  *$4->cnst + "," + *$6->cnst + ")";
-    delete $2; delete $4; delete $6;
-    $$ = $1;
+    if ($4.C->getType() != $6.C->getType()) 
+      error("icmp operand types must match");
+    $$.C = ConstantExpr::getCompare($2, $4.C, $6.C);
+    $$.S = Unsigned;
   }
   | FCMP FPredicates '(' ConstVal ',' ConstVal ')' {
-    *$1 += " " + *$2 + " (" + *$4->cnst + "," + *$6->cnst + ")";
-    delete $2; delete $4; delete $6;
-    $$ = $1;
+    if ($4.C->getType() != $6.C->getType()) 
+      error("fcmp operand types must match");
+    $$.C = ConstantExpr::getCompare($2, $4.C, $6.C);
+    $$.S = Unsigned;
   }
   | ShiftOps '(' ConstVal ',' ConstVal ')' {
-    const char* shiftop = $1->c_str();
-    if (*$1 == "shr")
-      shiftop = ($3->type->isUnsigned()) ? "lshr" : "ashr";
-    $$ = new std::string(shiftop);
-    *$$ += "(" + *$3->cnst + "," + *$5->cnst + ")";
-    delete $1; delete $3; delete $5;
+    if (!$5.C->getType()->isInteger() ||
+        cast($5.C->getType())->getBitWidth() != 8)
+      error("Shift count for shift constant must be unsigned byte");
+    if (!$3.C->getType()->isInteger())
+      error("Shift constant expression requires integer operand");
+    $$.C = ConstantExpr::get(getOtherOp($1, $3.S), $3.C, $5.C);
+    $$.S = $3.S;
   }
   | EXTRACTELEMENT '(' ConstVal ',' ConstVal ')' {
-    *$1 += "(" + *$3->cnst + "," + *$5->cnst + ")";
-    delete $3; delete $5;
-    $$ = $1;
+    if (!ExtractElementInst::isValidOperands($3.C, $5.C))
+      error("Invalid extractelement operands");
+    $$.C = ConstantExpr::getExtractElement($3.C, $5.C);
+    $$.S = $3.S;
   }
   | INSERTELEMENT '(' ConstVal ',' ConstVal ',' ConstVal ')' {
-    *$1 += "(" + *$3->cnst + "," + *$5->cnst + "," + *$7->cnst + ")";
-    delete $3; delete $5; delete $7;
-    $$ = $1;
+    if (!InsertElementInst::isValidOperands($3.C, $5.C, $7.C))
+      error("Invalid insertelement operands");
+    $$.C = ConstantExpr::getInsertElement($3.C, $5.C, $7.C);
+    $$.S = $3.S;
   }
   | SHUFFLEVECTOR '(' ConstVal ',' ConstVal ',' ConstVal ')' {
-    *$1 += "(" + *$3->cnst + "," + *$5->cnst + "," + *$7->cnst + ")";
-    delete $3; delete $5; delete $7;
-    $$ = $1;
-  };
+    if (!ShuffleVectorInst::isValidOperands($3.C, $5.C, $7.C))
+      error("Invalid shufflevector operands");
+    $$.C = ConstantExpr::getShuffleVector($3.C, $5.C, $7.C);
+    $$.S = $3.S;
+  }
+  ;
 
 
 // ConstVector - A list of comma separated constants.
-
 ConstVector 
-  : ConstVector ',' ConstVal {
-    *$1 += ", " + *$3->cnst;
-    delete $3;
-    $$ = $1;
+  : ConstVector ',' ConstVal { ($$ = $1)->push_back($3); }
+  | ConstVal {
+    $$ = new std::vector();
+    $$->push_back($1);
   }
-  | ConstVal { $$ = new std::string(*$1->cnst); delete $1; }
   ;
 
 
 // GlobalType - Match either GLOBAL or CONSTANT for global declarations...
-GlobalType : GLOBAL | CONSTANT ;
+GlobalType 
+  : GLOBAL { $$ = false; } 
+  | CONSTANT { $$ = true; }
+  ;
 
 
 //===----------------------------------------------------------------------===//
@@ -1461,819 +2375,1059 @@
 // Module rule: Capture the result of parsing the whole file into a result
 // variable...
 //
-Module : DefinitionList {
-};
+Module 
+  : FunctionList {
+    $$ = ParserResult = $1;
+    CurModule.ModuleDone();
+  }
+  ;
 
-// DefinitionList - Top level definitions
+// FunctionList - A list of functions, preceeded by a constant pool.
 //
-DefinitionList : DefinitionList Function {
-    $$ = 0;
-  } 
-  | DefinitionList FunctionProto {
-    *O << *$2 << '\n';
-    delete $2;
-    $$ = 0;
-  }
-  | DefinitionList MODULE ASM_TOK AsmBlock {
-    *O << "module asm " << ' ' << *$4 << '\n';
-    $$ = 0;
-  }  
-  | DefinitionList IMPLEMENTATION {
-    *O << "implementation\n";
-    $$ = 0;
+FunctionList 
+  : FunctionList Function { $$ = $1; CurFun.FunctionDone(); } 
+  | FunctionList FunctionProto { $$ = $1; }
+  | FunctionList MODULE ASM_TOK AsmBlock { $$ = $1; }  
+  | FunctionList IMPLEMENTATION { $$ = $1; }
+  | ConstPool {
+    $$ = CurModule.CurrentModule;
+    // Emit an error if there are any unresolved types left.
+    if (!CurModule.LateResolveTypes.empty()) {
+      const ValID &DID = CurModule.LateResolveTypes.begin()->first;
+      if (DID.Type == ValID::NameVal) {
+        error("Reference to an undefined type: '"+DID.getName() + "'");
+      } else {
+        error("Reference to an undefined type: #" + itostr(DID.Num));
+      }
+    }
   }
-  | ConstPool { $$ = 0; }
   ;
 
-External : EXTERNAL | UNINITIALIZED { $$ = $1; *$$ = "external"; } ;
-
 // ConstPool - Constants with optional names assigned to them.
-ConstPool : ConstPool OptAssign TYPE TypesV {
-    Type::EnumeratedTypes.push_back($4);
-    if (!$2->empty()) {
-      Type::NamedTypes[*$2] = $4;
-      *O << *$2 << " = ";
+ConstPool 
+  : ConstPool OptAssign TYPE TypesV {
+    // Eagerly resolve types.  This is not an optimization, this is a
+    // requirement that is due to the fact that we could have this:
+    //
+    // %list = type { %list * }
+    // %list = type { %list * }    ; repeated type decl
+    //
+    // If types are not resolved eagerly, then the two types will not be
+    // determined to be the same type!
+    //
+    const Type* Ty = $4.T->get();
+    ResolveTypeTo($2, Ty);
+
+    if (!setTypeName(Ty, $2) && !$2) {
+      // If this is a named type that is not a redefinition, add it to the slot
+      // table.
+      CurModule.Types.push_back(Ty);
     }
-    *O << "type " << $4->getNewTy() << '\n';
-    delete $2; delete $3;
-    $$ = 0;
+    delete $4.T;
   }
   | ConstPool FunctionProto {       // Function prototypes can be in const pool
-    *O << *$2 << '\n';
-    delete $2;
-    $$ = 0;
   }
   | ConstPool MODULE ASM_TOK AsmBlock {  // Asm blocks can be in the const pool
-    *O << *$2 << ' ' << *$3 << ' ' << *$4 << '\n';
-    delete $2; delete $3; delete $4; 
-    $$ = 0;
   }
-  | ConstPool OptAssign OptLinkage GlobalType ConstVal  GlobalVarAttributes {
-    if (!$2->empty()) {
-      std::string Name = getGlobalName($2,*$3, $5->type->getPointerType(),
-                                       *$4 == "constant");
-      *O << Name << " = ";
-    }
-    *O << *$3 << ' ' << *$4 << ' ' << *$5->cnst << ' ' << *$6 << '\n';
-    delete $2; delete $3; delete $4; delete $6; 
-    $$ = 0;
-  }
-  | ConstPool OptAssign External GlobalType Types  GlobalVarAttributes {
-    if (!$2->empty()) {
-      std::string Name = getGlobalName($2,*$3,$5->getPointerType(),
-                                       *$4 == "constant");
-      *O << Name << " = ";
-    }
-    *O <<  *$3 << ' ' << *$4 << ' ' << $5->getNewTy() << ' ' << *$6 << '\n';
-    delete $2; delete $3; delete $4; delete $6;
-    $$ = 0;
-  }
-  | ConstPool OptAssign DLLIMPORT GlobalType Types GlobalVarAttributes {
-    if (!$2->empty()) {
-      std::string Name = getGlobalName($2,*$3,$5->getPointerType(),
-                                       *$4 == "constant");
-      *O << Name << " = ";
-    }
-    *O << *$3 << ' ' << *$4 << ' ' << $5->getNewTy() << ' ' << *$6 << '\n';
-    delete $2; delete $3; delete $4; delete $6;
-    $$ = 0;
-  }
-  | ConstPool OptAssign EXTERN_WEAK GlobalType Types  GlobalVarAttributes {
-    if (!$2->empty()) {
-      std::string Name = getGlobalName($2,*$3,$5->getPointerType(),
-                                       *$4 == "constant");
-      *O << Name << " = ";
-    }
-    *O << *$3 << ' ' << *$4 << ' ' << $5->getNewTy() << ' ' << *$6 << '\n';
-    delete $2; delete $3; delete $4; delete $6;
-    $$ = 0;
+  | ConstPool OptAssign OptLinkage GlobalType ConstVal {
+    if ($5.C == 0) 
+      error("Global value initializer is not a constant");
+    CurGV = ParseGlobalVariable($2, $3, $4, $5.C->getType(), $5.C);
+  } GlobalVarAttributes {
+    CurGV = 0;
+  }
+  | ConstPool OptAssign EXTERNAL GlobalType Types {
+    const Type *Ty = $5.T->get();
+    CurGV = ParseGlobalVariable($2, GlobalValue::ExternalLinkage, $4, Ty, 0);
+    delete $5.T;
+  } GlobalVarAttributes {
+    CurGV = 0;
+  }
+  | ConstPool OptAssign DLLIMPORT GlobalType Types {
+    const Type *Ty = $5.T->get();
+    CurGV = ParseGlobalVariable($2, GlobalValue::DLLImportLinkage, $4, Ty, 0);
+    delete $5.T;
+  } GlobalVarAttributes {
+    CurGV = 0;
+  }
+  | ConstPool OptAssign EXTERN_WEAK GlobalType Types {
+    const Type *Ty = $5.T->get();
+    CurGV = 
+      ParseGlobalVariable($2, GlobalValue::ExternalWeakLinkage, $4, Ty, 0);
+    delete $5.T;
+  } GlobalVarAttributes {
+    CurGV = 0;
   }
   | ConstPool TARGET TargetDefinition { 
-    *O << *$2 << ' ' << *$3 << '\n';
-    delete $2; delete $3;
-    $$ = 0;
   }
   | ConstPool DEPLIBS '=' LibrariesDefinition {
-    *O << *$2 << " = " << *$4 << '\n';
-    delete $2; delete $4;
-    $$ = 0;
   }
   | /* empty: end of list */ { 
-    $$ = 0;
-  };
+  }
+  ;
 
+AsmBlock 
+  : STRINGCONSTANT {
+    const std::string &AsmSoFar = CurModule.CurrentModule->getModuleInlineAsm();
+    char *EndStr = UnEscapeLexed($1, true);
+    std::string NewAsm($1, EndStr);
+    free($1);
 
-AsmBlock : STRINGCONSTANT ;
+    if (AsmSoFar.empty())
+      CurModule.CurrentModule->setModuleInlineAsm(NewAsm);
+    else
+      CurModule.CurrentModule->setModuleInlineAsm(AsmSoFar+"\n"+NewAsm);
+  }
+  ;
 
-BigOrLittle : BIG | LITTLE ;
+BigOrLittle 
+  : BIG    { $$ = Module::BigEndian; };
+  | LITTLE { $$ = Module::LittleEndian; }
+  ;
 
 TargetDefinition 
   : ENDIAN '=' BigOrLittle {
-    *$1 += " = " + *$3;
-    delete $3;
-    $$ = $1;
+    CurModule.setEndianness($3);
   }
   | POINTERSIZE '=' EUINT64VAL {
-    *$1 += " = " + *$3;
-    if (*$3 == "64")
-      SizeOfPointer = 64;
-    delete $3;
-    $$ = $1;
+    if ($3 == 32)
+      CurModule.setPointerSize(Module::Pointer32);
+    else if ($3 == 64)
+      CurModule.setPointerSize(Module::Pointer64);
+    else
+      error("Invalid pointer size: '" + utostr($3) + "'");
   }
   | TRIPLE '=' STRINGCONSTANT {
-    *$1 += " = " + *$3;
-    delete $3;
-    $$ = $1;
+    CurModule.CurrentModule->setTargetTriple($3);
+    free($3);
   }
   | DATALAYOUT '=' STRINGCONSTANT {
-    *$1 += " = " + *$3;
-    delete $3;
-    $$ = $1;
-  };
+    CurModule.CurrentModule->setDataLayout($3);
+    free($3);
+  }
+  ;
 
 LibrariesDefinition 
-  : '[' LibList ']' {
-    $2->insert(0, "[ ");
-    *$2 += " ]";
-    $$ = $2;
-  };
+  : '[' LibList ']'
+  ;
 
 LibList 
   : LibList ',' STRINGCONSTANT {
-    *$1 += ", " + *$3;
-    delete $3;
-    $$ = $1;
+      CurModule.CurrentModule->addLibrary($3);
+      free($3);
   }
-  | STRINGCONSTANT 
-  | /* empty: end of list */ {
-    $$ = new std::string();
-  };
+  | STRINGCONSTANT {
+    CurModule.CurrentModule->addLibrary($1);
+    free($1);
+  }
+  | /* empty: end of list */ { }
+  ;
 
 //===----------------------------------------------------------------------===//
 //                       Rules to match Function Headers
 //===----------------------------------------------------------------------===//
 
-Name : VAR_ID | STRINGCONSTANT;
-OptName : Name | /*empty*/ { $$ = new std::string(); };
+Name 
+  : VAR_ID | STRINGCONSTANT
+  ;
+
+OptName 
+  : Name 
+  | /*empty*/ { $$ = 0; }
+  ;
 
-ArgVal : Types OptName {
-  $$ = new std::string($1->getNewTy());
-  if (!$2->empty()) {
-    std::string Name = getUniqueName($2, $1->resolve());
-    *$$ += " " + Name;
+ArgVal 
+  : Types OptName {
+    if ($1.T->get() == Type::VoidTy)
+      error("void typed arguments are invalid");
+    $$ = new std::pair($1, $2);
   }
-  delete $2;
-};
+  ;
 
-ArgListH : ArgListH ',' ArgVal {
-    *$1 += ", " + *$3;
+ArgListH 
+  : ArgListH ',' ArgVal {
+    $$ = $1;
+    $$->push_back(*$3);
     delete $3;
   }
   | ArgVal {
-    $$ = $1;
-  };
-
-ArgList : ArgListH {
-    $$ = $1;
+    $$ = new std::vector >();
+    $$->push_back(*$1);
+    delete $1;
   }
+  ;
+
+ArgList 
+  : ArgListH { $$ = $1; }
   | ArgListH ',' DOTDOTDOT {
-    *$1 += ", ...";
     $$ = $1;
-    delete $3;
+    PATypeInfo VoidTI;
+    VoidTI.T = new PATypeHolder(Type::VoidTy);
+    VoidTI.S = Signless;
+    $$->push_back(std::pair(VoidTI, 0));
   }
   | DOTDOTDOT {
-    $$ = $1;
+    $$ = new std::vector >();
+    PATypeInfo VoidTI;
+    VoidTI.T = new PATypeHolder(Type::VoidTy);
+    VoidTI.S = Signless;
+    $$->push_back(std::pair(VoidTI, 0));
   }
-  | /* empty */ { $$ = new std::string(); };
+  | /* empty */ { $$ = 0; }
+  ;
 
 FunctionHeaderH 
   : OptCallingConv TypesV Name '(' ArgList ')' OptSection OptAlign {
-    if (*$3 == "%llvm.va_start" || *$3 == "%llvm.va_end") {
-      *$5 = "i8*";
-    } else if (*$3 == "%llvm.va_copy") {
-      *$5 = "i8*, i8*";
-    }
-    if (!$1->empty()) {
-      *$1 += " ";
-    }
-    *$1 += $2->getNewTy() + " " + *$3 + "(" + *$5 + ")";
-    if (!$7->empty()) {
-      *$1 += " " + *$7;
+    UnEscapeLexed($3);
+    std::string FunctionName($3);
+    free($3);  // Free strdup'd memory!
+
+    const Type* RetTy = $2.T->get();
+    
+    if (!RetTy->isFirstClassType() && RetTy != Type::VoidTy)
+      error("LLVM functions cannot return aggregate types");
+
+    std::vector ParamTypeList;
+
+    // In LLVM 2.0 the signatures of three varargs intrinsics changed to take
+    // i8*. We check here for those names and override the parameter list
+    // types to ensure the prototype is correct.
+    if (FunctionName == "llvm.va_start" || FunctionName == "llvm.va_end") {
+      ParamTypeList.push_back(PointerType::get(Type::Int8Ty));
+    } else if (FunctionName == "llvm.va_copy") {
+      ParamTypeList.push_back(PointerType::get(Type::Int8Ty));
+      ParamTypeList.push_back(PointerType::get(Type::Int8Ty));
+    } else if ($5) {   // If there are arguments...
+      for (std::vector >::iterator 
+           I = $5->begin(), E = $5->end(); I != E; ++I) {
+        const Type *Ty = I->first.T->get();
+        ParamTypeList.push_back(Ty);
+      }
     }
-    if (!$8->empty()) {
-      *$1 += " " + *$8;
+
+    bool isVarArg = 
+      ParamTypeList.size() && ParamTypeList.back() == Type::VoidTy;
+    if (isVarArg) ParamTypeList.pop_back();
+
+    const FunctionType *FT = FunctionType::get(RetTy, ParamTypeList, isVarArg);
+    const PointerType *PFT = PointerType::get(FT);
+    delete $2.T;
+
+    ValID ID;
+    if (!FunctionName.empty()) {
+      ID = ValID::create((char*)FunctionName.c_str());
+    } else {
+      ID = ValID::create((int)CurModule.Values[PFT].size());
     }
-    delete $3;
-    delete $5;
-    delete $7;
-    delete $8;
-    $$ = $1;
-  };
 
-BEGIN : BEGINTOK { $$ = new std::string("{"); delete $1; }
-  | '{' { $$ = new std::string ("{"); }
+    Function *Fn = 0;
+    // See if this function was forward referenced.  If so, recycle the object.
+    if (GlobalValue *FWRef = CurModule.GetForwardRefForGlobal(PFT, ID)) {
+      // Move the function to the end of the list, from whereever it was 
+      // previously inserted.
+      Fn = cast(FWRef);
+      CurModule.CurrentModule->getFunctionList().remove(Fn);
+      CurModule.CurrentModule->getFunctionList().push_back(Fn);
+    } else if (!FunctionName.empty() &&     // Merge with an earlier prototype?
+               (Fn = CurModule.CurrentModule->getFunction(FunctionName, FT))) {
+      // If this is the case, either we need to be a forward decl, or it needs 
+      // to be.
+      if (!CurFun.isDeclare && !Fn->isExternal())
+        error("Redefinition of function '" + FunctionName + "'");
+      
+      // Make sure to strip off any argument names so we can't get conflicts.
+      if (Fn->isExternal())
+        for (Function::arg_iterator AI = Fn->arg_begin(), AE = Fn->arg_end();
+             AI != AE; ++AI)
+          AI->setName("");
+    } else  {  // Not already defined?
+      Fn = new Function(FT, GlobalValue::ExternalLinkage, FunctionName,
+                        CurModule.CurrentModule);
+
+      InsertValue(Fn, CurModule.Values);
+    }
+
+    CurFun.FunctionStart(Fn);
+
+    if (CurFun.isDeclare) {
+      // If we have declaration, always overwrite linkage.  This will allow us 
+      // to correctly handle cases, when pointer to function is passed as 
+      // argument to another function.
+      Fn->setLinkage(CurFun.Linkage);
+    }
+    Fn->setCallingConv($1);
+    Fn->setAlignment($8);
+    if ($7) {
+      Fn->setSection($7);
+      free($7);
+    }
+
+    // Add all of the arguments we parsed to the function...
+    if ($5) {                     // Is null if empty...
+      if (isVarArg) {  // Nuke the last entry
+        assert($5->back().first.T->get() == Type::VoidTy && 
+               $5->back().second == 0 && "Not a varargs marker");
+        delete $5->back().first.T;
+        $5->pop_back();  // Delete the last entry
+      }
+      Function::arg_iterator ArgIt = Fn->arg_begin();
+      for (std::vector >::iterator 
+           I = $5->begin(), E = $5->end(); I != E; ++I, ++ArgIt) {
+        delete I->first.T;                        // Delete the typeholder...
+        setValueName(ArgIt, I->second);           // Insert arg into symtab...
+        InsertValue(ArgIt);
+      }
+      delete $5;                     // We're now done with the argument list
+    }
+  }
+  ;
+
+BEGIN 
+  : BEGINTOK | '{'                // Allow BEGIN or '{' to start a function
   ;
 
 FunctionHeader 
   : OptLinkage FunctionHeaderH BEGIN {
-    *O << "define ";
-    if (!$1->empty()) {
-      *O << *$1 << ' ';
-    }
-    *O << *$2 << ' ' << *$3 << '\n';
-    delete $1; delete $2; delete $3;
-    $$ = 0;
+    $$ = CurFun.CurrentFunction;
+
+    // Make sure that we keep track of the linkage type even if there was a
+    // previous "declare".
+    $$->setLinkage($1);
   }
   ;
 
-END : ENDTOK { $$ = new std::string("}"); delete $1; }
-    | '}' { $$ = new std::string("}"); };
+END 
+  : ENDTOK | '}'                    // Allow end of '}' to end a function
+  ;
 
-Function : FunctionHeader BasicBlockList END {
-  if ($2)
-    *O << *$2;
-  *O << *$3 << "\n\n";
-  delete $1; delete $2; delete $3;
-  $$ = 0;
-};
+Function 
+  : BasicBlockList END {
+    $$ = $1;
+  };
 
 FnDeclareLinkage
-  : /*default*/ { $$ = new std::string(); }
-  | DLLIMPORT    
-  | EXTERN_WEAK 
+  : /*default*/ 
+  | DLLIMPORT   { CurFun.Linkage = GlobalValue::DLLImportLinkage; } 
+  | EXTERN_WEAK { CurFun.Linkage = GlobalValue::ExternalWeakLinkage; }
   ;
   
 FunctionProto 
-  : DECLARE { isDeclare = true; } FnDeclareLinkage FunctionHeaderH { 
-    if (!$3->empty())
-      *$1 += " " + *$3;
-    *$1 += " " + *$4;
-    delete $3;
-    delete $4;
-    $$ = $1;
-    isDeclare = false;
-  };
+  : DECLARE { CurFun.isDeclare = true; } FnDeclareLinkage FunctionHeaderH {
+    $$ = CurFun.CurrentFunction;
+    CurFun.FunctionDone();
+    
+  }
+  ;
 
 //===----------------------------------------------------------------------===//
 //                        Rules to match Basic Blocks
 //===----------------------------------------------------------------------===//
 
-OptSideEffect : /* empty */ { $$ = new std::string(); }
-  | SIDEEFFECT;
+OptSideEffect 
+  : /* empty */ { $$ = false; }
+  | SIDEEFFECT { $$ = true; }
+  ;
 
 ConstValueRef 
-  : ESINT64VAL | EUINT64VAL | FPVAL | TRUETOK | FALSETOK | NULL_TOK | UNDEF
-  | ZEROINITIALIZER 
-  | '<' ConstVector '>' { 
-    $2->insert(0, "<");
-    *$2 += ">";
-    $$ = $2;
+    // A reference to a direct constant
+  : ESINT64VAL {    $$ = ValID::create($1); }
+  | EUINT64VAL { $$ = ValID::create($1); }
+  | FPVAL { $$ = ValID::create($1); } 
+  | TRUETOK { $$ = ValID::create(ConstantInt::get(Type::Int1Ty, true)); } 
+  | FALSETOK { $$ = ValID::create(ConstantInt::get(Type::Int1Ty, false)); }
+  | NULL_TOK { $$ = ValID::createNull(); }
+  | UNDEF { $$ = ValID::createUndef(); }
+  | ZEROINITIALIZER { $$ = ValID::createZeroInit(); }
+  | '<' ConstVector '>' { // Nonempty unsized packed vector
+    const Type *ETy = (*$2)[0].C->getType();
+    int NumElements = $2->size(); 
+    PackedType* pt = PackedType::get(ETy, NumElements);
+    PATypeHolder* PTy = new PATypeHolder(
+      HandleUpRefs(PackedType::get(ETy, NumElements)));
+    
+    // Verify all elements are correct type!
+    std::vector Elems;
+    for (unsigned i = 0; i < $2->size(); i++) {
+      Constant *C = (*$2)[i].C;
+      const Type *CTy = C->getType();
+      if (ETy != CTy)
+        error("Element #" + utostr(i) + " is not of type '" + 
+              ETy->getDescription() +"' as required!\nIt is of type '" +
+              CTy->getDescription() + "'");
+      Elems.push_back(C);
+    }
+    $$ = ValID::create(ConstantPacked::get(pt, Elems));
+    delete PTy; delete $2;
+  }
+  | ConstExpr {
+    $$ = ValID::create($1.C);
   }
-  | ConstExpr 
   | ASM_TOK OptSideEffect STRINGCONSTANT ',' STRINGCONSTANT {
-    if (!$2->empty()) {
-      *$1 += " " + *$2;
-    }
-    *$1 += " " + *$3 + ", " + *$5;
-    delete $2; delete $3; delete $5;
-    $$ = $1;
-  };
+    char *End = UnEscapeLexed($3, true);
+    std::string AsmStr = std::string($3, End);
+    End = UnEscapeLexed($5, true);
+    std::string Constraints = std::string($5, End);
+    $$ = ValID::createInlineAsm(AsmStr, Constraints, $2);
+    free($3);
+    free($5);
+  }
+  ;
 
-SymbolicValueRef : IntVal | Name ;
+// SymbolicValueRef - Reference to one of two ways of symbolically refering to
+// another value.
+//
+SymbolicValueRef 
+  : INTVAL {  $$ = ValID::create($1); }
+  | Name   {  $$ = ValID::create($1); }
+  ;
 
 // ValueRef - A reference to a definition... either constant or symbolic
 ValueRef 
-  : SymbolicValueRef {
-    $$ = new Value;
-    $$->val = $1;
-    $$->constant = false;
-    $$->type = 0;
-  }
-  | ConstValueRef {
-    $$ = new Value;
-    $$->val = $1;
-    $$->constant = true;
-    $$->type = 0;
-  }
+  : SymbolicValueRef | ConstValueRef
   ;
 
+
 // ResolvedVal - a   pair.  This is used only in cases where the
 // type immediately preceeds the value reference, and allows complex constant
 // pool references (for things like: 'ret [2 x int] [ int 12, int 42]')
-ResolvedVal : Types ValueRef {
-    $1 = $1->resolve();
-    std::string Name = getUniqueName($2->val, $1);
-    $$ = $2;
-    delete $$->val;
-    $$->val = new std::string($1->getNewTy() + " " + Name);
-    $$->type = $1;
-  };
+ResolvedVal 
+  : Types ValueRef { 
+    const Type *Ty = $1.T->get();
+    $$.S = $1.S;
+    $$.V = getVal(Ty, $2); 
+    delete $1.T;
+  }
+  ;
 
-BasicBlockList : BasicBlockList BasicBlock {
-    $$ = 0;
+BasicBlockList 
+  : BasicBlockList BasicBlock {
+    $$ = $1;
   }
-  | BasicBlock { // Do not allow functions with 0 basic blocks   
-    $$ = 0;
+  | FunctionHeader BasicBlock { // Do not allow functions with 0 basic blocks   
+    $$ = $1;
   };
 
 
 // Basic blocks are terminated by branching instructions: 
 // br, br/cc, switch, ret
 //
-BasicBlock : InstructionList BBTerminatorInst  {
-    $$ = 0;
-  };
+BasicBlock 
+  : InstructionList OptAssign BBTerminatorInst  {
+    setValueName($3, $2);
+    InsertValue($3);
+    $1->getInstList().push_back($3);
+    InsertValue($1);
+    $$ = $1;
+  }
+  ;
 
-InstructionList : InstructionList Inst {
-    *O << "    " << *$2 << '\n';
-    delete $2;
-    $$ = 0;
+InstructionList
+  : InstructionList Inst {
+    if ($2.I)
+      $1->getInstList().push_back($2.I);
+    $$ = $1;
   }
   | /* empty */ {
-    $$ = 0;
+    $$ = CurBB = getBBVal(ValID::create((int)CurFun.NextBBNum++), true);
+    // Make sure to move the basic block to the correct location in the
+    // function, instead of leaving it inserted wherever it was first
+    // referenced.
+    Function::BasicBlockListType &BBL = 
+      CurFun.CurrentFunction->getBasicBlockList();
+    BBL.splice(BBL.end(), BBL, $$);
   }
   | LABELSTR {
-    *O << *$1 << '\n';
-    delete $1;
-    $$ = 0;
-  };
+    $$ = CurBB = getBBVal(ValID::create($1), true);
+    // Make sure to move the basic block to the correct location in the
+    // function, instead of leaving it inserted wherever it was first
+    // referenced.
+    Function::BasicBlockListType &BBL = 
+      CurFun.CurrentFunction->getBasicBlockList();
+    BBL.splice(BBL.end(), BBL, $$);
+  }
+  ;
 
-Unwind : UNWIND | EXCEPT { $$ = $1; *$$ = "unwind"; } ;
+Unwind : UNWIND | EXCEPT;
 
-BBTerminatorInst : RET ResolvedVal {              // Return with a result...
-    *O << "    " << *$1 << ' ' << *$2->val << '\n';
-    delete $1; delete $2;
-    $$ = 0;
+BBTerminatorInst 
+  : RET ResolvedVal {              // Return with a result...
+    $$ = new ReturnInst($2.V);
   }
   | RET VOID {                                       // Return with no result...
-    *O << "    " << *$1 << ' ' << $2->getNewTy() << '\n';
-    delete $1;
-    $$ = 0;
+    $$ = new ReturnInst();
   }
   | BR LABEL ValueRef {                         // Unconditional Branch...
-    *O << "    " << *$1 << ' ' << $2->getNewTy() << ' ' << *$3->val << '\n';
-    delete $1; delete $3;
-    $$ = 0;
+    BasicBlock* tmpBB = getBBVal($3);
+    $$ = new BranchInst(tmpBB);
   }                                                  // Conditional Branch...
   | BR BOOL ValueRef ',' LABEL ValueRef ',' LABEL ValueRef {  
-    std::string Name = getUniqueName($3->val, $2);
-    *O << "    " << *$1 << ' ' << $2->getNewTy() << ' ' << Name << ", " 
-       << $5->getNewTy() << ' ' << *$6->val << ", " << $8->getNewTy() << ' ' 
-       << *$9->val << '\n';
-    delete $1; delete $3; delete $6; delete $9;
-    $$ = 0;
+    BasicBlock* tmpBBA = getBBVal($6);
+    BasicBlock* tmpBBB = getBBVal($9);
+    Value* tmpVal = getVal(Type::Int1Ty, $3);
+    $$ = new BranchInst(tmpBBA, tmpBBB, tmpVal);
   }
   | SWITCH IntType ValueRef ',' LABEL ValueRef '[' JumpTable ']' {
-    std::string Name = getUniqueName($3->val, $2);
-    *O << "    " << *$1 << ' ' << $2->getNewTy() << ' ' << Name << ", " 
-       << $5->getNewTy() << ' ' << *$6->val << " [" << *$8 << " ]\n";
-    delete $1; 
-    delete $3;
-    delete $6; 
+    Value* tmpVal = getVal($2.T, $3);
+    BasicBlock* tmpBB = getBBVal($6);
+    SwitchInst *S = new SwitchInst(tmpVal, tmpBB, $8->size());
+    $$ = S;
+    std::vector >::iterator I = $8->begin(),
+      E = $8->end();
+    for (; I != E; ++I) {
+      if (ConstantInt *CI = dyn_cast(I->first))
+          S->addCase(CI, I->second);
+      else
+        error("Switch case is constant, but not a simple integer");
+    }
     delete $8;
-    $$ = 0;
   }
   | SWITCH IntType ValueRef ',' LABEL ValueRef '[' ']' {
-    std::string Name = getUniqueName($3->val, $2);
-    *O << "    " << *$1 << ' ' << $2->getNewTy() << ' ' << Name << ", " 
-       << $5->getNewTy() << ' ' << *$6->val << "[]\n";
-    delete $1; 
-    delete $3; 
-    delete $6;
-    $$ = 0;
+    Value* tmpVal = getVal($2.T, $3);
+    BasicBlock* tmpBB = getBBVal($6);
+    SwitchInst *S = new SwitchInst(tmpVal, tmpBB, 0);
+    $$ = S;
   }
-  | OptAssign INVOKE OptCallingConv TypesV ValueRef '(' ValueRefListE ')'
+  | INVOKE OptCallingConv TypesV ValueRef '(' ValueRefListE ')'
     TO LABEL ValueRef Unwind LABEL ValueRef {
-    const Type* ResTy = getFunctionReturnType($4);
-    *O << "    ";
-    if (!$1->empty()) {
-      std::string Name = getUniqueName($1, ResTy);
-      *O << Name << " = ";
-    }
-    *O << *$2 << ' ' << *$3 << ' ' << $4->getNewTy() << ' ' << *$5->val << " (";
-    for (unsigned i = 0; i < $7->size(); ++i) {
-      Value* V = (*$7)[i];
-      *O << *V->val;
-      if (i+1 < $7->size())
-        *O << ", ";
-      delete V;
-    }
-    *O << ") " << *$9 << ' ' << $10->getNewTy() << ' ' << *$11->val << ' ' 
-       << *$12 << ' ' << $13->getNewTy() << ' ' << *$14->val << '\n';
-    delete $1; delete $2; delete $3; delete $5; delete $7; 
-    delete $9; delete $11; delete $12; delete $14; 
-    $$ = 0;
+    const PointerType *PFTy;
+    const FunctionType *Ty;
+
+    if (!(PFTy = dyn_cast($3.T->get())) ||
+        !(Ty = dyn_cast(PFTy->getElementType()))) {
+      // Pull out the types of all of the arguments...
+      std::vector ParamTypes;
+      if ($6) {
+        for (std::vector::iterator I = $6->begin(), E = $6->end();
+             I != E; ++I)
+          ParamTypes.push_back((*I).V->getType());
+      }
+      bool isVarArg = ParamTypes.size() && ParamTypes.back() == Type::VoidTy;
+      if (isVarArg) ParamTypes.pop_back();
+      Ty = FunctionType::get($3.T->get(), ParamTypes, isVarArg);
+      PFTy = PointerType::get(Ty);
+    }
+    Value *V = getVal(PFTy, $4);   // Get the function we're calling...
+    BasicBlock *Normal = getBBVal($10);
+    BasicBlock *Except = getBBVal($13);
+
+    // Create the call node...
+    if (!$6) {                                   // Has no arguments?
+      $$ = new InvokeInst(V, Normal, Except, std::vector());
+    } else {                                     // Has arguments?
+      // Loop through FunctionType's arguments and ensure they are specified
+      // correctly!
+      //
+      FunctionType::param_iterator I = Ty->param_begin();
+      FunctionType::param_iterator E = Ty->param_end();
+      std::vector::iterator ArgI = $6->begin(), ArgE = $6->end();
+
+      std::vector Args;
+      for (; ArgI != ArgE && I != E; ++ArgI, ++I) {
+        if ((*ArgI).V->getType() != *I)
+          error("Parameter " +(*ArgI).V->getName()+ " is not of type '" +
+                (*I)->getDescription() + "'");
+        Args.push_back((*ArgI).V);
+      }
+
+      if (I != E || (ArgI != ArgE && !Ty->isVarArg()))
+        error("Invalid number of parameters detected");
+
+      $$ = new InvokeInst(V, Normal, Except, Args);
+    }
+    cast($$)->setCallingConv($2);
+    delete $3.T;
+    delete $6;
   }
   | Unwind {
-    *O << "    " << *$1 << '\n';
-    delete $1;
-    $$ = 0;
+    $$ = new UnwindInst();
   }
   | UNREACHABLE {
-    *O << "    " << *$1 << '\n';
-    delete $1;
-    $$ = 0;
-  };
+    $$ = new UnreachableInst();
+  }
+  ;
 
-JumpTable : JumpTable IntType ConstValueRef ',' LABEL ValueRef {
-    *$1 += " " + $2->getNewTy() + " " + *$3 + ", " + $5->getNewTy() + " " + 
-           *$6->val;
-    delete $3; delete $6;
+JumpTable 
+  : JumpTable IntType ConstValueRef ',' LABEL ValueRef {
     $$ = $1;
+    Constant *V = cast(getExistingValue($2.T, $3));
+    
+    if (V == 0)
+      error("May only switch on a constant pool value");
+
+    BasicBlock* tmpBB = getBBVal($6);
+    $$->push_back(std::make_pair(V, tmpBB));
   }
   | IntType ConstValueRef ',' LABEL ValueRef {
-    $2->insert(0, $1->getNewTy() + " " );
-    *$2 += ", " + $4->getNewTy() + " " + *$5->val;
-    delete $5;
-    $$ = $2;
-  };
+    $$ = new std::vector >();
+    Constant *V = cast(getExistingValue($1.T, $2));
+
+    if (V == 0)
+      error("May only switch on a constant pool value");
+
+    BasicBlock* tmpBB = getBBVal($5);
+    $$->push_back(std::make_pair(V, tmpBB)); 
+  }
+  ;
 
 Inst 
   : OptAssign InstVal {
-    if (!$1->empty()) {
-      // Get a unique name for this value, based on its type.
-      std::string Name = getUniqueName($1, $2->type);
-      *$1 = Name + " = ";
-      if (deleteUselessCastFlag && *deleteUselessCastName == Name) {
-        // don't actually delete it, just comment it out
-        $1->insert(0, "; USELSS BITCAST: "); 
-        delete deleteUselessCastName;
-      }
+    bool omit = false;
+    if ($1)
+      if (BitCastInst *BCI = dyn_cast($2.I))
+        if (BCI->getSrcTy() == BCI->getDestTy() && 
+            BCI->getOperand(0)->getName() == $1)
+          // This is a useless bit cast causing a name redefinition. It is
+          // a bit cast from a type to the same type of an operand with the
+          // same name as the name we would give this instruction. Since this
+          // instruction results in no code generation, it is safe to omit
+          // the instruction. This situation can occur because of collapsed
+          // type planes. For example:
+          //   %X = add int %Y, %Z
+          //   %X = cast int %Y to uint
+          // After upgrade, this looks like:
+          //   %X = add i32 %Y, %Z
+          //   %X = bitcast i32 to i32
+          // The bitcast is clearly useless so we omit it.
+          omit = true;
+    if (omit) {
+      $$.I = 0;
+      $$.S = Signless;
+    } else {
+      setValueName($2.I, $1);
+      InsertValue($2.I);
+      $$ = $2;
     }
-    *$1 += *$2->val;
-    delete $2;
-    deleteUselessCastFlag = false;
-    $$ = $1; 
   };
 
-PHIList 
-  : Types '[' ValueRef ',' ValueRef ']' {    // Used for PHI nodes
-    std::string Name = getUniqueName($3->val, $1);
-    Name.insert(0, $1->getNewTy() + "[");
-    Name += "," + *$5->val + "]";
-    $$ = new Value;
-    $$->val = new std::string(Name);
-    $$->type = $1;
-    delete $3; delete $5;
+PHIList : Types '[' ValueRef ',' ValueRef ']' {    // Used for PHI nodes
+    $$.P = new std::list >();
+    $$.S = $1.S;
+    Value* tmpVal = getVal($1.T->get(), $3);
+    BasicBlock* tmpBB = getBBVal($5);
+    $$.P->push_back(std::make_pair(tmpVal, tmpBB));
+    delete $1.T;
   }
   | PHIList ',' '[' ValueRef ',' ValueRef ']' {
-    std::string Name = getUniqueName($4->val, $1->type);
-    *$1->val += ", [" + Name + "," + *$6->val + "]";
-    delete $4; 
-    delete $6;
     $$ = $1;
-  };
-
+    Value* tmpVal = getVal($1.P->front().first->getType(), $4);
+    BasicBlock* tmpBB = getBBVal($6);
+    $1.P->push_back(std::make_pair(tmpVal, tmpBB));
+  }
+  ;
 
-ValueRefList 
-  : ResolvedVal {
-    $$ = new ValueList();
+ValueRefList : ResolvedVal {    // Used for call statements, and memory insts...
+    $$ = new std::vector();
     $$->push_back($1);
   }
   | ValueRefList ',' ResolvedVal {
     $$ = $1;
-    $$->push_back($3);
+    $1->push_back($3);
   };
 
 // ValueRefListE - Just like ValueRefList, except that it may also be empty!
 ValueRefListE 
-  : ValueRefList  { $$ = $1; }
-  | /*empty*/ { $$ = new ValueList(); }
+  : ValueRefList 
+  | /*empty*/ { $$ = 0; }
   ;
 
 OptTailCall 
   : TAIL CALL {
-    *$1 += " " + *$2;
-    delete $2;
-    $$ = $1;
+    $$ = true;
+  }
+  | CALL {
+    $$ = false;
   }
-  | CALL 
   ;
 
-InstVal : ArithmeticOps Types ValueRef ',' ValueRef {
-    const char* op = getDivRemOpcode(*$1, $2); 
-    std::string Name1 = getUniqueName($3->val, $2);
-    std::string Name2 = getUniqueName($5->val, $2);
-    $$ = $3;
-    delete $$->val;
-    $$->val = new std::string(op);
-    *$$->val += " " + $2->getNewTy() + " " + Name1 + ", " + Name2;
-    $$->type = $2;
-    delete $1; delete $5;
+InstVal 
+  : ArithmeticOps Types ValueRef ',' ValueRef {
+    const Type* Ty = $2.T->get();
+    if (!Ty->isInteger() && !Ty->isFloatingPoint() && !isa(Ty))
+      error("Arithmetic operator requires integer, FP, or packed operands");
+    if (isa(Ty) && 
+        ($1 == URemOp || $1 == SRemOp || $1 == FRemOp || $1 == RemOp))
+      error("Remainder not supported on packed types");
+    // Upgrade the opcode from obsolete versions before we do anything with it.
+    Instruction::BinaryOps Opcode = getBinaryOp($1, Ty, $2.S);
+    Value* val1 = getVal(Ty, $3); 
+    Value* val2 = getVal(Ty, $5);
+    $$.I = BinaryOperator::create(Opcode, val1, val2);
+    if ($$.I == 0)
+      error("binary operator returned null");
+    $$.S = $2.S;
+    delete $2.T;
   }
   | LogicalOps Types ValueRef ',' ValueRef {
-    std::string Name1 = getUniqueName($3->val, $2);
-    std::string Name2 = getUniqueName($5->val, $2);
-    *$1 += " " + $2->getNewTy() + " " + Name1 + ", " + Name2;
-    $$ = $3;
-    delete $$->val;
-    $$->val = $1;
-    $$->type = $2;
-    delete $5;
+    const Type *Ty = $2.T->get();
+    if (!Ty->isInteger()) {
+      if (!isa(Ty) ||
+          !cast(Ty)->getElementType()->isInteger())
+        error("Logical operator requires integral operands");
+    }
+    Instruction::BinaryOps Opcode = getBinaryOp($1, Ty, $2.S);
+    Value* tmpVal1 = getVal(Ty, $3);
+    Value* tmpVal2 = getVal(Ty, $5);
+    $$.I = BinaryOperator::create(Opcode, tmpVal1, tmpVal2);
+    if ($$.I == 0)
+      error("binary operator returned null");
+    $$.S = $2.S;
+    delete $2.T;
   }
   | SetCondOps Types ValueRef ',' ValueRef {
-    std::string Name1 = getUniqueName($3->val, $2);
-    std::string Name2 = getUniqueName($5->val, $2);
-    *$1 = getCompareOp(*$1, $2);
-    *$1 += " " + $2->getNewTy() + " " + Name1 + ", " + Name2;
-    $$ = $3;
-    delete $$->val;
-    $$->val = $1;
-    $$->type = Type::get("i1",BoolTy);
-    delete $5;
+    const Type* Ty = $2.T->get();
+    if(isa(Ty))
+      error("PackedTypes currently not supported in setcc instructions");
+    unsigned short pred;
+    Instruction::OtherOps Opcode = getCompareOp($1, pred, Ty, $2.S);
+    Value* tmpVal1 = getVal(Ty, $3);
+    Value* tmpVal2 = getVal(Ty, $5);
+    $$.I = CmpInst::create(Opcode, pred, tmpVal1, tmpVal2);
+    if ($$.I == 0)
+      error("binary operator returned null");
+    $$.S = Unsigned;
+    delete $2.T;
   }
   | ICMP IPredicates Types ValueRef ',' ValueRef {
-    std::string Name1 = getUniqueName($4->val, $3);
-    std::string Name2 = getUniqueName($6->val, $3);
-    *$1 += " " + *$2 + " " + $3->getNewTy() + " " + Name1 + "," + Name2;
-    $$ = $4;
-    delete $$->val;
-    $$->val = $1;
-    $$->type = Type::get("i1",BoolTy);
-    delete $2; delete $6;
+    const Type *Ty = $3.T->get();
+    if (isa(Ty)) 
+      error("PackedTypes currently not supported in icmp instructions");
+    else if (!Ty->isInteger() && !isa(Ty))
+      error("icmp requires integer or pointer typed operands");
+    Value* tmpVal1 = getVal(Ty, $4);
+    Value* tmpVal2 = getVal(Ty, $6);
+    $$.I = new ICmpInst($2, tmpVal1, tmpVal2);
+    $$.S = Unsigned;
+    delete $3.T;
   }
   | FCMP FPredicates Types ValueRef ',' ValueRef {
-    std::string Name1 = getUniqueName($4->val, $3);
-    std::string Name2 = getUniqueName($6->val, $3);
-    *$1 += " " + *$2 + " " + $3->getNewTy() + " " + Name1 + "," + Name2;
-    $$ = $4;
-    delete $$->val;
-    $$->val = $1;
-    $$->type = Type::get("i1",BoolTy);
-    delete $2; delete $6;
+    const Type *Ty = $3.T->get();
+    if (isa(Ty))
+      error("PackedTypes currently not supported in fcmp instructions");
+    else if (!Ty->isFloatingPoint())
+      error("fcmp instruction requires floating point operands");
+    Value* tmpVal1 = getVal(Ty, $4);
+    Value* tmpVal2 = getVal(Ty, $6);
+    $$.I = new FCmpInst($2, tmpVal1, tmpVal2);
+    $$.S = Unsigned;
+    delete $3.T;
+  }
+  | NOT ResolvedVal {
+    warning("Use of obsolete 'not' instruction: Replacing with 'xor");
+    const Type *Ty = $2.V->getType();
+    Value *Ones = ConstantInt::getAllOnesValue(Ty);
+    if (Ones == 0)
+      error("Expected integral type for not instruction");
+    $$.I = BinaryOperator::create(Instruction::Xor, $2.V, Ones);
+    if ($$.I == 0)
+      error("Could not create a xor instruction");
+    $$.S = $2.S
   }
   | ShiftOps ResolvedVal ',' ResolvedVal {
-    const char* shiftop = $1->c_str();
-    if (*$1 == "shr")
-      shiftop = ($2->type->isUnsigned()) ? "lshr" : "ashr";
-    std::string *val = new std::string(shiftop);
-    *val += " " + *$2->val + ", " + *$4->val;
-    $$ = $2;
-    delete $$->val;
-    $$->val = val;
-    delete $1; delete $4;
+    if (!$4.V->getType()->isInteger() ||
+        cast($4.V->getType())->getBitWidth() != 8)
+      error("Shift amount must be int8");
+    if (!$2.V->getType()->isInteger())
+      error("Shift constant expression requires integer operand");
+    $$.I = new ShiftInst(getOtherOp($1, $2.S), $2.V, $4.V);
+    $$.S = $2.S;
   }
   | CastOps ResolvedVal TO Types {
-    std::string source = *$2->val;
-    const Type* SrcTy = $2->type->resolve();
-    const Type* DstTy = $4->resolve();
-    $$ = $2;
-    delete $$->val;
-    $$->val = new std::string();
-    $$->type = DstTy;
-    if (*$1 == "cast") {
-      *$$->val += getCastUpgrade(source, SrcTy, DstTy, false);
-    } else {
-      *$$->val += *$1 + " " + source + " to " + DstTy->getNewTy();
-    }
-    // Check to see if this is a useless cast of a value to the same name
-    // and the same type. Such casts will probably cause redefinition errors
-    // when assembled and perform no code gen action so just remove them.
-    if (*$1 == "cast" || *$1 == "bitcast")
-      if (SrcTy->isInteger() && DstTy->isInteger() &&
-          SrcTy->getBitWidth() == DstTy->getBitWidth()) {
-        deleteUselessCastFlag = true; // Flag the "Inst" rule
-        deleteUselessCastName = new std::string(*$2->val); // save the name
-        size_t pos = deleteUselessCastName->find_first_of("%\"",0);
-        if (pos != std::string::npos) {
-          // remove the type portion before val
-          deleteUselessCastName->erase(0, pos);
-        }
-      }
-    delete $1; 
-    delete $3;
+    const Type *DstTy = $4.T->get();
+    if (!DstTy->isFirstClassType())
+      error("cast instruction to a non-primitive type: '" +
+            DstTy->getDescription() + "'");
+    $$.I = cast(getCast($1, $2.V, $2.S, DstTy, $4.S, true));
+    $$.S = $4.S;
+    delete $4.T;
   }
   | SELECT ResolvedVal ',' ResolvedVal ',' ResolvedVal {
-    *$1 += " " + *$2->val + ", " + *$4->val + ", " + *$6->val;
-    $$ = $2;
-    delete $$->val;
-    $$->val = $1;
-    $$->type = $4->type;
-    delete $4;
-    delete $6;
+    if (!$2.V->getType()->isInteger() ||
+        cast($2.V->getType())->getBitWidth() != 1)
+      error("select condition must be bool");
+    if ($4.V->getType() != $6.V->getType())
+      error("select value types should match");
+    $$.I = new SelectInst($2.V, $4.V, $6.V);
+    $$.S = $2.S;
   }
   | VAARG ResolvedVal ',' Types {
-    *$1 += " " + *$2->val + ", " + $4->getNewTy();
-    $$ = $2;
-    delete $$->val;
-    $$->val = $1;
-    $$->type = $4;
+    const Type *Ty = $4.T->get();
+    NewVarArgs = true;
+    $$.I = new VAArgInst($2.V, Ty);
+    $$.S = $4.S;
+    delete $4.T;
+  }
+  | VAARG_old ResolvedVal ',' Types {
+    const Type* ArgTy = $2.V->getType();
+    const Type* DstTy = $4.T->get();
+    ObsoleteVarArgs = true;
+    Function* NF = cast(CurModule.CurrentModule->
+      getOrInsertFunction("llvm.va_copy", ArgTy, ArgTy, (Type *)0));
+
+    //b = vaarg a, t -> 
+    //foo = alloca 1 of t
+    //bar = vacopy a 
+    //store bar -> foo
+    //b = vaarg foo, t
+    AllocaInst* foo = new AllocaInst(ArgTy, 0, "vaarg.fix");
+    CurBB->getInstList().push_back(foo);
+    CallInst* bar = new CallInst(NF, $2.V);
+    CurBB->getInstList().push_back(bar);
+    CurBB->getInstList().push_back(new StoreInst(bar, foo));
+    $$.I = new VAArgInst(foo, DstTy);
+    $$.S = $4.S;
+    delete $4.T;
+  }
+  | VANEXT_old ResolvedVal ',' Types {
+    const Type* ArgTy = $2.V->getType();
+    const Type* DstTy = $4.T->get();
+    ObsoleteVarArgs = true;
+    Function* NF = cast(CurModule.CurrentModule->
+      getOrInsertFunction("llvm.va_copy", ArgTy, ArgTy, (Type *)0));
+
+    //b = vanext a, t ->
+    //foo = alloca 1 of t
+    //bar = vacopy a
+    //store bar -> foo
+    //tmp = vaarg foo, t
+    //b = load foo
+    AllocaInst* foo = new AllocaInst(ArgTy, 0, "vanext.fix");
+    CurBB->getInstList().push_back(foo);
+    CallInst* bar = new CallInst(NF, $2.V);
+    CurBB->getInstList().push_back(bar);
+    CurBB->getInstList().push_back(new StoreInst(bar, foo));
+    Instruction* tmp = new VAArgInst(foo, DstTy);
+    CurBB->getInstList().push_back(tmp);
+    $$.I = new LoadInst(foo);
+    $$.S = $4.S;
+    delete $4.T;
   }
   | EXTRACTELEMENT ResolvedVal ',' ResolvedVal {
-    *$1 += " " + *$2->val + ", " + *$4->val;
-    $$ = $2;
-    delete $$->val;
-    $$->val = $1;
-    $$->type = $$->type->resolve();
-    $$->type = $$->type->getElementType();
-    delete $4;
+    if (!ExtractElementInst::isValidOperands($2.V, $4.V))
+      error("Invalid extractelement operands");
+    $$.I = new ExtractElementInst($2.V, $4.V);
+    $$.S = $2.S;
   }
   | INSERTELEMENT ResolvedVal ',' ResolvedVal ',' ResolvedVal {
-    *$1 += " " + *$2->val + ", " + *$4->val + ", " + *$6->val;
-    $$ = $2;
-    delete $$->val;
-    $$->val = $1;
-    delete $4; delete $6;
+    if (!InsertElementInst::isValidOperands($2.V, $4.V, $6.V))
+      error("Invalid insertelement operands");
+    $$.I = new InsertElementInst($2.V, $4.V, $6.V);
+    $$.S = $2.S;
   }
   | SHUFFLEVECTOR ResolvedVal ',' ResolvedVal ',' ResolvedVal {
-    *$1 += " " + *$2->val + ", " + *$4->val + ", " + *$6->val;
-    $$ = $2;
-    delete $$->val;
-    $$->val = $1;
-    delete $4; delete $6;
+    if (!ShuffleVectorInst::isValidOperands($2.V, $4.V, $6.V))
+      error("Invalid shufflevector operands");
+    $$.I = new ShuffleVectorInst($2.V, $4.V, $6.V);
+    $$.S = $2.S;
   }
   | PHI_TOK PHIList {
-    *$1 += " " + *$2->val;
-    $$ = $2;
-    delete $2->val;
-    $$->val = $1;
+    const Type *Ty = $2.P->front().first->getType();
+    if (!Ty->isFirstClassType())
+      error("PHI node operands must be of first class type");
+    PHINode *PHI = new PHINode(Ty);
+    PHI->reserveOperandSpace($2.P->size());
+    while ($2.P->begin() != $2.P->end()) {
+      if ($2.P->front().first->getType() != Ty) 
+        error("All elements of a PHI node must be of the same type");
+      PHI->addIncoming($2.P->front().first, $2.P->front().second);
+      $2.P->pop_front();
+    }
+    $$.I = PHI;
+    $$.S = $2.S;
+    delete $2.P;  // Free the list...
   }
   | OptTailCall OptCallingConv TypesV ValueRef '(' ValueRefListE ')'  {
-    // map llvm.isunordered to "fcmp uno" 
-    $$ = new Value;
-    if (*$4->val == "%llvm.isunordered.f32" ||
-        *$4->val == "%llvm.isunordered.f64") {
-      $$->val = new std::string( "fcmp uno " + *(*$6)[0]->val + ", ");
-      size_t pos = (*$6)[1]->val->find(' ');
-      assert(pos != std::string::npos && "no space?");
-      *$$->val += (*$6)[1]->val->substr(pos+1);
-      $$->type = Type::get("i1", BoolTy);
+
+    // Handle the short call syntax
+    const PointerType *PFTy;
+    const FunctionType *FTy;
+    if (!(PFTy = dyn_cast($3.T->get())) ||
+        !(FTy = dyn_cast(PFTy->getElementType()))) {
+      // Pull out the types of all of the arguments...
+      std::vector ParamTypes;
+      if ($6) {
+        for (std::vector::iterator I = $6->begin(), E = $6->end();
+             I != E; ++I)
+          ParamTypes.push_back((*I).V->getType());
+      }
+
+      bool isVarArg = ParamTypes.size() && ParamTypes.back() == Type::VoidTy;
+      if (isVarArg) ParamTypes.pop_back();
+
+      const Type *RetTy = $3.T->get();
+      if (!RetTy->isFirstClassType() && RetTy != Type::VoidTy)
+        error("Functions cannot return aggregate types");
+
+      FTy = FunctionType::get(RetTy, ParamTypes, isVarArg);
+      PFTy = PointerType::get(FTy);
+    }
+
+    // First upgrade any intrinsic calls.
+    std::vector Args;
+    if ($6)
+      for (unsigned i = 0, e = $6->size(); i < e; ++i) 
+        Args.push_back((*$6)[i].V);
+    Instruction *Inst = upgradeIntrinsicCall(FTy, $4, Args);
+
+    // If we got an upgraded intrinsic
+    if (Inst) {
+      $$.I = Inst;
+      $$.S = Signless;
     } else {
-      static unsigned upgradeCount = 1;
-      if (*$4->val == "%llvm.va_start" || *$4->val == "%llvm.va_end") {
-        if (!$6->empty()) {
-          std::string name("%va_upgrade");
-          name += llvm::utostr(upgradeCount++);
-          $1->insert(0, name + " = bitcast " + *(*$6)[0]->val + " to i8*\n    ");
-          *(*$6)[0]->val = "i8* " + name;
-          (*$6)[0]->type = Type::get("i8", UByteTy)->getPointerType();
-        }
-      } else if (*$4->val == "%llvm.va_copy") {
-        std::string name0("%va_upgrade");
-        name0 += llvm::utostr(upgradeCount++);
-        std::string name1("%va_upgrade");
-        name1 += llvm::utostr(upgradeCount++);
-        $1->insert(0, name0 + " = bitcast " + *(*$6)[0]->val + " to i8*\n    " +
-                      name1 + " = bitcast " + *(*$6)[1]->val + " to i8*\n    ");
-        *(*$6)[0]->val = "i8* " + name0;
-        (*$6)[0]->type = Type::get("i8", UByteTy)->getPointerType();
-        *(*$6)[1]->val = "i8* " + name1;
-        (*$6)[0]->type = Type::get("i8", UByteTy)->getPointerType();
-      }
-      if (!$2->empty())
-        *$1 += " " + *$2;
-      if (!$1->empty())
-        *$1 += " ";
-      *$1 += $3->getNewTy() + " " + *$4->val + "(";
-      for (unsigned i = 0; i < $6->size(); ++i) {
-        Value* V = (*$6)[i];
-        *$1 += *V->val;
-        if (i+1 < $6->size())
-          *$1 += ", ";
-        delete V;
+      // Get the function we're calling
+      Value *V = getVal(PFTy, $4);
+
+      // Check the argument values match
+      if (!$6) {                                   // Has no arguments?
+        // Make sure no arguments is a good thing!
+        if (FTy->getNumParams() != 0)
+          error("No arguments passed to a function that expects arguments");
+      } else {                                     // Has arguments?
+        // Loop through FunctionType's arguments and ensure they are specified
+        // correctly!
+        //
+        FunctionType::param_iterator I = FTy->param_begin();
+        FunctionType::param_iterator E = FTy->param_end();
+        std::vector::iterator ArgI = $6->begin(), ArgE = $6->end();
+
+        for (; ArgI != ArgE && I != E; ++ArgI, ++I)
+          if ((*ArgI).V->getType() != *I)
+            error("Parameter " +(*ArgI).V->getName()+ " is not of type '" +
+                  (*I)->getDescription() + "'");
+
+        if (I != E || (ArgI != ArgE && !FTy->isVarArg()))
+          error("Invalid number of parameters detected");
       }
-      *$1 += ")";
-      $$ = new Value;
-      $$->val = $1;
-      $$->type = getFunctionReturnType($3);
+
+      // Create the call instruction
+      CallInst *CI = new CallInst(V, Args);
+      CI->setTailCall($1);
+      CI->setCallingConv($2);
+      $$.I = CI;
+      $$.S = $3.S;
     }
-    delete $2; delete $4; delete $6;
+    delete $3.T;
+    delete $6;
+  }
+  | MemoryInst {
+    $$ = $1;
   }
-  | MemoryInst ;
+  ;
 
 
 // IndexList - List of indices for GEP based instructions...
 IndexList 
-  : ',' ValueRefList { $$ = $2; }
-  | /* empty */ {  $$ = new ValueList(); }
+  : ',' ValueRefList { $$ = $2; } 
+  | /* empty */ { $$ = new std::vector(); }
   ;
 
 OptVolatile 
-  : VOLATILE 
-  | /* empty */ { $$ = new std::string(); }
+  : VOLATILE { $$ = true; }
+  | /* empty */ { $$ = false; }
   ;
 
-MemoryInst : MALLOC Types OptCAlign {
-    *$1 += " " + $2->getNewTy();
-    if (!$3->empty())
-      *$1 += " " + *$3;
-    $$ = new Value;
-    $$->val = $1;
-    $$->type = $2->getPointerType();
-    delete $3;
+MemoryInst 
+  : MALLOC Types OptCAlign {
+    const Type *Ty = $2.T->get();
+    $$.S = $2.S;
+    $$.I = new MallocInst(Ty, 0, $3);
+    delete $2.T;
   }
   | MALLOC Types ',' UINT ValueRef OptCAlign {
-    std::string Name = getUniqueName($5->val, $4);
-    *$1 += " " + $2->getNewTy() + ", " + $4->getNewTy() + " " + Name;
-    if (!$6->empty())
-      *$1 += " " + *$6;
-    $$ = new Value;
-    $$->val = $1;
-    $$->type = $2->getPointerType();
-    delete $5; delete $6;
+    const Type *Ty = $2.T->get();
+    $$.S = $2.S;
+    $$.I = new MallocInst(Ty, getVal($4.T, $5), $6);
+    delete $2.T;
   }
   | ALLOCA Types OptCAlign {
-    *$1 += " " + $2->getNewTy();
-    if (!$3->empty())
-      *$1 += " " + *$3;
-    $$ = new Value;
-    $$->val = $1;
-    $$->type = $2->getPointerType();
-    delete $3;
+    const Type *Ty = $2.T->get();
+    $$.S = $2.S;
+    $$.I = new AllocaInst(Ty, 0, $3);
+    delete $2.T;
   }
   | ALLOCA Types ',' UINT ValueRef OptCAlign {
-    std::string Name = getUniqueName($5->val, $4);
-    *$1 += " " + $2->getNewTy() + ", " + $4->getNewTy() + " " + Name;
-    if (!$6->empty())
-      *$1 += " " + *$6;
-    $$ = $5;
-    delete $$->val;
-    $$->val = $1;
-    $$->type = $2->getPointerType();
-    delete $6;
+    const Type *Ty = $2.T->get();
+    $$.S = $2.S;
+    $$.I = new AllocaInst(Ty, getVal($4.T, $5), $6);
+    delete $2.T;
   }
   | FREE ResolvedVal {
-    *$1 += " " + *$2->val;
-    $$ = $2;
-    delete $2->val;
-    $$->val = $1;
-    $$->type = Type::get("void", VoidTy); 
+    const Type *PTy = $2.V->getType();
+    if (!isa(PTy))
+      error("Trying to free nonpointer type '" + PTy->getDescription() + "'");
+    $$.I = new FreeInst($2.V);
+    $$.S = Signless;
   }
   | OptVolatile LOAD Types ValueRef {
-    std::string Name = getUniqueName($4->val, $3);
-    if (!$1->empty())
-      *$1 += " ";
-    *$1 += *$2 + " " + $3->getNewTy() + " " + Name;
-    $$ = $4;
-    delete $$->val;
-    $$->val = $1;
-    $$->type = $3->getElementType();
-    delete $2;
+    const Type* Ty = $3.T->get();
+    $$.S = $3.S;
+    if (!isa(Ty))
+      error("Can't load from nonpointer type: " + Ty->getDescription());
+    if (!cast(Ty)->getElementType()->isFirstClassType())
+      error("Can't load from pointer of non-first-class type: " +
+                     Ty->getDescription());
+    Value* tmpVal = getVal(Ty, $4);
+    $$.I = new LoadInst(tmpVal, "", $1);
+    delete $3.T;
   }
   | OptVolatile STORE ResolvedVal ',' Types ValueRef {
-    std::string Name = getUniqueName($6->val, $5);
-    if (!$1->empty())
-      *$1 += " ";
-    *$1 += *$2 + " " + *$3->val + ", " + $5->getNewTy() + " " + Name;
-    $$ = $3;
-    delete $$->val;
-    $$->val = $1;
-    $$->type = Type::get("void", VoidTy);
-    delete $2; delete $6;
+    const PointerType *PTy = dyn_cast($5.T->get());
+    if (!PTy)
+      error("Can't store to a nonpointer type: " + 
+             $5.T->get()->getDescription());
+    const Type *ElTy = PTy->getElementType();
+    if (ElTy != $3.V->getType())
+      error("Can't store '" + $3.V->getType()->getDescription() +
+            "' into space of type '" + ElTy->getDescription() + "'");
+    Value* tmpVal = getVal(PTy, $6);
+    $$.I = new StoreInst($3.V, tmpVal, $1);
+    $$.S = Signless;
+    delete $5.T;
   }
   | GETELEMENTPTR Types ValueRef IndexList {
-    std::string Name = getUniqueName($3->val, $2);
-    // Upgrade the indices
-    for (unsigned i = 0; i < $4->size(); ++i) {
-      Value* V = (*$4)[i];
-      if (V->type->isUnsigned() && !V->isConstant() && 
-          V->type->getBitWidth() < 64) {
-        *O << "    %gep_upgrade" << UniqueNameCounter << " = zext " << *V->val 
-           << " to i64\n";
-        *V->val = "i64 %gep_upgrade" + llvm::utostr(UniqueNameCounter++);
-        V->type = Type::get("i64",ULongTy);
-      }
-    }
-    *$1 += " " + $2->getNewTy() + " " + Name;
-    for (unsigned i = 0; i < $4->size(); ++i) {
-      Value* V = (*$4)[i];
-      *$1 += ", " + *V->val;
-    }
-    $$ = $3;
-    delete $$->val;
-    $$->val = $1;
-    $$->type = getGEPIndexedType($2,$4); 
-    for (unsigned i = 0; i < $4->size(); ++i)
-      delete (*$4)[i];
+    const Type* Ty = $2.T->get();
+    if (!isa(Ty))
+      error("getelementptr insn requires pointer operand");
+
+    std::vector VIndices;
+    upgradeGEPIndices(Ty, $4, VIndices);
+
+    Value* tmpVal = getVal(Ty, $3);
+    $$.I = new GetElementPtrInst(tmpVal, VIndices);
+    $$.S = Signless;
+    delete $2.T;
     delete $4;
   };
 
+
 %%
 
 int yyerror(const char *ErrorMsg) {
   std::string where 
     = std::string((CurFilename == "-") ? std::string("") : CurFilename)
-                  + ":" + llvm::utostr((unsigned) Upgradelineno) + ": ";
-  std::string errMsg = where + "error: " + std::string(ErrorMsg) + 
-                       " while reading ";
-  if (yychar == YYEMPTY || yychar == 0)
-    errMsg += "end-of-file.";
-  else
-    errMsg += "token: '" + std::string(Upgradetext, Upgradeleng) + "'";
+                  + ":" + llvm::utostr((unsigned) Upgradelineno-1) + ": ";
+  std::string errMsg = where + "error: " + std::string(ErrorMsg);
+  if (yychar != YYEMPTY && yychar != 0)
+    errMsg += " while reading token '" + std::string(Upgradetext, Upgradeleng) +
+              "'.";
   std::cerr << "llvm-upgrade: " << errMsg << '\n';
-  *O << "llvm-upgrade parse failed.\n";
+  std::cout << "llvm-upgrade: parse failed.\n";
   exit(1);
 }
 
 void warning(const std::string& ErrorMsg) {
   std::string where 
     = std::string((CurFilename == "-") ? std::string("") : CurFilename)
-                  + ":" + llvm::utostr((unsigned) Upgradelineno) + ": ";
-  std::string errMsg = where + "warning: " + std::string(ErrorMsg) + 
-                       " while reading ";
-  if (yychar == YYEMPTY || yychar == 0)
-    errMsg += "end-of-file.";
-  else
-    errMsg += "token: '" + std::string(Upgradetext, Upgradeleng) + "'";
+                  + ":" + llvm::utostr((unsigned) Upgradelineno-1) + ": ";
+  std::string errMsg = where + "warning: " + std::string(ErrorMsg);
+  if (yychar != YYEMPTY && yychar != 0)
+    errMsg += " while reading token '" + std::string(Upgradetext, Upgradeleng) +
+              "'.";
   std::cerr << "llvm-upgrade: " << errMsg << '\n';
 }
+
+void error(const std::string& ErrorMsg, int LineNo) {
+  if (LineNo == -1) LineNo = Upgradelineno;
+  Upgradelineno = LineNo;
+  yyerror(ErrorMsg.c_str());
+}
+


Index: llvm/tools/llvm-upgrade/llvm-upgrade.cpp
diff -u llvm/tools/llvm-upgrade/llvm-upgrade.cpp:1.7 llvm/tools/llvm-upgrade/llvm-upgrade.cpp:1.8
--- llvm/tools/llvm-upgrade/llvm-upgrade.cpp:1.7	Fri Jan  5 11:19:32 2007
+++ llvm/tools/llvm-upgrade/llvm-upgrade.cpp	Fri Jan 26 02:19:09 2007
@@ -20,6 +20,8 @@
 //===----------------------------------------------------------------------===//
 
 #include "UpgradeInternals.h"
+#include "llvm/Module.h"
+#include "llvm/Bytecode/Writer.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Streams.h"
@@ -45,7 +47,11 @@
          cl::init(false));
 
 static cl::opt
-Debug("debug", cl::desc("Print debug output from yacc parser"),cl::Hidden,
+Debug("debug-upgrade-yacc", cl::desc("Print debug output from yacc parser"),
+      cl::Hidden, cl::init(false));
+
+static cl::opt
+EmitByteCode("emit-bytecode", cl::desc("Emit bytecode instead of assembly"),
     cl::init(false));
 
 int main(int argc, char **argv) {
@@ -119,7 +125,20 @@
       return 1;
     }
 
-    UpgradeAssembly(InputFilename, *In, *Out, Debug, AddAttrs);
+    Module *M = UpgradeAssembly(InputFilename, *In, Debug, AddAttrs);
+    if (!M) {
+      cerr << argv[0] << ": No module returned from assembly parsing\n";
+      if (!EmitByteCode)
+        *Out << argv[0] << ": parse failed.";
+      exit(1);
+    }
+
+    // Finally, print the module on the output stream.
+    if (EmitByteCode) {
+      OStream OS(*Out);
+      WriteBytecodeToFile(M, OS);
+    } else
+      M->print(Out);
 
   } catch (const std::string& caught_message) {
     cerr << argv[0] << ": " << caught_message << "\n";





From reid at x10sys.com  Fri Jan 26 02:26:03 2007
From: reid at x10sys.com (Reid Spencer)
Date: Fri, 26 Jan 2007 02:26:03 -0600
Subject: [llvm-commits] CVS:
	llvm/test/Transforms/FunctionResolve/2002-08-19-ResolveGlobalVars.ll
	2002-08-19-ResolveGlobalVarsEasier.ll
	2003-10-21-GlobalResolveHack.ll
Message-ID: <200701260826.l0Q8Q3uf031670@zion.cs.uiuc.edu>



Changes in directory llvm/test/Transforms/FunctionResolve:

2002-08-19-ResolveGlobalVars.ll updated: 1.7 -> 1.8
2002-08-19-ResolveGlobalVarsEasier.ll updated: 1.5 -> 1.6
2003-10-21-GlobalResolveHack.ll updated: 1.3 -> 1.4
---
Log message:

For PR761: http://llvm.org/PR761 :
Remove "target endian/pointersize" or add "target datalayout" to make
the test parse properly or set the datalayout because defaults changes.

For PR645: http://llvm.org/PR645 :
Make global names use the @ prefix.

For llvm-upgrade changes:
Fix test cases or completely remove use of llvm-upgrade for test cases 
that cannot survive the new renaming or upgrade capabilities. 



---
Diffs of the changes:  (+18 -20)

 2002-08-19-ResolveGlobalVars.ll       |   12 ++++++------
 2002-08-19-ResolveGlobalVarsEasier.ll |   10 +++++-----
 2003-10-21-GlobalResolveHack.ll       |   16 +++++++---------
 3 files changed, 18 insertions(+), 20 deletions(-)


Index: llvm/test/Transforms/FunctionResolve/2002-08-19-ResolveGlobalVars.ll
diff -u llvm/test/Transforms/FunctionResolve/2002-08-19-ResolveGlobalVars.ll:1.7 llvm/test/Transforms/FunctionResolve/2002-08-19-ResolveGlobalVars.ll:1.8
--- llvm/test/Transforms/FunctionResolve/2002-08-19-ResolveGlobalVars.ll:1.7	Fri Dec  1 22:23:09 2006
+++ llvm/test/Transforms/FunctionResolve/2002-08-19-ResolveGlobalVars.ll	Fri Jan 26 02:25:06 2007
@@ -1,17 +1,17 @@
 ; Test that: extern int X[]  and int X[] = { 1, 2, 3, 4 } are resolved 
 ; correctly.
 ;
-; RUN: llvm-upgrade < %s | llvm-as | opt -funcresolve | llvm-dis | not grep external
+; RUN: llvm-as < %s | opt -funcresolve | llvm-dis | not grep external
 
-%X = external global [0 x int]
-%X = global [4 x int] [ int 1, int 2, int 3, int 4 ]
+ at X = external global [0 x int]
+ at X = global [4 x int] [ int 1, int 2, int 3, int 4 ]
 
 implementation   ; Functions:
 
-int %foo(int %x) {
+int @foo(int %x) {
 bb1:                                    ;[#uses=0]
-	store int 5, int* getelementptr ([0 x int]* %X, long 0, long 2)
-	%F = getelementptr [0 x int]* %X, long 0, long 2
+	store int 5, int* getelementptr ([0 x int]* @X, long 0, long 2)
+	%F = getelementptr [0 x int]* @X, long 0, long 2
 	%val = load int* %F
         ret int %val
 }


Index: llvm/test/Transforms/FunctionResolve/2002-08-19-ResolveGlobalVarsEasier.ll
diff -u llvm/test/Transforms/FunctionResolve/2002-08-19-ResolveGlobalVarsEasier.ll:1.5 llvm/test/Transforms/FunctionResolve/2002-08-19-ResolveGlobalVarsEasier.ll:1.6
--- llvm/test/Transforms/FunctionResolve/2002-08-19-ResolveGlobalVarsEasier.ll:1.5	Fri Dec  1 22:23:09 2006
+++ llvm/test/Transforms/FunctionResolve/2002-08-19-ResolveGlobalVarsEasier.ll	Fri Jan 26 02:25:06 2007
@@ -1,19 +1,19 @@
 ; Test that: extern int X[]  and int X[] = { 1, 2, 3, 4 } are resolved 
 ; correctly.  This doesn't have constantexprs
 ;
-; RUN: llvm-upgrade < %s | llvm-as | opt -funcresolve | llvm-dis | not grep external
+; RUN: llvm-as < %s | opt -funcresolve | llvm-dis | not grep external
 ;
 
-%X = external global [0 x int]
-%X = global [4 x int] [ int 1, int 2, int 3, int 4 ]
+ at X = external global [0 x int]
+ at X = global [4 x int] [ int 1, int 2, int 3, int 4 ]
 
 implementation   ; Functions:
 
 int %foo(int %x) {
 bb1:                                    ;[#uses=0]
-	%G = getelementptr [0 x int]* %X, long 0, long 1
+	%G = getelementptr [0 x int]* @X, long 0, long 1
 	store int 5, int* %G
-	%F = getelementptr [0 x int]* %X, long 0, long 2
+	%F = getelementptr [0 x int]* @X, long 0, long 2
 	%val = load int* %F
         ret int %val
 }


Index: llvm/test/Transforms/FunctionResolve/2003-10-21-GlobalResolveHack.ll
diff -u llvm/test/Transforms/FunctionResolve/2003-10-21-GlobalResolveHack.ll:1.3 llvm/test/Transforms/FunctionResolve/2003-10-21-GlobalResolveHack.ll:1.4
--- llvm/test/Transforms/FunctionResolve/2003-10-21-GlobalResolveHack.ll:1.3	Fri Dec  1 22:23:09 2006
+++ llvm/test/Transforms/FunctionResolve/2003-10-21-GlobalResolveHack.ll	Fri Jan 26 02:25:06 2007
@@ -1,14 +1,12 @@
 ; This tests a hack put into place specifically for the C++ libstdc++ library.
 ; It uses an ugly hack which is cleaned up by the funcresolve pass.
+;
+; RUN: llvm-as < %s | opt -funcresolve | llvm-dis | grep @X | grep '{'
 
-; RUN: llvm-upgrade < %s | llvm-as | opt -funcresolve | llvm-dis | grep %X | grep '{'
+ at X = external global { i32 }
+ at X = global [ 4 x i8 ] zeroinitializer
 
-%X = external global { int }
-%X = global [ 4 x sbyte ] zeroinitializer
-
-implementation
-
-int* %test() {
-  %P = getelementptr {int}* %X, long 0, uint 0
-  ret int* %P
+define i32* @test() {
+  %P = getelementptr {i32}* @X, i64 0, i32 0
+  ret i32* %P
 }





From reid at x10sys.com  Fri Jan 26 02:26:05 2007
From: reid at x10sys.com (Reid Spencer)
Date: Fri, 26 Jan 2007 02:26:05 -0600
Subject: [llvm-commits] CVS: llvm/test/Linker/2003-01-30-LinkerRename.ll
	2003-11-18-TypeResolution.ll 2005-12-06-AppendingZeroLengthArrays.ll
Message-ID: <200701260826.l0Q8Q5u1031681@zion.cs.uiuc.edu>



Changes in directory llvm/test/Linker:

2003-01-30-LinkerRename.ll updated: 1.4 -> 1.5
2003-11-18-TypeResolution.ll updated: 1.2 -> 1.3
2005-12-06-AppendingZeroLengthArrays.ll updated: 1.4 -> 1.5
---
Log message:

For PR761: http://llvm.org/PR761 :
Remove "target endian/pointersize" or add "target datalayout" to make
the test parse properly or set the datalayout because defaults changes.

For PR645: http://llvm.org/PR645 :
Make global names use the @ prefix.

For llvm-upgrade changes:
Fix test cases or completely remove use of llvm-upgrade for test cases 
that cannot survive the new renaming or upgrade capabilities. 



---
Diffs of the changes:  (+5 -5)

 2003-01-30-LinkerRename.ll              |    2 +-
 2003-11-18-TypeResolution.ll            |    2 +-
 2005-12-06-AppendingZeroLengthArrays.ll |    6 +++---
 3 files changed, 5 insertions(+), 5 deletions(-)


Index: llvm/test/Linker/2003-01-30-LinkerRename.ll
diff -u llvm/test/Linker/2003-01-30-LinkerRename.ll:1.4 llvm/test/Linker/2003-01-30-LinkerRename.ll:1.5
--- llvm/test/Linker/2003-01-30-LinkerRename.ll:1.4	Fri Dec 29 14:01:32 2006
+++ llvm/test/Linker/2003-01-30-LinkerRename.ll	Fri Jan 26 02:25:06 2007
@@ -4,7 +4,7 @@
 ; RUN: echo "implementation internal int %foo() { ret int 7 }" | llvm-upgrade |\
 ; RUN:    llvm-as > %t.1.bc
 ; RUN: llvm-upgrade < %s | llvm-as -o %t.2.bc -f
-; RUN: llvm-link %t.[12].bc | llvm-dis | grep '%foo()' | grep -v internal
+; RUN: llvm-link %t.[12].bc | llvm-dis | grep '@foo()' | grep -v internal
 
 implementation
 int %foo() { ret int 0 }


Index: llvm/test/Linker/2003-11-18-TypeResolution.ll
diff -u llvm/test/Linker/2003-11-18-TypeResolution.ll:1.2 llvm/test/Linker/2003-11-18-TypeResolution.ll:1.3
--- llvm/test/Linker/2003-11-18-TypeResolution.ll:1.2	Sat Dec  2 14:40:30 2006
+++ llvm/test/Linker/2003-11-18-TypeResolution.ll	Fri Jan 26 02:25:06 2007
@@ -5,7 +5,7 @@
 ; own.
 
 ; RUN: llvm-upgrade %s | llvm-as > %t.out2.bc
-; RUN: echo "%T1 = type opaque  %GVar = external global %T1*" | llvm-as > %t.out1.bc
+; RUN: echo "%T1 = type opaque  @GVar = external global %T1*" | llvm-as > %t.out1.bc
 ; RUN: llvm-link %t.out[12].bc
 
 	%T1 = type opaque


Index: llvm/test/Linker/2005-12-06-AppendingZeroLengthArrays.ll
diff -u llvm/test/Linker/2005-12-06-AppendingZeroLengthArrays.ll:1.4 llvm/test/Linker/2005-12-06-AppendingZeroLengthArrays.ll:1.5
--- llvm/test/Linker/2005-12-06-AppendingZeroLengthArrays.ll:1.4	Fri Jan  5 12:36:46 2007
+++ llvm/test/Linker/2005-12-06-AppendingZeroLengthArrays.ll	Fri Jan 26 02:25:06 2007
@@ -1,9 +1,9 @@
-; RUN: echo "%G = appending global [0 x int] zeroinitializer" | llvm-upgrade |\
+; RUN: echo "@G = appending global [0 x i32] zeroinitializer" | \
 ; RUN:   llvm-as > %t.out2.bc
 ; RUN: llvm-upgrade < %s | llvm-as > %t.out1.bc
-; RUN: llvm-link %t.out[12].bc | llvm-dis | grep '%G ='
+; RUN: llvm-link %t.out[12].bc | llvm-dis | grep '@G ='
 
 ; When linked, the globals should be merged, and the result should still 
-; be named '%G'.
+; be named '@G'.
 
 %G = appending global [1 x int] zeroinitializer





From reid at x10sys.com  Fri Jan 26 02:26:06 2007
From: reid at x10sys.com (Reid Spencer)
Date: Fri, 26 Jan 2007 02:26:06 -0600
Subject: [llvm-commits] CVS:
	llvm/test/Analysis/BasicAA/2007-01-13-BasePointerBadNoAlias.ll
Message-ID: <200701260826.l0Q8Q6mi031689@zion.cs.uiuc.edu>



Changes in directory llvm/test/Analysis/BasicAA:

2007-01-13-BasePointerBadNoAlias.ll updated: 1.1 -> 1.2
---
Log message:

For PR761: http://llvm.org/PR761 :
Remove "target endian/pointersize" or add "target datalayout" to make
the test parse properly or set the datalayout because defaults changes.

For PR645: http://llvm.org/PR645 :
Make global names use the @ prefix.

For llvm-upgrade changes:
Fix test cases or completely remove use of llvm-upgrade for test cases 
that cannot survive the new renaming or upgrade capabilities. 



---
Diffs of the changes:  (+1 -3)

 2007-01-13-BasePointerBadNoAlias.ll |    4 +---
 1 files changed, 1 insertion(+), 3 deletions(-)


Index: llvm/test/Analysis/BasicAA/2007-01-13-BasePointerBadNoAlias.ll
diff -u llvm/test/Analysis/BasicAA/2007-01-13-BasePointerBadNoAlias.ll:1.1 llvm/test/Analysis/BasicAA/2007-01-13-BasePointerBadNoAlias.ll:1.2
--- llvm/test/Analysis/BasicAA/2007-01-13-BasePointerBadNoAlias.ll:1.1	Sat Jan 13 23:56:45 2007
+++ llvm/test/Analysis/BasicAA/2007-01-13-BasePointerBadNoAlias.ll	Fri Jan 26 02:25:05 2007
@@ -3,8 +3,6 @@
 ; PR1109
 
 target datalayout = "e-p:32:32"
-target endian = little
-target pointersize = 32
 target triple = "i686-apple-darwin8"
 	%struct.CONSTRAINT = type { i32, i32, i32, i32 }
 	%struct.FILE_POS = type { i8, i8, i16, i32 }
@@ -21,7 +19,7 @@
 
 implementation   ; Functions:
 
-define i32 %test(%struct.closure_type* %tmp18169) {
+define i32 @test(%struct.closure_type* %tmp18169) {
 	%tmp18174 = getelementptr %struct.closure_type* %tmp18169, i32 0, i32 4, i32 0, i32 0		;  [#uses=2]
 	%tmp18269 = bitcast i32* %tmp18174  to %struct.STYLE*		; <%struct.STYLE*> [#uses=1]
 	%A = load i32* %tmp18174		;  [#uses=1]





From reid at x10sys.com  Fri Jan 26 02:26:06 2007
From: reid at x10sys.com (Reid Spencer)
Date: Fri, 26 Jan 2007 02:26:06 -0600
Subject: [llvm-commits] CVS: llvm/test/CodeGen/X86/2006-05-11-InstrSched.ll
	2007-01-08-InstrSched.ll 2007-01-13-StackPtrIndex.ll
	sse-fcopysign.ll test-hidden.ll test-pic-1.ll test-pic-2.ll
	test-pic-3.ll test-pic-4.ll test-pic-5.ll test-pic-6.ll
	test-pic-cpool.ll test-pic-jtbl.ll trunc-to-bool.ll
Message-ID: <200701260826.l0Q8Q6Xu031739@zion.cs.uiuc.edu>



Changes in directory llvm/test/CodeGen/X86:

2006-05-11-InstrSched.ll updated: 1.5 -> 1.6
2007-01-08-InstrSched.ll updated: 1.3 -> 1.4
2007-01-13-StackPtrIndex.ll updated: 1.1 -> 1.2
sse-fcopysign.ll updated: 1.3 -> 1.4
test-hidden.ll updated: 1.2 -> 1.3
test-pic-1.ll updated: 1.1 -> 1.2
test-pic-2.ll updated: 1.1 -> 1.2
test-pic-3.ll updated: 1.1 -> 1.2
test-pic-4.ll updated: 1.1 -> 1.2
test-pic-5.ll updated: 1.1 -> 1.2
test-pic-6.ll updated: 1.1 -> 1.2
test-pic-cpool.ll updated: 1.2 -> 1.3
test-pic-jtbl.ll updated: 1.1 -> 1.2
trunc-to-bool.ll updated: 1.7 -> 1.8
---
Log message:

For PR761: http://llvm.org/PR761 :
Remove "target endian/pointersize" or add "target datalayout" to make
the test parse properly or set the datalayout because defaults changes.

For PR645: http://llvm.org/PR645 :
Make global names use the @ prefix.

For llvm-upgrade changes:
Fix test cases or completely remove use of llvm-upgrade for test cases 
that cannot survive the new renaming or upgrade capabilities. 



---
Diffs of the changes:  (+97 -97)

 2006-05-11-InstrSched.ll    |    4 ++-
 2007-01-08-InstrSched.ll    |    2 -
 2007-01-13-StackPtrIndex.ll |   48 +++++++++++++++++++++-----------------------
 sse-fcopysign.ll            |   12 +++++------
 test-hidden.ll              |   10 ++++-----
 test-pic-1.ll               |   14 ++++++------
 test-pic-2.ll               |   14 ++++++------
 test-pic-3.ll               |    6 ++---
 test-pic-4.ll               |   12 +++++------
 test-pic-5.ll               |    4 +--
 test-pic-6.ll               |   14 ++++++------
 test-pic-cpool.ll           |    2 -
 test-pic-jtbl.ll            |   40 ++++++++++++++++++------------------
 trunc-to-bool.ll            |   12 +++++------
 14 files changed, 97 insertions(+), 97 deletions(-)


Index: llvm/test/CodeGen/X86/2006-05-11-InstrSched.ll
diff -u llvm/test/CodeGen/X86/2006-05-11-InstrSched.ll:1.5 llvm/test/CodeGen/X86/2006-05-11-InstrSched.ll:1.6
--- llvm/test/CodeGen/X86/2006-05-11-InstrSched.ll:1.5	Fri Dec  1 22:23:08 2006
+++ llvm/test/CodeGen/X86/2006-05-11-InstrSched.ll	Fri Jan 26 02:25:06 2007
@@ -1,5 +1,7 @@
-; RUN: llvm-upgrade < %s | llvm-as | llc -march=x86 -mattr=+sse2 -stats 2>&1 | grep 'asm-printer' | grep 39
+; RUN: llvm-upgrade < %s | llvm-as | llc -march=x86 -mattr=+sse2 -stats 2>&1 |\
+; RUN:     grep 'asm-printer' | grep 39
 
+target datalayout = "e-p:32:32"
 void %foo(int* %mc, int* %bp, int* %ms, int* %xmb, int* %mpp, int* %tpmm, int* %ip, int* %tpim, int* %dpp, int* %tpdm, int* %bpi, int %M) {
 entry:
 	%tmp9 = setlt int %M, 5		;  [#uses=1]


Index: llvm/test/CodeGen/X86/2007-01-08-InstrSched.ll
diff -u llvm/test/CodeGen/X86/2007-01-08-InstrSched.ll:1.3 llvm/test/CodeGen/X86/2007-01-08-InstrSched.ll:1.4
--- llvm/test/CodeGen/X86/2007-01-08-InstrSched.ll:1.3	Mon Jan  8 18:31:52 2007
+++ llvm/test/CodeGen/X86/2007-01-08-InstrSched.ll	Fri Jan 26 02:25:06 2007
@@ -2,7 +2,7 @@
 ; RUN:   %prcontext 'mulss LCPI1_3' 1 | grep mulss | wc -l | grep 1
 ; PR1075
 
-define float %foo(float %x) {
+define float @foo(float %x) {
     %tmp1 = mul float %x, 3.000000e+00
     %tmp3 = mul float %x, 5.000000e+00
     %tmp5 = mul float %x, 7.000000e+00


Index: llvm/test/CodeGen/X86/2007-01-13-StackPtrIndex.ll
diff -u llvm/test/CodeGen/X86/2007-01-13-StackPtrIndex.ll:1.1 llvm/test/CodeGen/X86/2007-01-13-StackPtrIndex.ll:1.2
--- llvm/test/CodeGen/X86/2007-01-13-StackPtrIndex.ll:1.1	Sat Jan 13 18:12:50 2007
+++ llvm/test/CodeGen/X86/2007-01-13-StackPtrIndex.ll	Fri Jan 26 02:25:06 2007
@@ -3,13 +3,11 @@
 ; PR1103
 
 target datalayout = "e-p:64:64"
-target endian = little
-target pointersize = 64
-%i6000 = global [128 x i64] zeroinitializer, align 16
+ at i6000 = global [128 x i64] zeroinitializer, align 16
 
 implementation
 
-define void %foo(i32* %a0, i32* %a1, i32* %a2, i32* %a3, i32* %a4, i32* %a5) {
+define void @foo(i32* %a0, i32* %a1, i32* %a2, i32* %a3, i32* %a4, i32* %a5) {
 b:
 	%r = load i32* %a0
 	%r2 = load i32* %a1
@@ -135,14 +133,14 @@
 	%d753 = bitcast i64 %w1874 to i64
 	%r343 = add i64 %s661, 0
 	%r346 = add i64 %r343, 0
-	%r347 = getelementptr float* bitcast ([128 x i64]* %i6000 to float*), i64 %r346
+	%r347 = getelementptr float* bitcast ([128 x i64]* @i6000 to float*), i64 %r346
 	%r348 = load float* %r347
 	%r352 = add i64 %r343, 0
-	%r353 = getelementptr float* bitcast ([128 x i64]* %i6000 to float*), i64 %r352
+	%r353 = getelementptr float* bitcast ([128 x i64]* @i6000 to float*), i64 %r352
 	%r354 = load float* %r353
-	%r362 = load float* bitcast ([128 x i64]* %i6000 to float*)
+	%r362 = load float* bitcast ([128 x i64]* @i6000 to float*)
 	%r363 = add float 0.000000e+00, %r362
-	%r370 = load float* bitcast ([128 x i64]* %i6000 to float*)
+	%r370 = load float* bitcast ([128 x i64]* @i6000 to float*)
 	%r376 = icmp slt i64 %r16, 0
 	br i1 %r376, label %b377, label %a35b
 b377:
@@ -186,9 +184,9 @@
 	%s923 = phi i64 [ 0, %b514 ], [ %r799, %b712 ]
 	%s933 = phi i64 [ %r533, %b514 ], [ %r795, %b712 ]
 	%r538 = add i64 %w1855, 0
-	%r539 = getelementptr float* bitcast ([128 x i64]* %i6000 to float*), i64 %r538
+	%r539 = getelementptr float* bitcast ([128 x i64]* @i6000 to float*), i64 %r538
 	%r540 = load float* %r539
-	%r551 = load float* bitcast ([128 x i64]* %i6000 to float*)
+	%r551 = load float* bitcast ([128 x i64]* @i6000 to float*)
 	%r562 = sub i64 %s933, 0
 	%r564 = icmp slt i64 %r512, 0
 	br i1 %r564, label %b565, label %a45b
@@ -215,22 +213,22 @@
 a45b714:
 	%r717 = add i64 %e944, 0
 	%r720 = add i64 %r717, 0
-	%r721 = getelementptr float* bitcast ([128 x i64]* %i6000 to float*), i64 %r720
+	%r721 = getelementptr float* bitcast ([128 x i64]* @i6000 to float*), i64 %r720
 	%r722 = load float* %r721
 	%r726 = add i64 %r717, 0
-	%r727 = getelementptr float* bitcast ([128 x i64]* %i6000 to float*), i64 %r726
+	%r727 = getelementptr float* bitcast ([128 x i64]* @i6000 to float*), i64 %r726
 	%r728 = load float* %r727
 	%r732 = add i64 %r717, 0
-	%r733 = getelementptr float* bitcast ([128 x i64]* %i6000 to float*), i64 %r732
+	%r733 = getelementptr float* bitcast ([128 x i64]* @i6000 to float*), i64 %r732
 	%r734 = load float* %r733
 	%r738 = add i64 %r717, 0
-	%r739 = getelementptr float* bitcast ([128 x i64]* %i6000 to float*), i64 %r738
+	%r739 = getelementptr float* bitcast ([128 x i64]* @i6000 to float*), i64 %r738
 	%r740 = load float* %r739
 	%r744 = add i64 %r717, 0
-	%r745 = getelementptr float* bitcast ([128 x i64]* %i6000 to float*), i64 %r744
+	%r745 = getelementptr float* bitcast ([128 x i64]* @i6000 to float*), i64 %r744
 	%r746 = load float* %r745
 	%r750 = add i64 %r717, 0
-	%r751 = getelementptr float* bitcast ([128 x i64]* %i6000 to float*), i64 %r750
+	%r751 = getelementptr float* bitcast ([128 x i64]* @i6000 to float*), i64 %r750
 	%r752 = load float* %r751
 	%r753 = add float %r752, %r746
 	%r754 = add float %r728, %r722
@@ -239,10 +237,10 @@
 	%r757 = add float %r753, %r756
 	%r759 = add float %r757, %r540
 	%r770 = add i64 %r717, 0
-	%r771 = getelementptr float* bitcast ([128 x i64]* %i6000 to float*), i64 %r770
+	%r771 = getelementptr float* bitcast ([128 x i64]* @i6000 to float*), i64 %r770
 	%r772 = load float* %r771
 	%r776 = add i64 %r717, 0
-	%r777 = getelementptr float* bitcast ([128 x i64]* %i6000 to float*), i64 %r776
+	%r777 = getelementptr float* bitcast ([128 x i64]* @i6000 to float*), i64 %r776
 	%r778 = load float* %r777
 	%r781 = add float %r363, %r772
 	%r782 = add float %r781, %r778
@@ -256,7 +254,7 @@
 	%r844 = add i64 %r16, 0
 	%r846 = sext i32 %r60 to i64
 	%r847 = add i64 %r846, 0
-	%r851 = load float* bitcast ([128 x i64]* %i6000 to float*)
+	%r851 = load float* bitcast ([128 x i64]* @i6000 to float*)
 	%r856 = sub i64 %r, 0
 	br label %b858
 b858:
@@ -268,10 +266,10 @@
 	%s1173 = add i64 %b1902, 0
 	%r859 = add i64 %r856, 0
 	%r862 = add i64 %w1891, 0
-	%r863 = getelementptr float* bitcast ([128 x i64]* %i6000 to float*), i64 %r862
+	%r863 = getelementptr float* bitcast ([128 x i64]* @i6000 to float*), i64 %r862
 	%r864 = load float* %r863
 	%r868 = add i64 %w1891, 0
-	%r869 = getelementptr float* bitcast ([128 x i64]* %i6000 to float*), i64 %r868
+	%r869 = getelementptr float* bitcast ([128 x i64]* @i6000 to float*), i64 %r868
 	%r870 = load float* %r869
 	%r873 = sub i64 %r859, 0
 	%r876 = sub i64 %s1173, 0
@@ -338,7 +336,7 @@
 	%d1353 = bitcast i64 %w1915 to i64
 	%r1120 = add i64 %s661, 0
 	%r1121 = add i64 %r1120, 0
-	%r1122 = getelementptr float* bitcast ([128 x i64]* %i6000 to float*), i64 %r1121
+	%r1122 = getelementptr float* bitcast ([128 x i64]* @i6000 to float*), i64 %r1121
 	%r1123 = load float* %r1122
 	%r1132 = bitcast i8* %c22012 to float*
 	%r1134 = getelementptr float* %r1132, i64 %w1915
@@ -412,7 +410,7 @@
 	%r1352 = add i64 %s1523, 0
 	%r1355 = sub i64 %r1352, 0
 	%r1370 = add i64 %d1533, 0
-	%r1371 = getelementptr float* bitcast ([128 x i64]* %i6000 to float*), i64 %r1370
+	%r1371 = getelementptr float* bitcast ([128 x i64]* @i6000 to float*), i64 %r1370
 	%r1372 = load float* %r1371
 	br label %a74b
 a74b:
@@ -446,10 +444,10 @@
 	%r1756 = getelementptr float* %r1754, i64 %w1970
 	%r1757 = load float* %r1756
 	%r1761 = add i64 %r1622, 0
-	%r1762 = getelementptr float* bitcast ([128 x i64]* %i6000 to float*), i64 %r1761
+	%r1762 = getelementptr float* bitcast ([128 x i64]* @i6000 to float*), i64 %r1761
 	%r1763 = load float* %r1762
 	%r1767 = add i64 %r1622, 0
-	%r1768 = getelementptr float* bitcast ([128 x i64]* %i6000 to float*), i64 %r1767
+	%r1768 = getelementptr float* bitcast ([128 x i64]* @i6000 to float*), i64 %r1767
 	%r1772 = add float %r1763, 0.000000e+00
 	%r1773 = add float %r1772, 0.000000e+00
 	%r1809 = add float %r1757, 0.000000e+00


Index: llvm/test/CodeGen/X86/sse-fcopysign.ll
diff -u llvm/test/CodeGen/X86/sse-fcopysign.ll:1.3 llvm/test/CodeGen/X86/sse-fcopysign.ll:1.4
--- llvm/test/CodeGen/X86/sse-fcopysign.ll:1.3	Fri Jan  5 15:53:15 2007
+++ llvm/test/CodeGen/X86/sse-fcopysign.ll	Fri Jan 26 02:25:06 2007
@@ -1,17 +1,17 @@
 ; RUN: llvm-as < %s | llc -march=x86 -mattr=+sse2 &&
 ; RUN: llvm-as < %s | llc -march=x86 -mattr=+sse2 | not getp test
 
-define float %test1(float %a, float %b) {
-	%tmp = tail call float %copysignf( float %b, float %a )
+define float @test1(float %a, float %b) {
+	%tmp = tail call float @copysignf( float %b, float %a )
 	ret float %tmp
 }
 
-define double %test2(double %a, float %b, float %c) {
+define double @test2(double %a, float %b, float %c) {
 	%tmp1 = add float %b, %c
 	%tmp2 = fpext float %tmp1 to double
-	%tmp = tail call double %copysign( double %a, double %tmp2 )
+	%tmp = tail call double @copysign( double %a, double %tmp2 )
 	ret double %tmp
 }
 
-declare float %copysignf(float, float)
-declare double %copysign(double, double)
+declare float @copysignf(float, float)
+declare double @copysign(double, double)


Index: llvm/test/CodeGen/X86/test-hidden.ll
diff -u llvm/test/CodeGen/X86/test-hidden.ll:1.2 llvm/test/CodeGen/X86/test-hidden.ll:1.3
--- llvm/test/CodeGen/X86/test-hidden.ll:1.2	Mon Jan 15 12:32:24 2007
+++ llvm/test/CodeGen/X86/test-hidden.ll	Fri Jan 26 02:25:06 2007
@@ -3,18 +3,18 @@
 ; RUN: llvm-as < %s | llc -mtriple=i686-apple-darwin8.8.0 | grep ".private_extern" | wc -l | grep 2 
 
 %struct.Person = type { i32 }
-%a = hidden global i32 0
-%b = external global i32
+ at a = hidden global i32 0
+ at b = external global i32
 
 implementation   ; Functions:
 
-define weak hidden void %_ZN6Person13privateMethodEv(%struct.Person* %this) {
+define weak hidden void @_ZN6Person13privateMethodEv(%struct.Person* %this) {
   ret void
 }
 
-declare void %function(i32)
+declare void @function(i32)
 
-define weak void %_ZN6PersonC1Ei(%struct.Person* %this, i32 %_c) {
+define weak void @_ZN6PersonC1Ei(%struct.Person* %this, i32 %_c) {
   ret void
 }
 


Index: llvm/test/CodeGen/X86/test-pic-1.ll
diff -u llvm/test/CodeGen/X86/test-pic-1.ll:1.1 llvm/test/CodeGen/X86/test-pic-1.ll:1.2
--- llvm/test/CodeGen/X86/test-pic-1.ll:1.1	Fri Jan 12 13:20:47 2007
+++ llvm/test/CodeGen/X86/test-pic-1.ll	Fri Jan 26 02:25:06 2007
@@ -4,15 +4,15 @@
 ; RUN: llvm-as < %s | llc -mtriple=i686-pc-linux-gnu -relocation-model=pic | grep GOT | wc -l | grep 3 &&
 ; RUN: llvm-as < %s | llc -mtriple=i686-pc-linux-gnu -relocation-model=pic | grep GOTOFF | wc -l | grep 0
 
-%ptr = external global i32* 
-%dst = external global i32 
-%src = external global i32 
+ at ptr = external global i32* 
+ at dst = external global i32 
+ at src = external global i32 
 
-define void %foo() {
+define void @foo() {
 entry:
-    store i32* %dst, i32** %ptr
-    %tmp.s = load i32* %src
-    store i32 %tmp.s, i32* %dst
+    store i32* @dst, i32** @ptr
+    %tmp.s = load i32* @src
+    store i32 %tmp.s, i32* @dst
     ret void
 }
 


Index: llvm/test/CodeGen/X86/test-pic-2.ll
diff -u llvm/test/CodeGen/X86/test-pic-2.ll:1.1 llvm/test/CodeGen/X86/test-pic-2.ll:1.2
--- llvm/test/CodeGen/X86/test-pic-2.ll:1.1	Fri Jan 12 13:20:47 2007
+++ llvm/test/CodeGen/X86/test-pic-2.ll	Fri Jan 26 02:25:06 2007
@@ -3,15 +3,15 @@
 ; RUN: llvm-as < %s | llc -mtriple=i686-pc-linux-gnu -relocation-model=pic | grep piclabel | wc -l | grep 3 &&
 ; RUN: llvm-as < %s | llc -mtriple=i686-pc-linux-gnu -relocation-model=pic | grep GOTOFF | wc -l | grep 4
 
-%ptr = internal global i32* null
-%dst = internal global i32 0
-%src = internal global i32 0
+ at ptr = internal global i32* null
+ at dst = internal global i32 0
+ at src = internal global i32 0
 
-define void %foo() {
+define void @foo() {
 entry:
-    store i32* %dst, i32** %ptr
-    %tmp.s = load i32* %src
-    store i32 %tmp.s, i32* %dst
+    store i32* @dst, i32** @ptr
+    %tmp.s = load i32* @src
+    store i32 %tmp.s, i32* @dst
     ret void
 }
 


Index: llvm/test/CodeGen/X86/test-pic-3.ll
diff -u llvm/test/CodeGen/X86/test-pic-3.ll:1.1 llvm/test/CodeGen/X86/test-pic-3.ll:1.2
--- llvm/test/CodeGen/X86/test-pic-3.ll:1.1	Fri Jan 12 13:20:47 2007
+++ llvm/test/CodeGen/X86/test-pic-3.ll	Fri Jan 26 02:25:06 2007
@@ -3,12 +3,12 @@
 ; RUN: llvm-as < %s | llc -mtriple=i686-pc-linux-gnu -relocation-model=pic | grep piclabel | wc -l | grep 3 &&
 ; RUN: llvm-as < %s | llc -mtriple=i686-pc-linux-gnu -relocation-model=pic | grep PLT | wc -l | grep 1
 
-define void %bar() {
+define void @bar() {
 entry:
-    call void(...)* %foo()
+    call void(...)* @foo()
     br label %return
 return:
     ret void
 }
 
-declare void %foo(...)
+declare void @foo(...)


Index: llvm/test/CodeGen/X86/test-pic-4.ll
diff -u llvm/test/CodeGen/X86/test-pic-4.ll:1.1 llvm/test/CodeGen/X86/test-pic-4.ll:1.2
--- llvm/test/CodeGen/X86/test-pic-4.ll:1.1	Fri Jan 12 13:20:47 2007
+++ llvm/test/CodeGen/X86/test-pic-4.ll	Fri Jan 26 02:25:06 2007
@@ -5,17 +5,17 @@
 ; RUN: llvm-as < %s | llc -mtriple=i686-pc-linux-gnu -relocation-model=pic | grep "GOT" | wc -l | grep 1 &&
 ; RUN: llvm-as < %s | llc -mtriple=i686-pc-linux-gnu -relocation-model=pic | grep "GOTOFF" | wc -l | grep 0
 
-%pfoo = external global void(...)* 
+ at pfoo = external global void(...)* 
 
-define void %bar() {
+define void @bar() {
 entry:
-    %tmp = call void(...)*(...)* %afoo()
-    store void(...)* %tmp, void(...)** %pfoo
-    %tmp1 = load void(...)** %pfoo
+    %tmp = call void(...)*(...)* @afoo()
+    store void(...)* %tmp, void(...)** @pfoo
+    %tmp1 = load void(...)** @pfoo
     call void(...)* %tmp1()
     br label %return
 return:
     ret void
 }
 
-declare void(...)* %afoo(...)
+declare void(...)* @afoo(...)


Index: llvm/test/CodeGen/X86/test-pic-5.ll
diff -u llvm/test/CodeGen/X86/test-pic-5.ll:1.1 llvm/test/CodeGen/X86/test-pic-5.ll:1.2
--- llvm/test/CodeGen/X86/test-pic-5.ll:1.1	Fri Jan 12 13:20:47 2007
+++ llvm/test/CodeGen/X86/test-pic-5.ll	Fri Jan 26 02:25:06 2007
@@ -3,9 +3,9 @@
 ; RUN: llvm-as < %s | llc -mtriple=i686-pc-linux-gnu -relocation-model=pic | grep piclabel | wc -l | grep 3 &&
 ; RUN: llvm-as < %s | llc -mtriple=i686-pc-linux-gnu -relocation-model=pic | grep PLT | wc -l | grep 1
 
-%ptr = external global i32* 
+ at ptr = external global i32* 
 
-define void %foo() {
+define void @foo() {
 entry:
     %ptr = malloc i32, i32 10
     ret void


Index: llvm/test/CodeGen/X86/test-pic-6.ll
diff -u llvm/test/CodeGen/X86/test-pic-6.ll:1.1 llvm/test/CodeGen/X86/test-pic-6.ll:1.2
--- llvm/test/CodeGen/X86/test-pic-6.ll:1.1	Wed Jan 17 04:33:08 2007
+++ llvm/test/CodeGen/X86/test-pic-6.ll	Fri Jan 26 02:25:06 2007
@@ -3,15 +3,15 @@
 ; RUN: llvm-as < %s | llc -mtriple=i686-pc-linux-gnu -relocation-model=pic | grep piclabel | wc -l | grep 3 &&
 ; RUN: llvm-as < %s | llc -mtriple=i686-pc-linux-gnu -relocation-model=pic | grep GOT | wc -l | grep 3
 
-%ptr = global i32* null
-%dst = global i32 0
-%src = global i32 0
+ at ptr = global i32* null
+ at dst = global i32 0
+ at src = global i32 0
 
-define void %foo() {
+define void @foo() {
 entry:
-    store i32* %dst, i32** %ptr
-    %tmp.s = load i32* %src
-    store i32 %tmp.s, i32* %dst
+    store i32* @dst, i32** @ptr
+    %tmp.s = load i32* @src
+    store i32 %tmp.s, i32* @dst
     ret void
 }
 


Index: llvm/test/CodeGen/X86/test-pic-cpool.ll
diff -u llvm/test/CodeGen/X86/test-pic-cpool.ll:1.2 llvm/test/CodeGen/X86/test-pic-cpool.ll:1.3
--- llvm/test/CodeGen/X86/test-pic-cpool.ll:1.2	Fri Jan 12 23:06:52 2007
+++ llvm/test/CodeGen/X86/test-pic-cpool.ll	Fri Jan 26 02:25:06 2007
@@ -4,7 +4,7 @@
 ; RUN: llvm-as < %s | llc -mtriple=i686-pc-linux-gnu -relocation-model=pic | grep GOTOFF | wc -l | grep 2 &&
 ; RUN: llvm-as < %s | llc -mtriple=i686-pc-linux-gnu -relocation-model=pic | grep CPI | wc -l | grep 4
 
-define double %foo(i32 %a.u) {
+define double @foo(i32 %a.u) {
 entry:
     %tmp = icmp eq i32 %a.u,0
     %retval = select i1 %tmp, double 4.561230e+02, double 1.234560e+02


Index: llvm/test/CodeGen/X86/test-pic-jtbl.ll
diff -u llvm/test/CodeGen/X86/test-pic-jtbl.ll:1.1 llvm/test/CodeGen/X86/test-pic-jtbl.ll:1.2
--- llvm/test/CodeGen/X86/test-pic-jtbl.ll:1.1	Fri Jan 12 13:20:47 2007
+++ llvm/test/CodeGen/X86/test-pic-jtbl.ll	Fri Jan 26 02:25:06 2007
@@ -5,53 +5,53 @@
 ; RUN: llvm-as < %s | llc -mtriple=i686-pc-linux-gnu -relocation-model=pic | grep GOTOFF | wc -l | grep 1 &&
 ; RUN: llvm-as < %s | llc -mtriple=i686-pc-linux-gnu -relocation-model=pic | grep JTI | wc -l | grep 15
 
-define void %bar(i32 %n.u) {
+define void @bar(i32 %n.u) {
 entry:
     switch i32 %n.u, label %bb12 [i32 1, label %bb i32 2, label %bb6 i32 4, label %bb7 i32 5, label %bb8 i32 6, label %bb10 i32 7, label %bb1 i32 8, label %bb3 i32 9, label %bb4 i32 10, label %bb9 i32 11, label %bb2 i32 12, label %bb5 i32 13, label %bb11 ]
 bb:
-    tail call void(...)* %foo1()
+    tail call void(...)* @foo1()
     ret void
 bb1:
-    tail call void(...)* %foo2()
+    tail call void(...)* @foo2()
     ret void
 bb2:
-    tail call void(...)* %foo6()
+    tail call void(...)* @foo6()
     ret void
 bb3:
-    tail call void(...)* %foo3()
+    tail call void(...)* @foo3()
     ret void
 bb4:
-    tail call void(...)* %foo4()
+    tail call void(...)* @foo4()
     ret void
 bb5:
-    tail call void(...)* %foo5()
+    tail call void(...)* @foo5()
     ret void
 bb6:
-    tail call void(...)* %foo1()
+    tail call void(...)* @foo1()
     ret void
 bb7:
-    tail call void(...)* %foo2()
+    tail call void(...)* @foo2()
     ret void
 bb8:
-    tail call void(...)* %foo6()
+    tail call void(...)* @foo6()
     ret void
 bb9:
-    tail call void(...)* %foo3()
+    tail call void(...)* @foo3()
     ret void
 bb10:
-    tail call void(...)* %foo4()
+    tail call void(...)* @foo4()
     ret void
 bb11:
-    tail call void(...)* %foo5()
+    tail call void(...)* @foo5()
     ret void
 bb12:
-    tail call void(...)* %foo6()
+    tail call void(...)* @foo6()
     ret void
 }
 
-declare void %foo1(...)
-declare void %foo2(...)
-declare void %foo6(...)
-declare void %foo3(...)
-declare void %foo4(...)
-declare void %foo5(...)
+declare void @foo1(...)
+declare void @foo2(...)
+declare void @foo6(...)
+declare void @foo3(...)
+declare void @foo4(...)
+declare void @foo5(...)


Index: llvm/test/CodeGen/X86/trunc-to-bool.ll
diff -u llvm/test/CodeGen/X86/trunc-to-bool.ll:1.7 llvm/test/CodeGen/X86/trunc-to-bool.ll:1.8
--- llvm/test/CodeGen/X86/trunc-to-bool.ll:1.7	Fri Jan 12 23:06:52 2007
+++ llvm/test/CodeGen/X86/trunc-to-bool.ll	Fri Jan 26 02:25:06 2007
@@ -5,12 +5,12 @@
 ; RUN: llvm-as < %s | llc -march=x86 | grep '\(and\)\|\(test.*\$1\)' | \
 ; RUN:   wc -l | grep 6
 
-define i1 %test1(i32 %X) zext {
+define i1 @test1(i32 %X) zext {
     %Y = trunc i32 %X to i1
     ret i1 %Y
 }
 
-define i1 %test2(i32 %val, i32 %mask) {
+define i1 @test2(i32 %val, i32 %mask) {
 entry:
     %mask = trunc i32 %mask to i8
     %shifted = ashr i32 %val, i8 %mask
@@ -23,7 +23,7 @@
     ret i1 false
 }
 
-define i32 %test3(i8* %ptr) {
+define i32 @test3(i8* %ptr) {
     %val = load i8* %ptr
     %tmp = trunc i8 %val to i1
     br i1 %tmp, label %cond_true, label %cond_false
@@ -33,7 +33,7 @@
     ret i32 42
 }
 
-define i32 %test4(i8* %ptr) {
+define i32 @test4(i8* %ptr) {
     %tmp = ptrtoint i8* %ptr to i1
     br i1 %tmp, label %cond_true, label %cond_false
 cond_true:
@@ -42,7 +42,7 @@
     ret i32 42
 }
 
-define i32 %test5(float %f) {
+define i32 @test5(float %f) {
     %tmp = fptoui float %f to i1
     br i1 %tmp, label %cond_true, label %cond_false
 cond_true:
@@ -51,7 +51,7 @@
     ret i32 42
 }
 
-define i32 %test6(double %d) {
+define i32 @test6(double %d) {
     %tmp = fptosi double %d to i1
     br i1 %tmp, label %cond_true, label %cond_false
 cond_true:





From reid at x10sys.com  Fri Jan 26 02:26:07 2007
From: reid at x10sys.com (Reid Spencer)
Date: Fri, 26 Jan 2007 02:26:07 -0600
Subject: [llvm-commits] CVS:
	llvm/test/CodeGen/ARM/2007-01-19-InfiniteLoop.ll fcopysign.ll
	fpcmp_ueq.ll large-stack.ll ldr_ext.ll ldr_frame.ll mul.ll
	select.ll sxt_rot.ll thumb-imm.ll uxt_rot.ll
Message-ID: <200701260826.l0Q8Q7qs031724@zion.cs.uiuc.edu>



Changes in directory llvm/test/CodeGen/ARM:

2007-01-19-InfiniteLoop.ll updated: 1.1 -> 1.2
fcopysign.ll updated: 1.5 -> 1.6
fpcmp_ueq.ll updated: 1.3 -> 1.4
large-stack.ll updated: 1.1 -> 1.2
ldr_ext.ll updated: 1.2 -> 1.3
ldr_frame.ll updated: 1.1 -> 1.2
mul.ll updated: 1.4 -> 1.5
select.ll updated: 1.11 -> 1.12
sxt_rot.ll updated: 1.1 -> 1.2
thumb-imm.ll updated: 1.1 -> 1.2
uxt_rot.ll updated: 1.1 -> 1.2
---
Log message:

For PR761: http://llvm.org/PR761 :
Remove "target endian/pointersize" or add "target datalayout" to make
the test parse properly or set the datalayout because defaults changes.

For PR645: http://llvm.org/PR645 :
Make global names use the @ prefix.

For llvm-upgrade changes:
Fix test cases or completely remove use of llvm-upgrade for test cases 
that cannot survive the new renaming or upgrade capabilities. 



---
Diffs of the changes:  (+47 -47)

 2007-01-19-InfiniteLoop.ll |   26 +++++++++++++-------------
 fcopysign.ll               |   10 +++++-----
 fpcmp_ueq.ll               |    2 +-
 large-stack.ll             |    4 ++--
 ldr_ext.ll                 |    8 ++++----
 ldr_frame.ll               |    8 ++++----
 mul.ll                     |    8 ++++----
 select.ll                  |   14 +++++++-------
 sxt_rot.ll                 |    4 ++--
 thumb-imm.ll               |    4 ++--
 uxt_rot.ll                 |    6 +++---
 11 files changed, 47 insertions(+), 47 deletions(-)


Index: llvm/test/CodeGen/ARM/2007-01-19-InfiniteLoop.ll
diff -u llvm/test/CodeGen/ARM/2007-01-19-InfiniteLoop.ll:1.1 llvm/test/CodeGen/ARM/2007-01-19-InfiniteLoop.ll:1.2
--- llvm/test/CodeGen/ARM/2007-01-19-InfiniteLoop.ll:1.1	Fri Jan 19 16:43:14 2007
+++ llvm/test/CodeGen/ARM/2007-01-19-InfiniteLoop.ll	Fri Jan 26 02:25:05 2007
@@ -1,10 +1,10 @@
 ; RUN: llvm-as < %s | llc -march=arm -mattr=+v6,+vfp2
 
-%quant_coef = external global [6 x [4 x [4 x i32]]]		; <[6 x [4 x [4 x i32]]]*> [#uses=1]
-%dequant_coef = external global [6 x [4 x [4 x i32]]]		; <[6 x [4 x [4 x i32]]]*> [#uses=1]
-%A = external global [4 x [4 x i32]]		; <[4 x [4 x i32]]*> [#uses=1]
+ at quant_coef = external global [6 x [4 x [4 x i32]]]		; <[6 x [4 x [4 x i32]]]*> [#uses=1]
+ at dequant_coef = external global [6 x [4 x [4 x i32]]]		; <[6 x [4 x [4 x i32]]]*> [#uses=1]
+ at A = external global [4 x [4 x i32]]		; <[4 x [4 x i32]]*> [#uses=1]
 
-define fastcc i32 %dct_luma_sp(i32 %block_x, i32 %block_y, i32* %coeff_cost) {
+define fastcc i32 @dct_luma_sp(i32 %block_x, i32 %block_y, i32* %coeff_cost) {
 entry:
 	%predicted_block = alloca [4 x [4 x i32]], align 4		; <[4 x [4 x i32]]*> [#uses=1]
 	br label %cond_next489
@@ -17,7 +17,7 @@
 	%tmp495 = getelementptr [4 x [4 x i32]]* %predicted_block, i32 0, i32 %i.8, i32 %j.7		;  [#uses=2]
 	%tmp496 = load i32* %tmp495		;  [#uses=2]
 	%tmp502 = load i32* null		;  [#uses=1]
-	%tmp542 = getelementptr [6 x [4 x [4 x i32]]]* %quant_coef, i32 0, i32 0, i32 %i.8, i32 %j.7		;  [#uses=1]
+	%tmp542 = getelementptr [6 x [4 x [4 x i32]]]* @quant_coef, i32 0, i32 0, i32 %i.8, i32 %j.7		;  [#uses=1]
 	%tmp543 = load i32* %tmp542		;  [#uses=1]
 	%tmp548 = ashr i32 0, i8 0		;  [#uses=3]
 	%tmp561 = sub i32 0, %tmp496		;  [#uses=3]
@@ -30,14 +30,14 @@
 	br i1 %tmp579, label %bb712, label %cond_next589
 
 cond_next589:		; preds = %cond_next489
-	%tmp605 = getelementptr [6 x [4 x [4 x i32]]]* %dequant_coef, i32 0, i32 0, i32 %i.8, i32 %j.7		;  [#uses=1]
+	%tmp605 = getelementptr [6 x [4 x [4 x i32]]]* @dequant_coef, i32 0, i32 0, i32 %i.8, i32 %j.7		;  [#uses=1]
 	%tmp606 = load i32* %tmp605		;  [#uses=1]
 	%tmp612 = load i32* null		;  [#uses=1]
 	%tmp629 = load i32* null		;  [#uses=1]
 	%tmp629 = sitofp i32 %tmp629 to double		;  [#uses=1]
 	%tmp631 = mul double %tmp629, 0.000000e+00		;  [#uses=1]
 	%tmp632 = add double 0.000000e+00, %tmp631		;  [#uses=1]
-	%tmp642 = call fastcc i32 %sign( i32 %tmp576, i32 %tmp561 )		;  [#uses=1]
+	%tmp642 = call fastcc i32 @sign( i32 %tmp576, i32 %tmp561 )		;  [#uses=1]
 	%tmp650 = mul i32 %tmp606, %tmp642		;  [#uses=1]
 	%tmp656 = mul i32 %tmp650, %tmp612		;  [#uses=1]
 	%tmp658 = shl i32 %tmp656, i8 0		;  [#uses=1]
@@ -45,7 +45,7 @@
 	%tmp660 = sub i32 0, %tmp659		;  [#uses=1]
 	%tmp666 = sub i32 %tmp660, %tmp496		;  [#uses=1]
 	%tmp666 = sitofp i32 %tmp666 to double		;  [#uses=2]
-	call void %levrun_linfo_inter( i32 %tmp576, i32 0, i32* null, i32* null )
+	call void @levrun_linfo_inter( i32 %tmp576, i32 0, i32* null, i32* null )
 	%tmp671 = mul double %tmp666, %tmp666		;  [#uses=1]
 	%tmp675 = add double %tmp671, 0.000000e+00		;  [#uses=1]
 	%tmp678 = fcmp oeq double %tmp632, %tmp675		;  [#uses=1]
@@ -79,9 +79,9 @@
 	br i1 %tmp739, label %cond_next791, label %cond_true740
 
 cond_true740:		; preds = %bb737
-	%tmp761 = call fastcc i32 %sign( i32 %tmp576, i32 0 )		;  [#uses=1]
+	%tmp761 = call fastcc i32 @sign( i32 %tmp576, i32 0 )		;  [#uses=1]
 	%tmp780 = load i32* null		;  [#uses=1]
-	%tmp785 = getelementptr [4 x [4 x i32]]* %A, i32 0, i32 %i.8, i32 %j.7		;  [#uses=1]
+	%tmp785 = getelementptr [4 x [4 x i32]]* @A, i32 0, i32 %i.8, i32 %j.7		;  [#uses=1]
 	%tmp786 = load i32* %tmp785		;  [#uses=1]
 	%tmp781 = mul i32 %tmp780, %tmp761		;  [#uses=1]
 	%tmp787 = mul i32 %tmp781, %tmp786		;  [#uses=1]
@@ -94,10 +94,10 @@
 	%tmp796 = load i32* %tmp495		;  [#uses=1]
 	%tmp798 = add i32 %tmp796, %ilev.1		;  [#uses=1]
 	%tmp812 = mul i32 0, %tmp502		;  [#uses=0]
-	%tmp818 = call fastcc i32 %sign( i32 0, i32 %tmp798 )		;  [#uses=0]
+	%tmp818 = call fastcc i32 @sign( i32 0, i32 %tmp798 )		;  [#uses=0]
 	unreachable
 }
 
-declare i32 %sign(i32, i32)
+declare i32 @sign(i32, i32)
 
-declare void %levrun_linfo_inter(i32, i32, i32*, i32*)
+declare void @levrun_linfo_inter(i32, i32, i32*, i32*)


Index: llvm/test/CodeGen/ARM/fcopysign.ll
diff -u llvm/test/CodeGen/ARM/fcopysign.ll:1.5 llvm/test/CodeGen/ARM/fcopysign.ll:1.6
--- llvm/test/CodeGen/ARM/fcopysign.ll:1.5	Thu Jan 25 16:11:02 2007
+++ llvm/test/CodeGen/ARM/fcopysign.ll	Fri Jan 26 02:25:05 2007
@@ -3,17 +3,17 @@
 ; RUN: llvm-as < %s | llc -march=arm -mattr=+v6,+vfp2 &&
 ; RUN: llvm-as < %s | llc -march=arm -mattr=+v6,+vfp2 | grep fneg | wc -l | grep 2
 
-define float %test1(float %x, double %y) {
+define float @test1(float %x, double %y) {
 	%tmp = fpext float %x to double
-	%tmp2 = tail call double %copysign( double %tmp, double %y )
+	%tmp2 = tail call double @copysign( double %tmp, double %y )
 	%tmp2 = fptrunc double %tmp2 to float
 	ret float %tmp2
 }
 
-define double %test2(double %x, float %y) {
+define double @test2(double %x, float %y) {
 	%tmp = fpext float %y to double
-	%tmp2 = tail call double %copysign( double %x, double %tmp )
+	%tmp2 = tail call double @copysign( double %x, double %tmp )
 	ret double %tmp2
 }
 
-declare double %copysign(double, double)
+declare double @copysign(double, double)


Index: llvm/test/CodeGen/ARM/fpcmp_ueq.ll
diff -u llvm/test/CodeGen/ARM/fpcmp_ueq.ll:1.3 llvm/test/CodeGen/ARM/fpcmp_ueq.ll:1.4
--- llvm/test/CodeGen/ARM/fpcmp_ueq.ll:1.3	Fri Jan 19 03:20:23 2007
+++ llvm/test/CodeGen/ARM/fpcmp_ueq.ll	Fri Jan 26 02:25:05 2007
@@ -2,7 +2,7 @@
 ; RUN: llvm-as < %s | llc -march=arm | grep moveq &&
 ; RUN: llvm-as < %s | llc -march=arm -mattr=+vfp2 | grep movvs
 
-define i32 %f7(float %a, float %b) {
+define i32 @f7(float %a, float %b) {
 entry:
     %tmp = fcmp ueq float %a,%b
     %retval = select i1 %tmp, i32 666, i32 42


Index: llvm/test/CodeGen/ARM/large-stack.ll
diff -u llvm/test/CodeGen/ARM/large-stack.ll:1.1 llvm/test/CodeGen/ARM/large-stack.ll:1.2
--- llvm/test/CodeGen/ARM/large-stack.ll:1.1	Fri Jan 19 03:20:23 2007
+++ llvm/test/CodeGen/ARM/large-stack.ll	Fri Jan 26 02:25:05 2007
@@ -1,12 +1,12 @@
 ; RUN: llvm-as < %s | llc -march=arm &&
 ; RUN: llvm-as < %s | llc -march=arm -enable-thumb
 
-define void %test1() {
+define void @test1() {
     %tmp = alloca [ 64 x i32 ] , align 4
     ret void
 }
 
-define void %test2() {
+define void @test2() {
     %tmp = alloca [ 4168 x i8 ] , align 4
     ret void
 }


Index: llvm/test/CodeGen/ARM/ldr_ext.ll
diff -u llvm/test/CodeGen/ARM/ldr_ext.ll:1.2 llvm/test/CodeGen/ARM/ldr_ext.ll:1.3
--- llvm/test/CodeGen/ARM/ldr_ext.ll:1.2	Tue Jan 23 16:47:58 2007
+++ llvm/test/CodeGen/ARM/ldr_ext.ll	Fri Jan 26 02:25:05 2007
@@ -8,25 +8,25 @@
 ; RUN: llvm-as < %s | llc -march=arm -enable-thumb | grep "ldrsb" | wc -l | grep 1 &&
 ; RUN: llvm-as < %s | llc -march=arm -enable-thumb | grep "ldrsh" | wc -l | grep 1
 
-define i32 %test1(i8* %v.pntr.s0.u1) {
+define i32 @test1(i8* %v.pntr.s0.u1) {
     %tmp.u = load i8* %v.pntr.s0.u1
     %tmp1.s = zext i8 %tmp.u to i32
     ret i32 %tmp1.s
 }
 
-define i32 %test2(i16* %v.pntr.s0.u1) {
+define i32 @test2(i16* %v.pntr.s0.u1) {
     %tmp.u = load i16* %v.pntr.s0.u1
     %tmp1.s = zext i16 %tmp.u to i32
     ret i32 %tmp1.s
 }
 
-define i32 %test3(i8* %v.pntr.s1.u0) {
+define i32 @test3(i8* %v.pntr.s1.u0) {
     %tmp.s = load i8* %v.pntr.s1.u0
     %tmp1.s = sext i8 %tmp.s to i32
     ret i32 %tmp1.s
 }
 
-define i32 %test4() {
+define i32 @test4() {
     %tmp.s = load i16* null
     %tmp1.s = sext i16 %tmp.s to i32
     ret i32 %tmp1.s


Index: llvm/test/CodeGen/ARM/ldr_frame.ll
diff -u llvm/test/CodeGen/ARM/ldr_frame.ll:1.1 llvm/test/CodeGen/ARM/ldr_frame.ll:1.2
--- llvm/test/CodeGen/ARM/ldr_frame.ll:1.1	Tue Jan 23 20:27:03 2007
+++ llvm/test/CodeGen/ARM/ldr_frame.ll	Fri Jan 26 02:25:05 2007
@@ -3,14 +3,14 @@
 ; RUN: llvm-as < %s | llc -march=arm -enable-thumb &&
 ; RUN: llvm-as < %s | llc -march=arm -enable-thumb | grep cpy | wc -l | grep 2
 
-define i32 %f1() {
+define i32 @f1() {
 	%buf = alloca [32 x i32], align 4
 	%tmp = getelementptr [32 x i32]* %buf, i32 0, i32 0
 	%tmp1 = load i32* %tmp
 	ret i32 %tmp1
 }
 
-define i32 %f2() {
+define i32 @f2() {
 	%buf = alloca [32 x i8], align 4
 	%tmp = getelementptr [32 x i8]* %buf, i32 0, i32 0
 	%tmp1 = load i8* %tmp
@@ -18,14 +18,14 @@
 	ret i32 %tmp2
 }
 
-define i32 %f3() {
+define i32 @f3() {
 	%buf = alloca [32 x i32], align 4
 	%tmp = getelementptr [32 x i32]* %buf, i32 0, i32 32
 	%tmp1 = load i32* %tmp
 	ret i32 %tmp1
 }
 
-define i32 %f4() {
+define i32 @f4() {
 	%buf = alloca [32 x i8], align 4
 	%tmp = getelementptr [32 x i8]* %buf, i32 0, i32 2
 	%tmp1 = load i8* %tmp


Index: llvm/test/CodeGen/ARM/mul.ll
diff -u llvm/test/CodeGen/ARM/mul.ll:1.4 llvm/test/CodeGen/ARM/mul.ll:1.5
--- llvm/test/CodeGen/ARM/mul.ll:1.4	Tue Jan 23 17:28:50 2007
+++ llvm/test/CodeGen/ARM/mul.ll	Fri Jan 26 02:25:05 2007
@@ -4,22 +4,22 @@
 ; RUN: llvm-as < %s | llc -march=arm -enable-thumb | grep mul | wc -l | grep 3 &&
 ; RUN: llvm-as < %s | llc -march=arm -enable-thumb | grep lsl | wc -l | grep 1
 
-define i32 %f1(i32 %u) {
+define i32 @f1(i32 %u) {
     %tmp = mul i32 %u, %u
     ret i32 %tmp
 }
 
-define i32 %f2(i32 %u, i32 %v) {
+d
