Add more support for intrinsic functions and for varargs stuff

llvm-svn: 6035

lib/VMCore/Function.cpp

@@ -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"
 
@@ -150,6 +151,41 @@ void Function::dropAllReferences() {
     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
 //===----------------------------------------------------------------------===//

lib/VMCore/Verifier.cpp

@@ -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 @@ namespace {  // Anonymous namespace for class
     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 @@ void Verifier::visitCallInst(CallInst &CI) {
             "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 @@ void Verifier::visitInstruction(Instruction &I) {
               "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);
 }