//
// The LLVM Compiler Infrastructure
//
-// This file was developed by Reid Spencer and is distributed under the
-// University of Illinois Open Source License. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
#include "llvm/InlineAsm.h"
#include "llvm/Instruction.h"
#include "llvm/Instructions.h"
-#include "llvm/ParameterAttributes.h"
#include "llvm/Module.h"
#include "llvm/TypeSymbolTable.h"
#include "llvm/ADT/StringExtras.h"
GenModule,
GenContents,
GenFunction,
+ GenFunctions,
GenInline,
GenVariable,
GenType
cl::desc("Choose what kind of output to generate"),
cl::init(GenProgram),
cl::values(
- clEnumValN(GenProgram, "gen-program", "Generate a complete program"),
- clEnumValN(GenModule, "gen-module", "Generate a module definition"),
- clEnumValN(GenContents,"gen-contents", "Generate contents of a module"),
- clEnumValN(GenFunction,"gen-function", "Generate a function definition"),
- clEnumValN(GenInline, "gen-inline", "Generate an inline function"),
- clEnumValN(GenVariable,"gen-variable", "Generate a variable definition"),
- clEnumValN(GenType, "gen-type", "Generate a type definition"),
+ clEnumValN(GenProgram, "gen-program", "Generate a complete program"),
+ clEnumValN(GenModule, "gen-module", "Generate a module definition"),
+ clEnumValN(GenContents, "gen-contents", "Generate contents of a module"),
+ clEnumValN(GenFunction, "gen-function", "Generate a function definition"),
+ clEnumValN(GenFunctions,"gen-functions", "Generate all function definitions"),
+ clEnumValN(GenInline, "gen-inline", "Generate an inline function"),
+ clEnumValN(GenVariable, "gen-variable", "Generate a variable definition"),
+ clEnumValN(GenType, "gen-type", "Generate a type definition"),
clEnumValEnd
)
);
void printModule(const std::string& fname, const std::string& modName );
void printContents(const std::string& fname, const std::string& modName );
void printFunction(const std::string& fname, const std::string& funcName );
+ void printFunctions();
void printInline(const std::string& fname, const std::string& funcName );
void printVariable(const std::string& fname, const std::string& varName );
void printType(const std::string& fname, const std::string& typeName );
private:
void printLinkageType(GlobalValue::LinkageTypes LT);
+ void printVisibilityType(GlobalValue::VisibilityTypes VisTypes);
void printCallingConv(unsigned cc);
void printEscapedString(const std::string& str);
void printCFP(const ConstantFP* CFP);
std::string getCppName(const Value* val);
inline void printCppName(const Value* val);
+ void printParamAttrs(const PAListPtr &PAL, const std::string &name);
bool printTypeInternal(const Type* Ty);
inline void printType(const Type* Ty);
void printTypes(const Module* M);
// result so that we don't lose precision.
void
CppWriter::printCFP(const ConstantFP *CFP) {
+ APFloat APF = APFloat(CFP->getValueAPF()); // copy
+ 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];
- sprintf(Buffer, "%A", CFP->getValue());
+ sprintf(Buffer, "%A", APF.convertToDouble());
if ((!strncmp(Buffer, "0x", 2) ||
!strncmp(Buffer, "-0x", 3) ||
!strncmp(Buffer, "+0x", 3)) &&
- (atof(Buffer) == CFP->getValue()))
+ APF.bitwiseIsEqual(APFloat(atof(Buffer)))) {
if (CFP->getType() == Type::DoubleTy)
Out << "BitsToDouble(" << Buffer << ")";
else
- Out << "BitsToFloat(" << Buffer << ")";
- else {
+ Out << "BitsToFloat((float)" << Buffer << ")";
+ Out << ")";
+ } else {
#endif
- std::string StrVal = ftostr(CFP->getValue());
+ std::string StrVal = ftostr(CFP->getValueAPF());
while (StrVal[0] == ' ')
StrVal.erase(StrVal.begin());
if (((StrVal[0] >= '0' && StrVal[0] <= '9') ||
((StrVal[0] == '-' || StrVal[0] == '+') &&
(StrVal[1] >= '0' && StrVal[1] <= '9'))) &&
- (atof(StrVal.c_str()) == CFP->getValue()))
+ (CFP->isExactlyValue(atof(StrVal.c_str())))) {
if (CFP->getType() == Type::DoubleTy)
Out << StrVal;
else
- Out << StrVal;
+ Out << StrVal << "f";
+ }
else if (CFP->getType() == Type::DoubleTy)
- Out << "BitsToDouble(0x" << std::hex << DoubleToBits(CFP->getValue())
+ Out << "BitsToDouble(0x" << std::hex
+ << CFP->getValueAPF().convertToAPInt().getZExtValue()
<< std::dec << "ULL) /* " << StrVal << " */";
else
- Out << "BitsToFloat(0x" << std::hex << FloatToBits(CFP->getValue())
+ Out << "BitsToFloat(0x" << std::hex
+ << (uint32_t)CFP->getValueAPF().convertToAPInt().getZExtValue()
<< std::dec << "U) /* " << StrVal << " */";
+ Out << ")";
#if HAVE_PRINTF_A
}
#endif
case GlobalValue::ExternalLinkage:
Out << "GlobalValue::ExternalLinkage"; break;
case GlobalValue::DLLImportLinkage:
- Out << "GlobalValue::DllImportLinkage"; break;
+ Out << "GlobalValue::DLLImportLinkage"; break;
case GlobalValue::DLLExportLinkage:
- Out << "GlobalValue::DllExportLinkage"; break;
+ Out << "GlobalValue::DLLExportLinkage"; break;
case GlobalValue::ExternalWeakLinkage:
Out << "GlobalValue::ExternalWeakLinkage"; break;
case GlobalValue::GhostLinkage:
}
}
+void
+CppWriter::printVisibilityType(GlobalValue::VisibilityTypes VisType) {
+ switch (VisType) {
+ default: assert(0 && "Unknown GVar visibility");
+ case GlobalValue::DefaultVisibility:
+ Out << "GlobalValue::DefaultVisibility";
+ break;
+ case GlobalValue::HiddenVisibility:
+ Out << "GlobalValue::HiddenVisibility";
+ break;
+ case GlobalValue::ProtectedVisibility:
+ Out << "GlobalValue::ProtectedVisibility";
+ break;
+ }
+}
+
// printEscapedString - Print each character of the specified string, escaping
// it if it is not printable or if it is an escape char.
void
printEscapedString(getCppName(val));
}
+void
+CppWriter::printParamAttrs(const PAListPtr &PAL, const std::string &name) {
+ Out << "PAListPtr " << name << "_PAL = 0;";
+ nl(Out);
+ if (!PAL.isEmpty()) {
+ Out << '{'; in(); nl(Out);
+ Out << "SmallVector<ParamAttrsWithIndex, 4> Attrs;"; nl(Out);
+ Out << "ParamAttrsWithIndex PAWI;"; nl(Out);
+ for (unsigned i = 0; i < PAL.getNumSlots(); ++i) {
+ uint16_t index = PAL.getSlot(i).Index;
+ ParameterAttributes 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";
+ Out << ";";
+ nl(Out);
+ Out << "Attrs.push_back(PAWI);";
+ nl(Out);
+ }
+ Out << name << "_PAL = PAListPtr::get(Attrs.begin(), Attrs.end());";
+ nl(Out);
+ out(); nl(Out);
+ Out << '}'; nl(Out);
+ }
+}
+
bool
CppWriter::printTypeInternal(const Type* Ty) {
// We don't print definitions for primitive types
Out << ");";
nl(Out);
}
- const ParamAttrsList *PAL = FT->getParamAttrs();
- Out << "ParamAttrsList *" << typeName << "_PAL = 0;";
- nl(Out);
- if (PAL) {
- Out << '{'; in(); nl(Out);
- Out << "ParamAttrsVector Attrs;"; nl(Out);
- Out << "ParamAttrsWithIndex PAWI;"; nl(Out);
- for (unsigned i = 0; i < PAL->size(); ++i) {
- uint16_t index = PAL->getParamIndex(i);
- uint16_t attrs = PAL->getParamAttrs(index);
- Out << "PAWI.index = " << index << "; PAWI.attrs = 0 ";
- if (attrs & ParamAttr::SExt)
- Out << " | ParamAttr::SExt";
- if (attrs & ParamAttr::ZExt)
- Out << " | ParamAttr::ZExt";
- if (attrs & ParamAttr::NoAlias)
- Out << " | ParamAttr::NoAlias";
- 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";
- Out << ";";
- nl(Out);
- Out << "Attrs.push_back(PAWI);";
- nl(Out);
- }
- Out << typeName << "_PAL = ParamAttrsList::get(Attrs);";
- nl(Out);
- out(); nl(Out);
- Out << '}'; nl(Out);
- }
bool isForward = printTypeInternal(FT->getReturnType());
std::string retTypeName(getCppName(FT->getReturnType()));
Out << "FunctionType* " << typeName << " = FunctionType::get(";
Out << "_fwd";
Out << ",";
nl(Out) << "/*Params=*/" << typeName << "_args,";
- nl(Out) << "/*isVarArg=*/" << (FT->isVarArg() ? "true," : "false,") ;
- nl(Out) << "/*ParamAttrs=*/" << typeName << "_PAL" << ");";
+ nl(Out) << "/*isVarArg=*/" << (FT->isVarArg() ? "true" : "false") << ");";
out();
nl(Out);
break;
bool isForward = printTypeInternal(ET);
std::string elemName(getCppName(ET));
Out << "PointerType* " << typeName << " = PointerType::get("
- << elemName << (isForward ? "_fwd" : "") << ");";
+ << elemName << (isForward ? "_fwd" : "")
+ << ", " << utostr(PT->getAddressSpace()) << ");";
nl(Out);
break;
}
} else if (const ConstantArray *CA = dyn_cast<ConstantArray>(CV)) {
if (CA->isString() && CA->getType()->getElementType() == Type::Int8Ty) {
Out << "Constant* " << constName << " = ConstantArray::get(\"";
- printEscapedString(CA->getAsString());
+ std::string tmp = CA->getAsString();
+ bool nullTerminate = false;
+ if (tmp[tmp.length()-1] == 0) {
+ tmp.erase(tmp.length()-1);
+ nullTerminate = true;
+ }
+ printEscapedString(tmp);
// Determine if we want null termination or not.
- if (CA->getType()->getNumElements() <= CA->getAsString().length())
- Out << "\", false";// No null terminator
- else
+ if (nullTerminate)
Out << "\", true"; // Indicate that the null terminator should be added.
+ else
+ Out << "\", false";// No null terminator
Out << ");";
} else {
Out << "std::vector<Constant*> " << constName << "_elems;";
Out << "Constant* " << constName
<< " = ConstantExpr::getGetElementPtr("
<< getCppName(CE->getOperand(0)) << ", "
- << "&" << constName << "_indices[0], " << CE->getNumOperands() - 1
+ << "&" << constName << "_indices[0], "
+ << constName << "_indices.size()"
<< " );";
} else if (CE->isCast()) {
printConstant(CE->getOperand(0));
Out << "->setAlignment(" << utostr(GV->getAlignment()) << ");";
nl(Out);
};
+ if (GV->getVisibility() != GlobalValue::DefaultVisibility) {
+ printCppName(GV);
+ Out << "->setVisibility(";
+ printVisibilityType(GV->getVisibility());
+ Out << ");";
+ nl(Out);
+ }
if (is_inline) {
out(); Out << "}"; nl(Out);
}
switch (I->getOpcode()) {
case Instruction::Ret: {
const ReturnInst* ret = cast<ReturnInst>(I);
- Out << "new ReturnInst("
+ Out << "ReturnInst::Create("
<< (ret->getReturnValue() ? opNames[0] + ", " : "") << bbname << ");";
break;
}
case Instruction::Br: {
const BranchInst* br = cast<BranchInst>(I);
- Out << "new BranchInst(" ;
+ Out << "BranchInst::Create(" ;
if (br->getNumOperands() == 3 ) {
Out << opNames[0] << ", "
<< opNames[1] << ", "
}
case Instruction::Switch: {
const SwitchInst* sw = cast<SwitchInst>(I);
- Out << "SwitchInst* " << iName << " = new SwitchInst("
+ Out << "SwitchInst* " << iName << " = SwitchInst::Create("
<< opNames[0] << ", "
<< opNames[1] << ", "
<< sw->getNumCases() << ", " << bbname << ");";
<< opNames[i] << ");";
nl(Out);
}
- Out << "InvokeInst *" << iName << " = new InvokeInst("
+ Out << "InvokeInst *" << iName << " = InvokeInst::Create("
<< opNames[0] << ", "
<< opNames[1] << ", "
<< opNames[2] << ", "
- << "&" << iName << "_params[0], " << inv->getNumOperands() - 3
- << ", \"";
+ << iName << "_params.begin(), " << iName << "_params.end(), \"";
printEscapedString(inv->getName());
Out << "\", " << bbname << ");";
nl(Out) << iName << "->setCallingConv(";
printCallingConv(inv->getCallingConv());
Out << ");";
+ printParamAttrs(inv->getParamAttrs(), iName);
+ Out << iName << "->setParamAttrs(" << iName << "_PAL);";
+ nl(Out);
break;
}
case Instruction::Unwind: {
case Instruction::GetElementPtr: {
const GetElementPtrInst* gep = cast<GetElementPtrInst>(I);
if (gep->getNumOperands() <= 2) {
- Out << "GetElementPtrInst* " << iName << " = new GetElementPtrInst("
+ Out << "GetElementPtrInst* " << iName << " = GetElementPtrInst::Create("
<< opNames[0];
if (gep->getNumOperands() == 2)
Out << ", " << opNames[1];
<< opNames[i] << ");";
nl(Out);
}
- Out << "Instruction* " << iName << " = new GetElementPtrInst("
- << opNames[0] << ", &" << iName << "_indices[0], "
- << gep->getNumOperands() - 1;
+ Out << "Instruction* " << iName << " = GetElementPtrInst::Create("
+ << opNames[0] << ", " << iName << "_indices.begin(), "
+ << iName << "_indices.end()";
}
Out << ", \"";
printEscapedString(gep->getName());
case Instruction::PHI: {
const PHINode* phi = cast<PHINode>(I);
- Out << "PHINode* " << iName << " = new PHINode("
+ Out << "PHINode* " << iName << " = PHINode::Create("
<< getCppName(phi->getType()) << ", \"";
printEscapedString(phi->getName());
Out << "\", " << bbname << ");";
<< (ila->hasSideEffects() ? "true" : "false") << ");";
nl(Out);
}
- if (call->getNumOperands() > 3) {
+ if (call->getNumOperands() > 2) {
Out << "std::vector<Value*> " << iName << "_params;";
nl(Out);
for (unsigned i = 1; i < call->getNumOperands(); ++i) {
Out << iName << "_params.push_back(" << opNames[i] << ");";
nl(Out);
}
- Out << "CallInst* " << iName << " = new CallInst("
- << opNames[0] << ", &" << iName << "_params[0], "
- << call->getNumOperands() - 1 << ", \"";
- } else if (call->getNumOperands() == 3) {
- Out << "CallInst* " << iName << " = new CallInst("
- << opNames[0] << ", " << opNames[1] << ", " << opNames[2] << ", \"";
+ Out << "CallInst* " << iName << " = CallInst::Create("
+ << opNames[0] << ", " << iName << "_params.begin(), "
+ << iName << "_params.end(), \"";
} else if (call->getNumOperands() == 2) {
- Out << "CallInst* " << iName << " = new CallInst("
+ Out << "CallInst* " << iName << " = CallInst::Create("
<< opNames[0] << ", " << opNames[1] << ", \"";
} else {
- Out << "CallInst* " << iName << " = new CallInst(" << opNames[0]
+ Out << "CallInst* " << iName << " = CallInst::Create(" << opNames[0]
<< ", \"";
}
printEscapedString(call->getName());
nl(Out) << iName << "->setTailCall("
<< (call->isTailCall() ? "true":"false");
Out << ");";
+ printParamAttrs(call->getParamAttrs(), iName);
+ Out << iName << "->setParamAttrs(" << iName << "_PAL);";
+ nl(Out);
break;
}
case Instruction::Select: {
const SelectInst* sel = cast<SelectInst>(I);
- Out << "SelectInst* " << getCppName(sel) << " = new SelectInst(";
+ Out << "SelectInst* " << getCppName(sel) << " = SelectInst::Create(";
Out << opNames[0] << ", " << opNames[1] << ", " << opNames[2] << ", \"";
printEscapedString(sel->getName());
Out << "\", " << bbname << ");";
case Instruction::InsertElement: {
const InsertElementInst* iei = cast<InsertElementInst>(I);
Out << "InsertElementInst* " << getCppName(iei)
- << " = new InsertElementInst(" << opNames[0]
+ << " = InsertElementInst::Create(" << opNames[0]
<< ", " << opNames[1] << ", " << opNames[2] << ", \"";
printEscapedString(iei->getName());
Out << "\", " << bbname << ");";
nl(Out) << "if (!" << getCppName(F) << ") {";
nl(Out) << getCppName(F);
}
- Out<< " = new Function(";
+ Out<< " = Function::Create(";
nl(Out,1) << "/*Type=*/" << getCppName(F->getFunctionType()) << ",";
nl(Out) << "/*Linkage=*/";
printLinkageType(F->getLinkage());
Out << "->setAlignment(" << F->getAlignment() << ");";
nl(Out);
}
+ if (F->getVisibility() != GlobalValue::DefaultVisibility) {
+ printCppName(F);
+ Out << "->setVisibility(";
+ printVisibilityType(F->getVisibility());
+ Out << ");";
+ nl(Out);
+ }
+ if (F->hasCollector()) {
+ printCppName(F);
+ Out << "->setCollector(\"" << F->getCollector() << "\");";
+ nl(Out);
+ }
if (is_inline) {
Out << "}";
nl(Out);
}
+ printParamAttrs(F->getParamAttrs(), getCppName(F));
+ printCppName(F);
+ Out << "->setParamAttrs(" << getCppName(F) << "_PAL);";
+ nl(Out);
}
void CppWriter::printFunctionBody(const Function *F) {
for (Function::const_iterator BI = F->begin(), BE = F->end();
BI != BE; ++BI) {
std::string bbname(getCppName(BI));
- Out << "BasicBlock* " << bbname << " = new BasicBlock(\"";
+ Out << "BasicBlock* " << bbname << " = BasicBlock::Create(\"";
if (BI->hasName())
printEscapedString(BI->getName());
Out << "\"," << getCppName(BI->getParent()) << ",0);";
Out << "#include <llvm/BasicBlock.h>\n";
Out << "#include <llvm/Instructions.h>\n";
Out << "#include <llvm/InlineAsm.h>\n";
- Out << "#include <llvm/ParameterAttributes.h>\n";
Out << "#include <llvm/Support/MathExtras.h>\n";
Out << "#include <llvm/Pass.h>\n";
Out << "#include <llvm/PassManager.h>\n";
Out << "}\n";
}
+void CppWriter::printFunctions() {
+ const Module::FunctionListType &funcs = TheModule->getFunctionList();
+ Module::const_iterator I = funcs.begin();
+ Module::const_iterator IE = funcs.end();
+
+ for (; I != IE; ++I) {
+ const Function &func = *I;
+ if (!func.isDeclaration()) {
+ std::string name("define_");
+ name += func.getName();
+ printFunction(name, func.getName());
+ }
+ }
+}
+
void CppWriter::printVariable(
const std::string& fname, /// Name of generated function
const std::string& varName // Name of variable to generate
std::string tgtname = NameToGenerate.getValue();
if (GenerationType == GenModule ||
GenerationType == GenContents ||
- GenerationType == GenProgram) {
+ GenerationType == GenProgram ||
+ GenerationType == GenFunctions) {
if (tgtname == "!bad!") {
if (mod->getModuleIdentifier() == "-")
tgtname = "<stdin>";
fname = "makeLLVMFunction";
W.printFunction(fname,tgtname);
break;
+ case GenFunctions:
+ W.printFunctions();
+ break;
case GenInline:
if (fname.empty())
fname = "makeLLVMInline";