Cleanup of the [SU]ADDO type legalization code. Patch by Duncan!

[oota-llvm.git] / lib / AsmParser / ParserInternals.h

diff --git a/lib/AsmParser/ParserInternals.h b/lib/AsmParser/ParserInternals.h
index 298dd8c19023fbeda71884efd31052c0af1b21cd..8af27c77c33a2c9e4cb7e6ef0b9858cf15180f7d 100644 (file)
--- a/lib/AsmParser/ParserInternals.h
+++ b/lib/AsmParser/ParserInternals.h
@@ -17,12 +17,13 @@
 
 #include "llvm/Constants.h"
 #include "llvm/DerivedTypes.h"
-#include "llvm/ParameterAttributes.h"
+#include "llvm/Attributes.h"
 #include "llvm/Function.h"
 #include "llvm/Instructions.h"
 #include "llvm/Assembly/Parser.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/APFloat.h"
+#include "llvm/ADT/APSInt.h"
 namespace llvm { class MemoryBuffer; }
 
 // Global variables exported from the lexer...
@@ -56,7 +57,7 @@ extern void GenerateError(const std::string &message, int LineNo = -1);
 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) {}
 };
@@ -72,16 +73,17 @@ struct InlineAsmDescriptor {
 struct ValID {
   enum {
     LocalID, GlobalID, LocalName, GlobalName,
-    ConstSIntVal, ConstUIntVal, ConstFPVal, ConstNullVal,
+    ConstSIntVal, ConstUIntVal, ConstAPInt, ConstFPVal, ConstNullVal,
     ConstUndefVal, ConstZeroVal, ConstantVal, InlineAsmVal
   } Type;
 
   union {
-    unsigned Num;         // If it's a numeric reference like %1234
-    std::string *Name;    // If it's a named reference.  Memory must be deleted.
-    int64_t  ConstPool64; // Constant pool reference.  This is the value
-    uint64_t UConstPool64;// Unsigned constant pool reference.
-    APFloat *ConstPoolFP; // Floating point constant pool reference
+    unsigned Num;            // If it's a numeric reference like %1234
+    std::string *Name;       // If it's a named reference.  Memory must be deleted.
+    int64_t  ConstPool64;    // Constant pool reference.  This is the value
+    uint64_t UConstPool64;   // Unsigned constant pool reference.
+    APSInt *ConstPoolInt;    // Large Integer constant pool reference
+    APFloat *ConstPoolFP;    // Floating point constant pool reference
     Constant *ConstantValue; // Fully resolved constant for ConstantVal case.
     InlineAsmDescriptor *IAD;
  };
@@ -98,7 +100,7 @@ struct ValID {
   static ValID createGlobalName(const std::string &Name) {
     ValID D; D.Type = GlobalName; D.Name = new std::string(Name); return D;
   }
-  
+
   static ValID create(int64_t Val) {
     ValID D; D.Type = ConstSIntVal; D.ConstPool64 = Val; return D;
   }
@@ -111,6 +113,13 @@ struct ValID {
     ValID D; D.Type = ConstFPVal; D.ConstPoolFP = Val; return D;
   }
 
+  static ValID create(const APInt &Val, bool isSigned) {
+    ValID D; D.Type = ConstAPInt;
+    D.ConstPoolInt = new APSInt(Val, !isSigned);
+    return D;
+  }
+
+
   static ValID createNull() {
     ValID D; D.Type = ConstNullVal; return D;
   }
@@ -122,11 +131,11 @@ struct ValID {
   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) {
@@ -141,11 +150,18 @@ struct ValID {
       delete Name;    // Free this strdup'd memory.
     else if (Type == InlineAsmVal)
       delete IAD;
+    else if (Type == ConstAPInt)
+      delete ConstPoolInt;
+    else if (Type == ConstFPVal)
+      delete ConstPoolFP;
   }
 
   inline ValID copy() const {
-    if (Type != LocalName && Type != GlobalName) return *this;
     ValID Result = *this;
+    if (Type == ConstAPInt)
+      Result.ConstPoolInt = new APSInt(*ConstPoolInt);
+
+    if (Type != LocalName && Type != GlobalName) return Result;
     Result.Name = new std::string(*Name);
     return Result;
   }
@@ -156,6 +172,7 @@ struct ValID {
     case GlobalID      : return '@' + utostr(Num);
     case LocalName     : return *Name;
     case GlobalName    : return *Name;
+    case ConstAPInt    : return ConstPoolInt->toString(10);
     case ConstFPVal    : return ftostr(*ConstPoolFP);
     case ConstNullVal  : return "null";
     case ConstUndefVal : return "undef";
@@ -182,47 +199,48 @@ struct ValID {
     case GlobalName:    return *Name < *V.Name;
     case ConstSIntVal:  return ConstPool64  < V.ConstPool64;
     case ConstUIntVal:  return UConstPool64 < V.UConstPool64;
+    case ConstAPInt:    return ConstPoolInt->ult(*V.ConstPoolInt);
     case ConstFPVal:    return ConstPoolFP->compare(*V.ConstPoolFP) ==
                                APFloat::cmpLessThan;
     case ConstNullVal:  return false;
     case ConstUndefVal: return false;
-    case ConstZeroVal: return false;
+    case ConstZeroVal:  return false;
     case ConstantVal:   return ConstantValue < V.ConstantValue;
     default:  assert(0 && "Unknown value type!"); return false;
     }
   }
 
   bool operator==(const ValID &V) const {
-    if (Type == V.Type) {
-      switch (Type) {
-        case LocalID:
-        case GlobalID: return Num == V.Num;
-        case LocalName:
-        case GlobalName: return *Name == *(V.Name);
-        case ConstSIntVal:  return ConstPool64  == V.ConstPool64;
-        case ConstUIntVal:  return UConstPool64 == V.UConstPool64;
-        case ConstFPVal:    return ConstPoolFP->compare(*V.ConstPoolFP) == 
-                                   APFloat::cmpEqual;
-        case ConstantVal:   return ConstantValue == V.ConstantValue;
-        case ConstNullVal:  return true;
-        case ConstUndefVal: return true;
-        case ConstZeroVal:  return true;
-        default:  assert(0 && "Unknown value type!"); return false;
-      }
+    if (Type != V.Type) return false;
+
+    switch (Type) {
+    default:  assert(0 && "Unknown value type!");
+    case LocalID:
+    case GlobalID:      return Num == V.Num;
+    case LocalName:
+    case GlobalName:    return *Name == *(V.Name);
+    case ConstSIntVal:  return ConstPool64  == V.ConstPool64;
+    case ConstUIntVal:  return UConstPool64 == V.UConstPool64;
+    case ConstAPInt:    return *ConstPoolInt == *V.ConstPoolInt;
+    case ConstFPVal:    return ConstPoolFP->compare(*V.ConstPoolFP) ==
+                               APFloat::cmpEqual;
+    case ConstantVal:   return ConstantValue == V.ConstantValue;
+    case ConstNullVal:  return true;
+    case ConstUndefVal: return true;
+    case ConstZeroVal:  return true;
     }
-    return false;
   }
 };
 
 struct TypeWithAttrs {
   llvm::PATypeHolder *Ty;
-  ParameterAttributes Attrs;
+  Attributes Attrs;
 };
 
-typedef std::vector<TypeWithAttrs> TypeWithAttrsList; 
+typedef std::vector<TypeWithAttrs> TypeWithAttrsList;
 
 struct ArgListEntry {
-  ParameterAttributes Attrs;
+  Attributes Attrs;
   llvm::PATypeHolder *Ty;
   std::string *Name;
 };
@@ -231,7 +249,7 @@ typedef std::vector<struct ArgListEntry> ArgListType;
 
 struct ParamListEntry {
   Value *Val;
-  ParameterAttributes Attrs;
+  Attributes Attrs;
 };
 
 typedef std::vector<ParamListEntry> ParamList;