#include "llvm/Support/MutexGuard.h"
#include "llvm/System/DynamicLibrary.h"
#include "llvm/Target/TargetData.h"
-#include <iostream>
using namespace llvm;
namespace {
unsigned PtrSize = EE->getTargetData()->getPointerSize();
char *Result = new char[(InputArgv.size()+1)*PtrSize];
- DEBUG(std::cerr << "ARGV = " << (void*)Result << "\n");
+ DOUT << "ARGV = " << (void*)Result << "\n";
const Type *SBytePtr = PointerType::get(Type::SByteTy);
for (unsigned i = 0; i != InputArgv.size(); ++i) {
unsigned Size = InputArgv[i].size()+1;
char *Dest = new char[Size];
- DEBUG(std::cerr << "ARGV[" << i << "] = " << (void*)Dest << "\n");
+ DOUT << "ARGV[" << i << "] = " << (void*)Dest << "\n";
std::copy(InputArgv[i].begin(), InputArgv[i].end(), Dest);
Dest[Size-1] = 0;
default:
break;
}
- std::cerr << "ConstantExpr not handled as global var init: " << *CE << "\n";
+ llvm_cerr << "ConstantExpr not handled as global var init: " << *CE << "\n";
abort();
}
assert(0 && "Unknown constant pointer type!");
break;
default:
- std::cout << "ERROR: Constant unimp for type: " << *C->getType() << "\n";
+ llvm_cerr << "ERROR: Constant unimp for type: " << *C->getType() << "\n";
abort();
}
return Result;
Ptr->Untyped[7] = (unsigned char)(Val.ULongVal >> 56);
break;
default:
- std::cout << "Cannot store value of type " << *Ty << "!\n";
+ llvm_cerr << "Cannot store value of type " << *Ty << "!\n";
}
} else {
switch (Ty->getTypeID()) {
Ptr->Untyped[0] = (unsigned char)(Val.ULongVal >> 56);
break;
default:
- std::cout << "Cannot store value of type " << *Ty << "!\n";
+ llvm_cerr << "Cannot store value of type " << *Ty << "!\n";
}
}
}
((uint64_t)Ptr->Untyped[7] << 56);
break;
default:
- std::cout << "Cannot load value of type " << *Ty << "!\n";
+ llvm_cerr << "Cannot load value of type " << *Ty << "!\n";
abort();
}
} else {
((uint64_t)Ptr->Untyped[0] << 56);
break;
default:
- std::cout << "Cannot load value of type " << *Ty << "!\n";
+ llvm_cerr << "Cannot load value of type " << *Ty << "!\n";
abort();
}
}
}
default:
- std::cerr << "Bad Type: " << *Init->getType() << "\n";
+ llvm_cerr << "Bad Type: " << *Init->getType() << "\n";
assert(0 && "Unknown constant type to initialize memory with!");
}
}
sys::DynamicLibrary::SearchForAddressOfSymbol(I->getName().c_str()))
addGlobalMapping(I, SymAddr);
else {
- std::cerr << "Could not resolve external global address: "
+ llvm_cerr << "Could not resolve external global address: "
<< I->getName() << "\n";
abort();
}
// already in the map.
void ExecutionEngine::EmitGlobalVariable(const GlobalVariable *GV) {
void *GA = getPointerToGlobalIfAvailable(GV);
- DEBUG(std::cerr << "Global '" << GV->getName() << "' -> " << GA << "\n");
+ DOUT << "Global '" << GV->getName() << "' -> " << GA << "\n";
const Type *ElTy = GV->getType()->getElementType();
size_t GVSize = (size_t)getTargetData()->getTypeSize(ElTy);
getOperandValue(CE->getOperand(1), SF),
getOperandValue(CE->getOperand(2), SF));
default:
- std::cerr << "Unhandled ConstantExpr: " << *CE << "\n";
+ llvm_cerr << "Unhandled ConstantExpr: " << *CE << "\n";
abort();
return GenericValue();
}
IMPLEMENT_BINARY_OPERATOR(+, Float);
IMPLEMENT_BINARY_OPERATOR(+, Double);
default:
- std::cout << "Unhandled type for Add instruction: " << *Ty << "\n";
+ llvm_cerr << "Unhandled type for Add instruction: " << *Ty << "\n";
abort();
}
return Dest;
IMPLEMENT_BINARY_OPERATOR(-, Float);
IMPLEMENT_BINARY_OPERATOR(-, Double);
default:
- std::cout << "Unhandled type for Sub instruction: " << *Ty << "\n";
+ llvm_cerr << "Unhandled type for Sub instruction: " << *Ty << "\n";
abort();
}
return Dest;
IMPLEMENT_BINARY_OPERATOR(*, Float);
IMPLEMENT_BINARY_OPERATOR(*, Double);
default:
- std::cout << "Unhandled type for Mul instruction: " << *Ty << "\n";
+ llvm_cerr << "Unhandled type for Mul instruction: " << *Ty << "\n";
abort();
}
return Dest;
IMPLEMENT_SIGNLESS_BINOP(/, UInt, Int);
IMPLEMENT_SIGNLESS_BINOP(/, ULong, Long);
default:
- std::cout << "Unhandled type for UDiv instruction: " << *Ty << "\n";
+ llvm_cerr << "Unhandled type for UDiv instruction: " << *Ty << "\n";
abort();
}
return Dest;
IMPLEMENT_SIGNLESS_BINOP(/, Int, UInt);
IMPLEMENT_SIGNLESS_BINOP(/, Long, ULong);
default:
- std::cout << "Unhandled type for SDiv instruction: " << *Ty << "\n";
+ llvm_cerr << "Unhandled type for SDiv instruction: " << *Ty << "\n";
abort();
}
return Dest;
IMPLEMENT_BINARY_OPERATOR(/, Float);
IMPLEMENT_BINARY_OPERATOR(/, Double);
default:
- std::cout << "Unhandled type for Div instruction: " << *Ty << "\n";
+ llvm_cerr << "Unhandled type for Div instruction: " << *Ty << "\n";
abort();
}
return Dest;
IMPLEMENT_SIGNLESS_BINOP(%, UInt, Int);
IMPLEMENT_SIGNLESS_BINOP(%, ULong, Long);
default:
- std::cout << "Unhandled type for URem instruction: " << *Ty << "\n";
+ llvm_cerr << "Unhandled type for URem instruction: " << *Ty << "\n";
abort();
}
return Dest;
IMPLEMENT_SIGNLESS_BINOP(%, Int, UInt);
IMPLEMENT_SIGNLESS_BINOP(%, Long, ULong);
default:
- std::cout << "Unhandled type for Rem instruction: " << *Ty << "\n";
+ llvm_cerr << "Unhandled type for Rem instruction: " << *Ty << "\n";
abort();
}
return Dest;
Dest.DoubleVal = fmod(Src1.DoubleVal, Src2.DoubleVal);
break;
default:
- std::cout << "Unhandled type for Rem instruction: " << *Ty << "\n";
+ llvm_cerr << "Unhandled type for Rem instruction: " << *Ty << "\n";
abort();
}
return Dest;
IMPLEMENT_BINARY_OPERATOR(&, ULong);
IMPLEMENT_BINARY_OPERATOR(&, Long);
default:
- std::cout << "Unhandled type for And instruction: " << *Ty << "\n";
+ llvm_cerr << "Unhandled type for And instruction: " << *Ty << "\n";
abort();
}
return Dest;
IMPLEMENT_BINARY_OPERATOR(|, ULong);
IMPLEMENT_BINARY_OPERATOR(|, Long);
default:
- std::cout << "Unhandled type for Or instruction: " << *Ty << "\n";
+ llvm_cerr << "Unhandled type for Or instruction: " << *Ty << "\n";
abort();
}
return Dest;
IMPLEMENT_BINARY_OPERATOR(^, ULong);
IMPLEMENT_BINARY_OPERATOR(^, Long);
default:
- std::cout << "Unhandled type for Xor instruction: " << *Ty << "\n";
+ llvm_cerr << "Unhandled type for Xor instruction: " << *Ty << "\n";
abort();
}
return Dest;
IMPLEMENT_SETCC(==, Double);
IMPLEMENT_POINTERSETCC(==);
default:
- std::cout << "Unhandled type for SetEQ instruction: " << *Ty << "\n";
+ llvm_cerr << "Unhandled type for SetEQ instruction: " << *Ty << "\n";
abort();
}
return Dest;
IMPLEMENT_POINTERSETCC(!=);
default:
- std::cout << "Unhandled type for SetNE instruction: " << *Ty << "\n";
+ llvm_cerr << "Unhandled type for SetNE instruction: " << *Ty << "\n";
abort();
}
return Dest;
IMPLEMENT_SETCC(<=, Double);
IMPLEMENT_POINTERSETCC(<=);
default:
- std::cout << "Unhandled type for SetLE instruction: " << *Ty << "\n";
+ llvm_cerr << "Unhandled type for SetLE instruction: " << *Ty << "\n";
abort();
}
return Dest;
IMPLEMENT_SETCC(>=, Double);
IMPLEMENT_POINTERSETCC(>=);
default:
- std::cout << "Unhandled type for SetGE instruction: " << *Ty << "\n";
+ llvm_cerr << "Unhandled type for SetGE instruction: " << *Ty << "\n";
abort();
}
return Dest;
IMPLEMENT_SETCC(<, Double);
IMPLEMENT_POINTERSETCC(<);
default:
- std::cout << "Unhandled type for SetLT instruction: " << *Ty << "\n";
+ llvm_cerr << "Unhandled type for SetLT instruction: " << *Ty << "\n";
abort();
}
return Dest;
IMPLEMENT_SETCC(>, Double);
IMPLEMENT_POINTERSETCC(>);
default:
- std::cout << "Unhandled type for SetGT instruction: " << *Ty << "\n";
+ llvm_cerr << "Unhandled type for SetGT instruction: " << *Ty << "\n";
abort();
}
return Dest;
case Instruction::SetLT: R = executeSetLTInst(Src1, Src2, Ty); break;
case Instruction::SetGT: R = executeSetGTInst(Src1, Src2, Ty); break;
default:
- std::cout << "Don't know how to handle this binary operator!\n-->" << I;
+ llvm_cerr << "Don't know how to handle this binary operator!\n-->" << I;
abort();
}
}
void Interpreter::visitUnreachableInst(UnreachableInst &I) {
- std::cerr << "ERROR: Program executed an 'unreachable' instruction!\n";
+ llvm_cerr << "ERROR: Program executed an 'unreachable' instruction!\n";
abort();
}
IMPLEMENT_SHIFT(<<, ULong);
IMPLEMENT_SHIFT(<<, Long);
default:
- std::cout << "Unhandled type for Shl instruction: " << *Ty << "\n";
+ llvm_cerr << "Unhandled type for Shl instruction: " << *Ty << "\n";
}
return Dest;
}
IMPLEMENT_SIGNLESS_SHIFT(>>, UInt, Int);
IMPLEMENT_SIGNLESS_SHIFT(>>, ULong, Long);
default:
- std::cout << "Unhandled type for LShr instruction: " << *Ty << "\n";
+ llvm_cerr << "Unhandled type for LShr instruction: " << *Ty << "\n";
abort();
}
return Dest;
IMPLEMENT_SIGNLESS_SHIFT(>>, Int, UInt);
IMPLEMENT_SIGNLESS_SHIFT(>>, Long, ULong);
default:
- std::cout << "Unhandled type for AShr instruction: " << *Ty << "\n";
+ llvm_cerr << "Unhandled type for AShr instruction: " << *Ty << "\n";
abort();
}
return Dest;
IMPLEMENT_CAST(DESTTY, DESTCTY, Float); \
IMPLEMENT_CAST(DESTTY, DESTCTY, Double) \
default: \
- std::cout << "Unhandled cast: " \
+ llvm_cerr << "Unhandled cast: " \
<< *SrcTy << " to " << *DstTy << "\n"; \
abort(); \
} \
break
#define IMPLEMENT_CAST_END \
- default: std::cout \
+ default: llvm_cerr \
<< "Unhandled dest type for cast instruction: " \
<< *DstTy << "\n"; \
abort(); \
IMPLEMENT_CAST_END
break;
default:
- std::cout
+ llvm_cerr
<< "Invalid cast opcode for cast instruction: " << opcode << "\n";
abort();
}
IMPLEMENT_VAARG(Double);
IMPLEMENT_VAARG(Bool);
default:
- std::cout << "Unhandled dest type for vaarg instruction: " << *Ty << "\n";
+ llvm_cerr << "Unhandled dest type for vaarg instruction: " << *Ty << "\n";
abort();
}
// Track the number of dynamic instructions executed.
++NumDynamicInsts;
- DEBUG(std::cerr << "About to interpret: " << I);
+ DOUT << "About to interpret: " << I;
visit(I); // Dispatch to one of the visit* methods...
}
}
#include "Interpreter.h"
#include "llvm/DerivedTypes.h"
#include "llvm/Module.h"
+#include "llvm/Support/Streams.h"
#include "llvm/System/DynamicLibrary.h"
#include "llvm/Target/TargetData.h"
#include <csignal>
std::map<const Function *, ExFunc>::iterator FI = Functions.find(F);
ExFunc Fn = (FI == Functions.end()) ? lookupFunction(F) : FI->second;
if (Fn == 0) {
- std::cout << "Tried to execute an unknown external function: "
+ llvm_cerr << "Tried to execute an unknown external function: "
<< F->getType()->getDescription() << " " << F->getName() << "\n";
if (F->getName() == "__main")
return GenericValue();
// void putchar(sbyte)
GenericValue lle_Vb_putchar(FunctionType *M, const vector<GenericValue> &Args) {
- std::cout << Args[0].SByteVal;
+ llvm_cout << Args[0].SByteVal;
return GenericValue();
}
// int putchar(int)
GenericValue lle_ii_putchar(FunctionType *M, const vector<GenericValue> &Args) {
- std::cout << ((char)Args[0].IntVal) << std::flush;
+ llvm_cout << ((char)Args[0].IntVal) << std::flush;
return Args[0];
}
// void putchar(ubyte)
GenericValue lle_VB_putchar(FunctionType *M, const vector<GenericValue> &Args) {
- std::cout << Args[0].SByteVal << std::flush;
+ llvm_cout << Args[0].SByteVal << std::flush;
return Args[0];
}
sprintf(Buffer, FmtBuf, (void*)GVTOP(Args[ArgNo++])); break;
case 's':
sprintf(Buffer, FmtBuf, (char*)GVTOP(Args[ArgNo++])); break;
- default: std::cout << "<unknown printf code '" << *FmtStr << "'!>";
+ default: llvm_cerr << "<unknown printf code '" << *FmtStr << "'!>";
ArgNo++; break;
}
strcpy(OutputBuffer, Buffer);
NewArgs.push_back(PTOGV(Buffer));
NewArgs.insert(NewArgs.end(), Args.begin(), Args.end());
GenericValue GV = lle_X_sprintf(M, NewArgs);
- std::cout << Buffer;
+ llvm_cout << Buffer;
return GV;
}