lib/ExecutionEngine/Interpreter/Interpreter.cpp

   1 //===- Interpreter.cpp - Top-Level LLVM Interpreter Implementation --------===//
   2 //
   3 // This file implements the top-level functionality for the LLVM interpreter.
   4 // This interpreter is designed to be a very simple, portable, inefficient
   5 // interpreter.
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "Interpreter.h"
  10 #include "llvm/Module.h"
  11 #include "llvm/DerivedTypes.h"
  12 #include "llvm/Function.h"
  13
  14 /// create - Create a new interpreter object.  This can never fail.
  15 ///
  16 ExecutionEngine *Interpreter::create(Module *M, bool TraceMode){
  17   bool isLittleEndian;
  18   switch (M->getEndianness()) {
  19   case Module::LittleEndian: isLittleEndian = true; break;
  20   case Module::BigEndian:    isLittleEndian = false; break;
  21   case Module::AnyPointerSize:
  22     int Test = 0;
  23     *(char*)&Test = 1;    // Return true if the host is little endian
  24     isLittleEndian = (Test == 1);
  25     break;
  26   }
  27
  28   bool isLongPointer;
  29   switch (M->getPointerSize()) {
  30   case Module::Pointer32: isLongPointer = false; break;
  31   case Module::Pointer64: isLongPointer = true; break;
  32   case Module::AnyPointerSize:
  33     isLongPointer = (sizeof(void*) == 8);  // Follow host
  34     break;
  35   }
  36
  37   return new Interpreter(M, isLittleEndian, isLongPointer, TraceMode);
  38 }
  39
  40 //===----------------------------------------------------------------------===//
  41 // Interpreter ctor - Initialize stuff
  42 //
  43 Interpreter::Interpreter(Module *M, bool isLittleEndian, bool isLongPointer,
  44                          bool TraceMode)
  45   : ExecutionEngine(M), ExitCode(0), Trace(TraceMode),
  46     CurFrame(-1), TD("lli", isLittleEndian, isLongPointer ? 8 : 4,
  47                      isLongPointer ? 8 : 4, isLongPointer ? 8 : 4) {
  48
  49   setTargetData(TD);
  50   // Initialize the "backend"
  51   initializeExecutionEngine();
  52   initializeExternalFunctions();
  53   CW.setModule(M);  // Update Writer
  54   emitGlobals();
  55 }
  56
  57 void Interpreter::runAtExitHandlers () {
  58   while (!AtExitHandlers.empty()) {
  59     callFunction(AtExitHandlers.back(), std::vector<GenericValue>());
  60     AtExitHandlers.pop_back();
  61     run();
  62   }
  63 }
  64
  65 /// run - Start execution with the specified function and arguments.
  66 ///
  67 GenericValue Interpreter::run(Function *F,
  68                               const std::vector<GenericValue> &ArgValues) {
  69   assert (F && "Function *F was null at entry to run()");
  70
  71   // Try extra hard not to pass extra args to a function that isn't
  72   // expecting them.  C programmers frequently bend the rules and
  73   // declare main() with fewer parameters than it actually gets
  74   // passed, and the interpreter barfs if you pass a function more
  75   // parameters than it is declared to take. This does not attempt to
  76   // take into account gratuitous differences in declared types,
  77   // though.
  78   std::vector<GenericValue> ActualArgs;
  79   const unsigned ArgCount = F->getFunctionType()->getParamTypes().size();
  80   for (unsigned i = 0; i < ArgCount; ++i) {
  81     ActualArgs.push_back (ArgValues[i]);
  82   }
  83
  84   // Set up the function call.
  85   callFunction(F, ActualArgs);
  86
  87   // Reset the current frame location to the top of stack
  88   CurFrame = ECStack.size()-1;
  89
  90   // Start executing the function.
  91   run();
  92
  93   // Run any atexit handlers now!
  94   runAtExitHandlers();
  95
  96   GenericValue rv;
  97   rv.IntVal = ExitCode;
  98   return rv;
  99 }