[llvm-commits] CVS: llvm/lib/VMCore/Function.cpp Verifier.cpp

Chris Lattner lattner at cs.uiuc.edu
Wed May 7 22:48:03 PDT 2003


Changes in directory llvm/lib/VMCore:

Function.cpp updated: 1.37 -> 1.38
Verifier.cpp updated: 1.47 -> 1.48

---
Log message:

Add more support for intrinsic functions and for varargs stuff



---
Diffs of the changes:

Index: llvm/lib/VMCore/Function.cpp
diff -u llvm/lib/VMCore/Function.cpp:1.37 llvm/lib/VMCore/Function.cpp:1.38
--- llvm/lib/VMCore/Function.cpp:1.37	Wed Apr 16 15:28:45 2003
+++ llvm/lib/VMCore/Function.cpp	Wed May  7 22:47:33 2003
@@ -8,6 +8,7 @@
 #include "llvm/Module.h"
 #include "llvm/DerivedTypes.h"
 #include "llvm/iOther.h"
+#include "llvm/Intrinsics.h"
 #include "Support/LeakDetector.h"
 #include "SymbolTableListTraitsImpl.h"
 
@@ -149,6 +150,41 @@
   for (iterator I = begin(), E = end(); I != E; ++I)
     I->dropAllReferences();
 }
+
+/// getIntrinsicID - This method returns the ID number of the specified
+/// function, or LLVMIntrinsic::not_intrinsic if the function is not an
+/// instrinsic, or if the pointer is null.  This value is always defined to be
+/// zero to allow easy checking for whether a function is intrinsic or not.  The
+/// particular intrinsic functions which correspond to this value are defined in
+/// llvm/Intrinsics.h.
+///
+unsigned Function::getIntrinsicID() const {
+  if (getName().size() <= 5 || getName()[4] != '.' || getName()[0] != 'l' ||
+      getName()[1] != 'l' || getName()[2] != 'v' || getName()[3] != 'm')
+    return 0;  // All intrinsics start with 'llvm.'
+  
+  switch (getName()[5]) {
+  case 'v':
+    if (getName().size() >= 9) {
+      switch (getName()[8]) {
+      case 's':
+        if (getName() == "llvm.va_start") return LLVMIntrinsic::va_start;
+        break;
+      case 'e':
+        if (getName() == "llvm.va_end") return LLVMIntrinsic::va_end;
+        break;
+      case 'c':
+        if (getName() == "llvm.va_copy") return LLVMIntrinsic::va_copy;
+        break;
+      }
+    }
+    break;
+  }
+  // The "llvm." namespace is reserved!
+  assert(0 && "Unknown LLVM intrinsic function!");
+  return 0;
+}
+
 
 //===----------------------------------------------------------------------===//
 // GlobalVariable Implementation


Index: llvm/lib/VMCore/Verifier.cpp
diff -u llvm/lib/VMCore/Verifier.cpp:1.47 llvm/lib/VMCore/Verifier.cpp:1.48
--- llvm/lib/VMCore/Verifier.cpp:1.47	Wed May  7 21:44:12 2003
+++ llvm/lib/VMCore/Verifier.cpp	Wed May  7 22:47:33 2003
@@ -43,6 +43,7 @@
 #include "llvm/iMemory.h"
 #include "llvm/SymbolTable.h"
 #include "llvm/PassManager.h"
+#include "llvm/Intrinsics.h"
 #include "llvm/Analysis/Dominators.h"
 #include "llvm/Support/CFG.h"
 #include "llvm/Support/InstVisitor.h"
@@ -140,6 +141,7 @@
     void visitReturnInst(ReturnInst &RI);
     void visitUserOp1(Instruction &I);
     void visitUserOp2(Instruction &I) { visitUserOp1(I); }
+    void visitIntrinsicFunctionCall(LLVMIntrinsic::ID ID, CallInst &CI);
 
     // CheckFailed - A check failed, so print out the condition and the message
     // that failed.  This provides a nice place to put a breakpoint if you want
@@ -359,6 +361,10 @@
             "Call parameter type does not match function signature!",
             CI.getOperand(i+1), FTy->getParamType(i));
 
+  if (Function *F = CI.getCalledFunction())
+    if (LLVMIntrinsic::ID ID = (LLVMIntrinsic::ID)F->getIntrinsicID())
+      visitIntrinsicFunctionCall(ID, CI);
+
   visitInstruction(CI);
 }
 
@@ -495,6 +501,37 @@
               "Instruction does not dominate all uses!", &I, Use);
     }
   }
+
+  // Check to make sure that the "address of" an intrinsic function is never
+  // taken.
+  for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i)
+    if (Function *F = dyn_cast<Function>(I.getOperand(i)))
+      Assert1(!F->isIntrinsic() || (i == 0 && isa<CallInst>(I)),
+              "Cannot take the address of an intrinsic!", &I);
+}
+
+/// visitIntrinsicFunction - Allow intrinsics to be verified in different ways.
+void Verifier::visitIntrinsicFunctionCall(LLVMIntrinsic::ID ID, CallInst &CI) {
+  Function *IF = CI.getCalledFunction();
+  const FunctionType *FT = IF->getFunctionType();
+  Assert1(IF->isExternal(), "Intrinsic functions should never be defined!", IF);
+  unsigned NumArgs;
+
+  switch (ID) {
+  case LLVMIntrinsic::va_start:
+    Assert1(isa<Argument>(CI.getOperand(2)),
+            "va_start second argument should be a function argument!", &CI);
+    NumArgs = 2;
+    break;
+  case LLVMIntrinsic::va_end: NumArgs = 1; break;
+  case LLVMIntrinsic::va_copy: NumArgs = 2; break;
+  case LLVMIntrinsic::not_intrinsic: 
+    assert(0 && "Invalid intrinsic!"); NumArgs = 0; break;
+  }
+
+  Assert1(FT->getNumParams() == NumArgs || (FT->getNumParams() < NumArgs &&
+                                             FT->isVarArg()),
+          "Illegal # arguments for intrinsic function!", IF);
 }
 
 





More information about the llvm-commits mailing list