projects / oota-llvm.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Remove PointerType from target definition. Use abstract type MVT::iPTR to
[oota-llvm.git] / utils / TableGen / CodeGenTarget.cpp
diff --git a/utils/TableGen/CodeGenTarget.cpp b/utils/TableGen/CodeGenTarget.cpp
index 6bee477f31745b826e40be0a17a69d039b165b4c..6fb97c550485e1cfff09d0105576b0428fb1470d 100644 (file)
--- a/utils/TableGen/CodeGenTarget.cpp
+++ b/utils/TableGen/CodeGenTarget.cpp
@@ -30,12 +30,7 @@ AsmWriterNum("asmwriternum", cl::init(0),
 /// getValueType - Return the MCV::ValueType that the specified TableGen record
 /// corresponds to.
 MVT::ValueType llvm::getValueType(Record *Rec, const CodeGenTarget *CGT) {
-  MVT::ValueType VT = (MVT::ValueType)Rec->getValueAsInt("Value");
-  if (VT == MVT::iPTR) {
-    assert(CGT && "Use a pointer type in a place that isn't supported yet!");
-    VT = CGT->getPointerType();
-  }
-  return VT;
+  return (MVT::ValueType)Rec->getValueAsInt("Value");
 }
 
 std::string llvm::getName(MVT::ValueType T) {
@@ -63,35 +58,37 @@ std::string llvm::getName(MVT::ValueType T) {
   case MVT::v2f32: return "v2f32";
   case MVT::v4f32: return "v4f32";
   case MVT::v2f64: return "v2f64";
+  case MVT::iPTR:  return "TLI.getPointetTy()";
   default: assert(0 && "ILLEGAL VALUE TYPE!"); return "";
   }
 }
 
 std::string llvm::getEnumName(MVT::ValueType T) {
   switch (T) {
-  case MVT::Other: return "Other";
-  case MVT::i1:    return "i1";
-  case MVT::i8:    return "i8";
-  case MVT::i16:   return "i16";
-  case MVT::i32:   return "i32";
-  case MVT::i64:   return "i64";
-  case MVT::i128:  return "i128";
-  case MVT::f32:   return "f32";
-  case MVT::f64:   return "f64";
-  case MVT::f80:   return "f80";
-  case MVT::f128:  return "f128";
-  case MVT::Flag:  return "Flag";
-  case MVT::isVoid:return "isVoid";
-  case MVT::v8i8:  return "v8i8";
-  case MVT::v4i16: return "v4i16";
-  case MVT::v2i32: return "v2i32";
-  case MVT::v16i8: return "v16i8";
-  case MVT::v8i16: return "v8i16";
-  case MVT::v4i32: return "v4i32";
-  case MVT::v2i64: return "v2i64";
-  case MVT::v2f32: return "v2f32";
-  case MVT::v4f32: return "v4f32";
-  case MVT::v2f64: return "v2f64";
+  case MVT::Other: return "MVT::Other";
+  case MVT::i1:    return "MVT::i1";
+  case MVT::i8:    return "MVT::i8";
+  case MVT::i16:   return "MVT::i16";
+  case MVT::i32:   return "MVT::i32";
+  case MVT::i64:   return "MVT::i64";
+  case MVT::i128:  return "MVT::i128";
+  case MVT::f32:   return "MVT::f32";
+  case MVT::f64:   return "MVT::f64";
+  case MVT::f80:   return "MVT::f80";
+  case MVT::f128:  return "MVT::f128";
+  case MVT::Flag:  return "MVT::Flag";
+  case MVT::isVoid:return "MVT::isVoid";
+  case MVT::v8i8:  return "MVT::v8i8";
+  case MVT::v4i16: return "MVT::v4i16";
+  case MVT::v2i32: return "MVT::v2i32";
+  case MVT::v16i8: return "MVT::v16i8";
+  case MVT::v8i16: return "MVT::v8i16";
+  case MVT::v4i32: return "MVT::v4i32";
+  case MVT::v2i64: return "MVT::v2i64";
+  case MVT::v2f32: return "MVT::v2f32";
+  case MVT::v4f32: return "MVT::v4f32";
+  case MVT::v2f64: return "MVT::v2f64";
+  case MVT::iPTR:  return "TLI.getPointetTy()";
   default: assert(0 && "ILLEGAL VALUE TYPE!"); return "";
   }
 }
@@ -104,7 +101,7 @@ std::ostream &llvm::operator<<(std::ostream &OS, MVT::ValueType T) {
 
 /// getTarget - Return the current instance of the Target class.
 ///
-CodeGenTarget::CodeGenTarget() : PointerType(MVT::Other) {
+CodeGenTarget::CodeGenTarget() {
   std::vector<Record*> Targets = Records.getAllDerivedDefinitions("Target");
   if (Targets.size() == 0)
     throw std::string("ERROR: No 'Target' subclasses defined!");
@@ -114,7 +111,6 @@ CodeGenTarget::CodeGenTarget() : PointerType(MVT::Other) {
 
   // Read in all of the CalleeSavedRegisters.
   CalleeSavedRegisters =TargetRec->getValueAsListOfDefs("CalleeSavedRegisters");
-  PointerType = getValueType(TargetRec->getValueAsDef("PointerType"));
 }
 
 
@@ -163,6 +159,23 @@ void CodeGenTarget::ReadRegisterClasses() const {
   RegisterClasses.assign(RegClasses.begin(), RegClasses.end());
 }
 
+std::vector<unsigned char> CodeGenTarget::getRegisterVTs(Record *R) const {
+  std::vector<unsigned char> Result;
+  const std::vector<CodeGenRegisterClass> &RCs = getRegisterClasses();
+  for (unsigned i = 0, e = RCs.size(); i != e; ++i) {
+    const CodeGenRegisterClass &RC = RegisterClasses[i];
+    for (unsigned ei = 0, ee = RC.Elements.size(); ei != ee; ++ei) {
+      if (R == RC.Elements[ei]) {
+        const std::vector<MVT::ValueType> &InVTs = RC.getValueTypes();
+        for (unsigned i = 0, e = InVTs.size(); i != e; ++i)
+          Result.push_back(InVTs[i]);
+      }
+    }
+  }
+  return Result;
+}
+
+
 CodeGenRegisterClass::CodeGenRegisterClass(Record *R) : TheDef(R) {
   // Rename anonymous register classes.
   if (R->getName().size() > 9 && R->getName()[9] == '.') {
@@ -362,13 +375,21 @@ std::vector<CodeGenIntrinsic> llvm::LoadIntrinsics(const RecordKeeper &RC) {
   std::vector<Record*> I = RC.getAllDerivedDefinitions("Intrinsic");
   
   std::vector<CodeGenIntrinsic> Result;
-  CodeGenTarget CGT;
+
+  // If we are in the context of a target .td file, get the target info so that
+  // we can decode the current intptr_t.
+  CodeGenTarget *CGT = 0;
+  if (Records.getClass("Target") &&
+      Records.getAllDerivedDefinitions("Target").size() == 1)
+    CGT = new CodeGenTarget();
+  
   for (unsigned i = 0, e = I.size(); i != e; ++i)
     Result.push_back(CodeGenIntrinsic(I[i], CGT));
+  delete CGT;
   return Result;
 }
 
-CodeGenIntrinsic::CodeGenIntrinsic(Record *R, CodeGenTarget &CGT) {
+CodeGenIntrinsic::CodeGenIntrinsic(Record *R, CodeGenTarget *CGT) {
   TheDef = R;
   std::string DefName = R->getName();
   ModRef = WriteMem;
@@ -415,7 +436,8 @@ CodeGenIntrinsic::CodeGenIntrinsic(Record *R, CodeGenTarget &CGT) {
     assert(TyEl->isSubClassOf("LLVMType") && "Expected a type!");
     ArgTypes.push_back(TyEl->getValueAsString("TypeVal"));
     
-    ArgVTs.push_back(getValueType(TyEl->getValueAsDef("VT"), &CGT));
+    if (CGT)
+      ArgVTs.push_back(getValueType(TyEl->getValueAsDef("VT"), CGT));
     ArgTypeDefs.push_back(TyEl);
   }
   if (ArgTypes.size() == 0)
@@ -430,13 +452,13 @@ CodeGenIntrinsic::CodeGenIntrinsic(Record *R, CodeGenTarget &CGT) {
     assert(Property->isSubClassOf("IntrinsicProperty") &&
            "Expected a property!");
     
-    if (Property->getName() == "InstrNoMem")
+    if (Property->getName() == "IntrNoMem")
       ModRef = NoMem;
-    else if (Property->getName() == "InstrReadArgMem")
+    else if (Property->getName() == "IntrReadArgMem")
       ModRef = ReadArgMem;
     else if (Property->getName() == "IntrReadMem")
       ModRef = ReadMem;
-    else if (Property->getName() == "InstrWriteArgMem")
+    else if (Property->getName() == "IntrWriteArgMem")
       ModRef = WriteArgMem;
     else if (Property->getName() == "IntrWriteMem")
       ModRef = WriteMem;
C/C++ LLVM-based compilers that forbids OOTA behaviors