Eliminate a few unnecessary uses of dynamic_cast.

[oota-llvm.git] / lib / VMCore / InlineAsm.cpp

diff --git a/lib/VMCore/InlineAsm.cpp b/lib/VMCore/InlineAsm.cpp
index cdb8c46e95fa53697197af6a5cbd84355b961833..e49bb6dc8fba2fca31ec2c84aa91be7a69388bd3 100644 (file)
--- a/lib/VMCore/InlineAsm.cpp
+++ b/lib/VMCore/InlineAsm.cpp
@@ -2,8 +2,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file was developed by Chris Lattner and is distributed under the
-// University of Illinois Open Source License. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
@@ -17,6 +17,12 @@
 #include <cctype>
 using namespace llvm;
 
+// Implement the first virtual method in this class in this file so the
+// InlineAsm vtable is emitted here.
+InlineAsm::~InlineAsm() {
+}
+
+
 // NOTE: when memoizing the function type, we have to be careful to handle the
 // case when the type gets refined.
 
@@ -28,7 +34,9 @@ InlineAsm *InlineAsm::get(const FunctionType *Ty, const std::string &AsmString,
 
 InlineAsm::InlineAsm(const FunctionType *Ty, const std::string &asmString,
                      const std::string &constraints, bool hasSideEffects)
-  : Value(PointerType::get(Ty), Value::InlineAsmVal), AsmString(asmString), 
+  : Value(PointerType::getUnqual(Ty), 
+          Value::InlineAsmVal), 
+    AsmString(asmString), 
     Constraints(constraints), HasSideEffects(hasSideEffects) {
 
   // Do various checks on the constraint string and type.
@@ -49,20 +57,22 @@ bool InlineAsm::ConstraintInfo::Parse(const std::string &Str,
   // Initialize
   Type = isInput;
   isEarlyClobber = false;
-  isIndirectOutput = false;
   hasMatchingInput = false;
+  isCommutative = false;
+  isIndirect = false;
   
-  // Parse the prefix.
+  // Parse prefixes.
   if (*I == '~') {
     Type = isClobber;
     ++I;
   } else if (*I == '=') {
     ++I;
     Type = isOutput;
-    if (I != E && *I == '=') {
-      isIndirectOutput = true;
-      ++I;
-    }
+  }
+  
+  if (*I == '*') {
+    isIndirect = true;
+    ++I;
   }
   
   if (I == E) return true;  // Just a prefix, like "==" or "~".
@@ -74,12 +84,21 @@ bool InlineAsm::ConstraintInfo::Parse(const std::string &Str,
     default:
       DoneWithModifiers = true;
       break;
-    case '&':
+    case '&':     // Early clobber.
       if (Type != isOutput ||      // Cannot early clobber anything but output.
           isEarlyClobber)          // Reject &&&&&&
         return true;
       isEarlyClobber = true;
       break;
+    case '%':     // Commutative.
+      if (Type == isClobber ||     // Cannot commute clobbers.
+          isCommutative)           // Reject %%%%%
+        return true;
+      isCommutative = true;
+      break;
+    case '#':     // Comment.
+    case '*':     // Register preferencing.
+      return true;     // Not supported.
     }
     
     if (!DoneWithModifiers) {
@@ -168,12 +187,12 @@ bool InlineAsm::Verify(const FunctionType *Ty, const std::string &ConstStr) {
   for (unsigned i = 0, e = Constraints.size(); i != e; ++i) {
     switch (Constraints[i].Type) {
     case InlineAsm::isOutput:
-      if (!Constraints[i].isIndirectOutput) {
+      if (!Constraints[i].isIndirect) {
         if (NumInputs || NumClobbers) return false;  // outputs come first.
         ++NumOutputs;
         break;
       }
-      // FALLTHROUGH for IndirectOutputs.
+      // FALLTHROUGH for Indirect Outputs.
     case InlineAsm::isInput:
       if (NumClobbers) return false;               // inputs before clobbers.
       ++NumInputs;
@@ -192,3 +211,4 @@ bool InlineAsm::Verify(const FunctionType *Ty, const std::string &ConstStr) {
   if (Ty->getNumParams() != NumInputs) return false;
   return true;
 }
+