Minor changes to make the diff be nothing against the X86 version

[oota-llvm.git] / lib / ExecutionEngine / ExecutionEngine.cpp

diff --git a/lib/ExecutionEngine/ExecutionEngine.cpp b/lib/ExecutionEngine/ExecutionEngine.cpp
index c9fd5776546cbfad5c4acc8dd5e2d72afa68f235..105c0b8a1d933c1f9481b0f6edd93ff03ddf7015 100644 (file)
--- a/lib/ExecutionEngine/ExecutionEngine.cpp
+++ b/lib/ExecutionEngine/ExecutionEngine.cpp
@@ -102,14 +102,21 @@ int ExecutionEngine::runFunctionAsMain(Function *Fn,
   std::vector<GenericValue> GVArgs;
   GenericValue GVArgc;
   GVArgc.IntVal = argv.size();
-  GVArgs.push_back(GVArgc); // Arg #0 = argc.
-  GVArgs.push_back(PTOGV(CreateArgv(this, argv))); // Arg #1 = argv.
-  assert(((char **)GVTOP(GVArgs[1]))[0] && "argv[0] was null after CreateArgv");
-
-  std::vector<std::string> EnvVars;
-  for (unsigned i = 0; envp[i]; ++i)
-    EnvVars.push_back(envp[i]);
-  GVArgs.push_back(PTOGV(CreateArgv(this, EnvVars))); // Arg #2 = envp.
+  unsigned NumArgs = Fn->getFunctionType()->getNumParams();
+  if (NumArgs) {
+    GVArgs.push_back(GVArgc); // Arg #0 = argc.
+    if (NumArgs > 1) {
+      GVArgs.push_back(PTOGV(CreateArgv(this, argv))); // Arg #1 = argv.
+      assert(((char **)GVTOP(GVArgs[1]))[0] &&
+             "argv[0] was null after CreateArgv");
+      if (NumArgs > 2) {
+        std::vector<std::string> EnvVars;
+        for (unsigned i = 0; envp[i]; ++i)
+          EnvVars.push_back(envp[i]);
+        GVArgs.push_back(PTOGV(CreateArgv(this, EnvVars))); // Arg #2 = envp.
+      }
+    }
+  }
   return runFunction(Fn, GVArgs).IntVal;
 }
 
@@ -137,6 +144,8 @@ ExecutionEngine *ExecutionEngine::create(ModuleProvider *MP,
       } catch (...) {
         std::cerr << "Error creating the interpreter!\n";
       }
+    } catch (std::string& errmsg) {
+      std::cerr << "Error reading the bytecode file: " << errmsg << "\n";
     } catch (...) {
       std::cerr << "Error reading the bytecode file!\n";
     }
@@ -206,14 +215,38 @@ GenericValue ExecutionEngine::getConstantValue(const Constant *C) {
     }
 
     case Instruction::Add:
-      if (CE->getOperand(0)->getType() == Type::LongTy ||
-          CE->getOperand(0)->getType() == Type::ULongTy)
+      switch (CE->getOperand(0)->getType()->getTypeID()) {
+      default: assert(0 && "Bad add type!"); abort();
+      case Type::LongTyID:
+      case Type::ULongTyID:
         Result.LongVal = getConstantValue(CE->getOperand(0)).LongVal +
                          getConstantValue(CE->getOperand(1)).LongVal;
-      else
         break;
+      case Type::IntTyID:
+      case Type::UIntTyID:
+        Result.IntVal = getConstantValue(CE->getOperand(0)).IntVal +
+                        getConstantValue(CE->getOperand(1)).IntVal;
+        break;
+      case Type::ShortTyID:
+      case Type::UShortTyID:
+        Result.ShortVal = getConstantValue(CE->getOperand(0)).ShortVal +
+                          getConstantValue(CE->getOperand(1)).ShortVal;
+        break;
+      case Type::SByteTyID:
+      case Type::UByteTyID:
+        Result.SByteVal = getConstantValue(CE->getOperand(0)).SByteVal +
+                          getConstantValue(CE->getOperand(1)).SByteVal;
+        break;
+      case Type::FloatTyID:
+        Result.FloatVal = getConstantValue(CE->getOperand(0)).FloatVal +
+                          getConstantValue(CE->getOperand(1)).FloatVal;
+        break;
+      case Type::DoubleTyID:
+        Result.DoubleVal = getConstantValue(CE->getOperand(0)).DoubleVal +
+                           getConstantValue(CE->getOperand(1)).DoubleVal;
+        break;
+      }
       return Result;
-
     default:
       break;
     }
@@ -237,22 +270,17 @@ GenericValue ExecutionEngine::getConstantValue(const Constant *C) {
     GET_CONST_VAL(Double , ConstantFP);
 #undef GET_CONST_VAL
   case Type::PointerTyID:
-    if (isa<ConstantPointerNull>(C)) {
+    if (isa<ConstantPointerNull>(C))
       Result.PointerVal = 0;
-    } else if (const ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(C)){
-      if (Function *F =
-          const_cast<Function*>(dyn_cast<Function>(CPR->getValue())))
-        Result = PTOGV(getPointerToFunctionOrStub(F));
-      else 
-        Result = PTOGV(getOrEmitGlobalVariable(
-                           cast<GlobalVariable>(CPR->getValue())));
-
-    } else {
+    else if (const Function *F = dyn_cast<Function>(C))
+      Result = PTOGV(getPointerToFunctionOrStub(const_cast<Function*>(F)));
+    else if (const GlobalVariable* GV = dyn_cast<GlobalVariable>(C))
+      Result = PTOGV(getOrEmitGlobalVariable(const_cast<GlobalVariable*>(GV)));
+    else
       assert(0 && "Unknown constant pointer type!");
-    }
     break;
   default:
-    std::cout << "ERROR: Constant unimp for type: " << C->getType() << "\n";
+    std::cout << "ERROR: Constant unimp for type: " << *C->getType() << "\n";
     abort();
   }
   return Result;
@@ -293,7 +321,7 @@ void ExecutionEngine::StoreValueToMemory(GenericValue Val, GenericValue *Ptr,
                             Ptr->Untyped[7] = (Val.ULongVal >> 56) & 255;
                             break;
     default:
-      std::cout << "Cannot store value of type " << Ty << "!\n";
+      std::cout << "Cannot store value of type " << *Ty << "!\n";
     }
   } else {
     switch (Ty->getTypeID()) {
@@ -326,7 +354,7 @@ void ExecutionEngine::StoreValueToMemory(GenericValue Val, GenericValue *Ptr,
                             Ptr->Untyped[0] = (Val.ULongVal >> 56) & 255;
                             break;
     default:
-      std::cout << "Cannot store value of type " << Ty << "!\n";
+      std::cout << "Cannot store value of type " << *Ty << "!\n";
     }
   }
 }
@@ -425,11 +453,10 @@ void ExecutionEngine::InitializeMemory(const Constant *Init, void *Addr) {
   switch (Init->getType()->getTypeID()) {
   case Type::ArrayTyID: {
     const ConstantArray *CPA = cast<ConstantArray>(Init);
-    const std::vector<Use> &Val = CPA->getValues();
     unsigned ElementSize = 
       getTargetData().getTypeSize(cast<ArrayType>(CPA->getType())->getElementType());
-    for (unsigned i = 0; i < Val.size(); ++i)
-      InitializeMemory(cast<Constant>(Val[i].get()), (char*)Addr+i*ElementSize);
+    for (unsigned i = 0, e = CPA->getNumOperands(); i != e; ++i)
+      InitializeMemory(CPA->getOperand(i), (char*)Addr+i*ElementSize);
     return;
   }
 
@@ -437,15 +464,13 @@ void ExecutionEngine::InitializeMemory(const Constant *Init, void *Addr) {
     const ConstantStruct *CPS = cast<ConstantStruct>(Init);
     const StructLayout *SL =
       getTargetData().getStructLayout(cast<StructType>(CPS->getType()));
-    const std::vector<Use> &Val = CPS->getValues();
-    for (unsigned i = 0; i < Val.size(); ++i)
-      InitializeMemory(cast<Constant>(Val[i].get()),
-                       (char*)Addr+SL->MemberOffsets[i]);
+    for (unsigned i = 0, e = CPS->getNumOperands(); i != e; ++i)
+      InitializeMemory(CPS->getOperand(i), (char*)Addr+SL->MemberOffsets[i]);
     return;
   }
 
   default:
-    std::cerr << "Bad Type: " << Init->getType() << "\n";
+    std::cerr << "Bad Type: " << *Init->getType() << "\n";
     assert(0 && "Unknown constant type to initialize memory with!");
   }
 }