#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Streams.h"
+#include "llvm/Support/raw_ostream.h"
#include "llvm/Config/config.h"
#include <algorithm>
-#include <iostream>
#include <set>
using namespace llvm;
/// module to a C++ translation unit.
class CppWriter : public ModulePass {
const char* progname;
- std::ostream &Out;
+ raw_ostream &Out;
const Module *TheModule;
uint64_t uniqueNum;
TypeMap TypeNames;
public:
static char ID;
- explicit CppWriter(std::ostream &o) :
- ModulePass((intptr_t)&ID), Out(o), uniqueNum(0), is_inline(false) {}
+ explicit CppWriter(raw_ostream &o) :
+ ModulePass(&ID), Out(o), uniqueNum(0), is_inline(false) {}
virtual const char *getPassName() const { return "C++ backend"; }
std::string getCppName(const Value* val);
inline void printCppName(const Value* val);
- void printParamAttrs(const PAListPtr &PAL, const std::string &name);
+ void printAttributes(const AttrListPtr &PAL, const std::string &name);
bool printTypeInternal(const Type* Ty);
inline void printType(const Type* Ty);
void printTypes(const Module* M);
};
static unsigned indent_level = 0;
- inline std::ostream& nl(std::ostream& Out, int delta = 0) {
+ inline raw_ostream& nl(raw_ostream& Out, int delta = 0) {
Out << "\n";
if (delta >= 0 || indent_level >= unsigned(-delta))
indent_level += delta;
}
void CppWriter::error(const std::string& msg) {
- std::cerr << progname << ": " << msg << "\n";
+ cerr << progname << ": " << msg << "\n";
exit(2);
}
if (CFP->getType() == Type::FloatTy)
APF.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven);
Out << "ConstantFP::get(";
- if (CFP->getType() == Type::DoubleTy)
- Out << "Type::DoubleTy, ";
- else
- Out << "Type::FloatTy, ";
Out << "APFloat(";
#if HAVE_PRINTF_A
char Buffer[100];
else
Out << StrVal << "f";
} else if (CFP->getType() == Type::DoubleTy)
- Out << "BitsToDouble(0x" << std::hex
- << CFP->getValueAPF().convertToAPInt().getZExtValue()
- << std::dec << "ULL) /* " << StrVal << " */";
+ Out << "BitsToDouble(0x"
+ << utohexstr(CFP->getValueAPF().bitcastToAPInt().getZExtValue())
+ << "ULL) /* " << StrVal << " */";
else
- Out << "BitsToFloat(0x" << std::hex
- << (uint32_t)CFP->getValueAPF().convertToAPInt().getZExtValue()
- << std::dec << "U) /* " << StrVal << " */";
+ Out << "BitsToFloat(0x"
+ << utohexstr((uint32_t)CFP->getValueAPF().
+ bitcastToAPInt().getZExtValue())
+ << "U) /* " << StrVal << " */";
Out << ")";
#if HAVE_PRINTF_A
}
Out << "GlobalValue::ExternalWeakLinkage"; break;
case GlobalValue::GhostLinkage:
Out << "GlobalValue::GhostLinkage"; break;
+ case GlobalValue::CommonLinkage:
+ Out << "GlobalValue::CommonLinkage"; break;
}
}
printEscapedString(getCppName(val));
}
- void CppWriter::printParamAttrs(const PAListPtr &PAL,
+ void CppWriter::printAttributes(const AttrListPtr &PAL,
const std::string &name) {
- Out << "PAListPtr " << name << "_PAL;";
+ Out << "AttrListPtr " << name << "_PAL;";
nl(Out);
if (!PAL.isEmpty()) {
Out << '{'; in(); nl(Out);
- Out << "SmallVector<ParamAttrsWithIndex, 4> Attrs;"; nl(Out);
- Out << "ParamAttrsWithIndex PAWI;"; nl(Out);
+ Out << "SmallVector<AttributeWithIndex, 4> Attrs;"; nl(Out);
+ Out << "AttributeWithIndex PAWI;"; nl(Out);
for (unsigned i = 0; i < PAL.getNumSlots(); ++i) {
uint16_t index = PAL.getSlot(i).Index;
- ParameterAttributes attrs = PAL.getSlot(i).Attrs;
+ Attributes attrs = PAL.getSlot(i).Attrs;
Out << "PAWI.Index = " << index << "; PAWI.Attrs = 0 ";
- if (attrs & ParamAttr::SExt)
- Out << " | ParamAttr::SExt";
- if (attrs & ParamAttr::ZExt)
- Out << " | ParamAttr::ZExt";
- if (attrs & ParamAttr::StructRet)
- Out << " | ParamAttr::StructRet";
- if (attrs & ParamAttr::InReg)
- Out << " | ParamAttr::InReg";
- if (attrs & ParamAttr::NoReturn)
- Out << " | ParamAttr::NoReturn";
- if (attrs & ParamAttr::NoUnwind)
- Out << " | ParamAttr::NoUnwind";
- if (attrs & ParamAttr::ByVal)
- Out << " | ParamAttr::ByVal";
- if (attrs & ParamAttr::NoAlias)
- Out << " | ParamAttr::NoAlias";
- if (attrs & ParamAttr::Nest)
- Out << " | ParamAttr::Nest";
- if (attrs & ParamAttr::ReadNone)
- Out << " | ParamAttr::ReadNone";
- if (attrs & ParamAttr::ReadOnly)
- Out << " | ParamAttr::ReadOnly";
+ if (attrs & Attribute::SExt)
+ Out << " | Attribute::SExt";
+ if (attrs & Attribute::ZExt)
+ Out << " | Attribute::ZExt";
+ if (attrs & Attribute::StructRet)
+ Out << " | Attribute::StructRet";
+ if (attrs & Attribute::InReg)
+ Out << " | Attribute::InReg";
+ if (attrs & Attribute::NoReturn)
+ Out << " | Attribute::NoReturn";
+ if (attrs & Attribute::NoUnwind)
+ Out << " | Attribute::NoUnwind";
+ if (attrs & Attribute::ByVal)
+ Out << " | Attribute::ByVal";
+ if (attrs & Attribute::NoAlias)
+ Out << " | Attribute::NoAlias";
+ if (attrs & Attribute::Nest)
+ Out << " | Attribute::Nest";
+ if (attrs & Attribute::ReadNone)
+ Out << " | Attribute::ReadNone";
+ if (attrs & Attribute::ReadOnly)
+ Out << " | Attribute::ReadOnly";
Out << ";";
nl(Out);
Out << "Attrs.push_back(PAWI);";
nl(Out);
}
- Out << name << "_PAL = PAListPtr::get(Attrs.begin(), Attrs.end());";
+ Out << name << "_PAL = AttrListPtr::get(Attrs.begin(), Attrs.end());";
nl(Out);
out(); nl(Out);
Out << '}'; nl(Out);
std::string constName(getCppName(CV));
std::string typeName(getCppName(CV->getType()));
- if (CV->isNullValue()) {
- Out << "Constant* " << constName << " = Constant::getNullValue("
- << typeName << ");";
- nl(Out);
- return;
- }
+
if (isa<GlobalValue>(CV)) {
// Skip variables and functions, we emit them elsewhere
return;
}
+
if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) {
+ std::string constValue = CI->getValue().toString(10, true);
Out << "ConstantInt* " << constName << " = ConstantInt::get(APInt("
- << cast<IntegerType>(CI->getType())->getBitWidth() << ", "
- << " \"" << CI->getValue().toStringSigned(10) << "\", 10));";
+ << cast<IntegerType>(CI->getType())->getBitWidth() << ", \""
+ << constValue << "\", " << constValue.length() << ", 10));";
} else if (isa<ConstantAggregateZero>(CV)) {
Out << "ConstantAggregateZero* " << constName
<< " = ConstantAggregateZero::get(" << typeName << ");";
} else if (isa<ConstantPointerNull>(CV)) {
Out << "ConstantPointerNull* " << constName
- << " = ConstanPointerNull::get(" << typeName << ");";
+ << " = ConstantPointerNull::get(" << typeName << ");";
} else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV)) {
Out << "ConstantFP* " << constName << " = ";
printCFP(CFP);
}
switch (I->getOpcode()) {
+ default:
+ error("Invalid instruction");
+ break;
+
case Instruction::Ret: {
const ReturnInst* ret = cast<ReturnInst>(I);
Out << "ReturnInst::Create("
nl(Out) << iName << "->setCallingConv(";
printCallingConv(inv->getCallingConv());
Out << ");";
- printParamAttrs(inv->getParamAttrs(), iName);
- Out << iName << "->setParamAttrs(" << iName << "_PAL);";
+ printAttributes(inv->getAttributes(), iName);
+ Out << iName << "->setAttributes(" << iName << "_PAL);";
nl(Out);
break;
}
case Instruction::Shl:
case Instruction::LShr:
case Instruction::AShr:{
- Out << "BinaryOperator* " << iName << " = BinaryOperator::create(";
+ Out << "BinaryOperator* " << iName << " = BinaryOperator::Create(";
switch (I->getOpcode()) {
case Instruction::Add: Out << "Instruction::Add"; break;
case Instruction::Sub: Out << "Instruction::Sub"; break;
nl(Out) << iName << "->setTailCall("
<< (call->isTailCall() ? "true":"false");
Out << ");";
- printParamAttrs(call->getParamAttrs(), iName);
- Out << iName << "->setParamAttrs(" << iName << "_PAL);";
+ printAttributes(call->getAttributes(), iName);
+ Out << iName << "->setAttributes(" << iName << "_PAL);";
nl(Out);
break;
}
Out << "\", " << bbname << ");";
break;
}
+ case Instruction::ExtractValue: {
+ const ExtractValueInst *evi = cast<ExtractValueInst>(I);
+ Out << "std::vector<unsigned> " << iName << "_indices;";
+ nl(Out);
+ for (unsigned i = 0; i < evi->getNumIndices(); ++i) {
+ Out << iName << "_indices.push_back("
+ << evi->idx_begin()[i] << ");";
+ nl(Out);
+ }
+ Out << "ExtractValueInst* " << getCppName(evi)
+ << " = ExtractValueInst::Create(" << opNames[0]
+ << ", "
+ << iName << "_indices.begin(), " << iName << "_indices.end(), \"";
+ printEscapedString(evi->getName());
+ Out << "\", " << bbname << ");";
+ break;
+ }
+ case Instruction::InsertValue: {
+ const InsertValueInst *ivi = cast<InsertValueInst>(I);
+ Out << "std::vector<unsigned> " << iName << "_indices;";
+ nl(Out);
+ for (unsigned i = 0; i < ivi->getNumIndices(); ++i) {
+ Out << iName << "_indices.push_back("
+ << ivi->idx_begin()[i] << ");";
+ nl(Out);
+ }
+ Out << "InsertValueInst* " << getCppName(ivi)
+ << " = InsertValueInst::Create(" << opNames[0]
+ << ", " << opNames[1] << ", "
+ << iName << "_indices.begin(), " << iName << "_indices.end(), \"";
+ printEscapedString(ivi->getName());
+ Out << "\", " << bbname << ");";
+ break;
+ }
}
DefinedValues.insert(I);
nl(Out);
Out << ");";
nl(Out);
}
- if (F->hasCollector()) {
+ if (F->hasGC()) {
printCppName(F);
- Out << "->setCollector(\"" << F->getCollector() << "\");";
+ Out << "->setGC(\"" << F->getGC() << "\");";
nl(Out);
}
if (is_inline) {
Out << "}";
nl(Out);
}
- printParamAttrs(F->getParamAttrs(), getCppName(F));
+ printAttributes(F->getAttributes(), getCppName(F));
printCppName(F);
- Out << "->setParamAttrs(" << getCppName(F) << "_PAL);";
+ Out << "->setAttributes(" << getCppName(F) << "_PAL);";
nl(Out);
}
//===----------------------------------------------------------------------===//
bool CPPTargetMachine::addPassesToEmitWholeFile(PassManager &PM,
- std::ostream &o,
+ raw_ostream &o,
CodeGenFileType FileType,
bool Fast) {
if (FileType != TargetMachine::AssemblyFile) return true;