1 //===-- CPPBackend.cpp - Library for converting LLVM code to C++ code -----===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the writing of the LLVM IR as a set of C++ calls to the
11 // LLVM IR interface. The input module is assumed to be verified.
13 //===----------------------------------------------------------------------===//
15 #include "CPPTargetMachine.h"
16 #include "llvm/ADT/SmallPtrSet.h"
17 #include "llvm/ADT/StringExtras.h"
18 #include "llvm/Config/config.h"
19 #include "llvm/IR/CallingConv.h"
20 #include "llvm/IR/Constants.h"
21 #include "llvm/IR/DerivedTypes.h"
22 #include "llvm/IR/InlineAsm.h"
23 #include "llvm/IR/Instruction.h"
24 #include "llvm/IR/Instructions.h"
25 #include "llvm/IR/Module.h"
26 #include "llvm/MC/MCAsmInfo.h"
27 #include "llvm/MC/MCInstrInfo.h"
28 #include "llvm/MC/MCSubtargetInfo.h"
29 #include "llvm/Pass.h"
30 #include "llvm/PassManager.h"
31 #include "llvm/Support/CommandLine.h"
32 #include "llvm/Support/ErrorHandling.h"
33 #include "llvm/Support/FormattedStream.h"
34 #include "llvm/Support/TargetRegistry.h"
42 static cl::opt
<std::string
>
43 FuncName("cppfname", cl::desc("Specify the name of the generated function"),
44 cl::value_desc("function name"));
57 static cl::opt
<WhatToGenerate
> GenerationType("cppgen", cl::Optional
,
58 cl::desc("Choose what kind of output to generate"),
61 clEnumValN(GenProgram
, "program", "Generate a complete program"),
62 clEnumValN(GenModule
, "module", "Generate a module definition"),
63 clEnumValN(GenContents
, "contents", "Generate contents of a module"),
64 clEnumValN(GenFunction
, "function", "Generate a function definition"),
65 clEnumValN(GenFunctions
,"functions", "Generate all function definitions"),
66 clEnumValN(GenInline
, "inline", "Generate an inline function"),
67 clEnumValN(GenVariable
, "variable", "Generate a variable definition"),
68 clEnumValN(GenType
, "type", "Generate a type definition"),
73 static cl::opt
<std::string
> NameToGenerate("cppfor", cl::Optional
,
74 cl::desc("Specify the name of the thing to generate"),
77 extern "C" void LLVMInitializeCppBackendTarget() {
78 // Register the target.
79 RegisterTargetMachine
<CPPTargetMachine
> X(TheCppBackendTarget
);
83 typedef std::vector
<Type
*> TypeList
;
84 typedef std::map
<Type
*,std::string
> TypeMap
;
85 typedef std::map
<const Value
*,std::string
> ValueMap
;
86 typedef std::set
<std::string
> NameSet
;
87 typedef std::set
<Type
*> TypeSet
;
88 typedef std::set
<const Value
*> ValueSet
;
89 typedef std::map
<const Value
*,std::string
> ForwardRefMap
;
91 /// CppWriter - This class is the main chunk of code that converts an LLVM
92 /// module to a C++ translation unit.
93 class CppWriter
: public ModulePass
{
94 formatted_raw_ostream
&Out
;
95 const Module
*TheModule
;
100 TypeSet DefinedTypes
;
101 ValueSet DefinedValues
;
102 ForwardRefMap ForwardRefs
;
104 unsigned indent_level
;
108 explicit CppWriter(formatted_raw_ostream
&o
) :
109 ModulePass(ID
), Out(o
), uniqueNum(0), is_inline(false), indent_level(0){}
111 const char *getPassName() const override
{ return "C++ backend"; }
113 bool runOnModule(Module
&M
) override
;
115 void printProgram(const std::string
& fname
, const std::string
& modName
);
116 void printModule(const std::string
& fname
, const std::string
& modName
);
117 void printContents(const std::string
& fname
, const std::string
& modName
);
118 void printFunction(const std::string
& fname
, const std::string
& funcName
);
119 void printFunctions();
120 void printInline(const std::string
& fname
, const std::string
& funcName
);
121 void printVariable(const std::string
& fname
, const std::string
& varName
);
122 void printType(const std::string
& fname
, const std::string
& typeName
);
124 void error(const std::string
& msg
);
127 formatted_raw_ostream
& nl(formatted_raw_ostream
&Out
, int delta
= 0);
128 inline void in() { indent_level
++; }
129 inline void out() { if (indent_level
>0) indent_level
--; }
132 void printLinkageType(GlobalValue::LinkageTypes LT
);
133 void printVisibilityType(GlobalValue::VisibilityTypes VisTypes
);
134 void printDLLStorageClassType(GlobalValue::DLLStorageClassTypes DSCType
);
135 void printThreadLocalMode(GlobalVariable::ThreadLocalMode TLM
);
136 void printCallingConv(CallingConv::ID cc
);
137 void printEscapedString(const std::string
& str
);
138 void printCFP(const ConstantFP
* CFP
);
140 std::string
getCppName(Type
* val
);
141 inline void printCppName(Type
* val
);
143 std::string
getCppName(const Value
* val
);
144 inline void printCppName(const Value
* val
);
146 void printAttributes(const AttributeSet
&PAL
, const std::string
&name
);
147 void printType(Type
* Ty
);
148 void printTypes(const Module
* M
);
150 void printConstant(const Constant
*CPV
);
151 void printConstants(const Module
* M
);
153 void printVariableUses(const GlobalVariable
*GV
);
154 void printVariableHead(const GlobalVariable
*GV
);
155 void printVariableBody(const GlobalVariable
*GV
);
157 void printFunctionUses(const Function
*F
);
158 void printFunctionHead(const Function
*F
);
159 void printFunctionBody(const Function
*F
);
160 void printInstruction(const Instruction
*I
, const std::string
& bbname
);
161 std::string
getOpName(const Value
*);
163 void printModuleBody();
165 } // end anonymous namespace.
167 formatted_raw_ostream
&CppWriter::nl(formatted_raw_ostream
&Out
, int delta
) {
169 if (delta
>= 0 || indent_level
>= unsigned(-delta
))
170 indent_level
+= delta
;
171 Out
.indent(indent_level
);
175 static inline void sanitize(std::string
&str
) {
176 for (size_t i
= 0; i
< str
.length(); ++i
)
177 if (!isalnum(str
[i
]) && str
[i
] != '_')
181 static std::string
getTypePrefix(Type
*Ty
) {
182 switch (Ty
->getTypeID()) {
183 case Type::VoidTyID
: return "void_";
184 case Type::IntegerTyID
:
185 return "int" + utostr(cast
<IntegerType
>(Ty
)->getBitWidth()) + "_";
186 case Type::FloatTyID
: return "float_";
187 case Type::DoubleTyID
: return "double_";
188 case Type::LabelTyID
: return "label_";
189 case Type::FunctionTyID
: return "func_";
190 case Type::StructTyID
: return "struct_";
191 case Type::ArrayTyID
: return "array_";
192 case Type::PointerTyID
: return "ptr_";
193 case Type::VectorTyID
: return "packed_";
194 default: return "other_";
198 void CppWriter::error(const std::string
& msg
) {
199 report_fatal_error(msg
);
202 static inline std::string
ftostr(const APFloat
& V
) {
204 if (&V
.getSemantics() == &APFloat::IEEEdouble
) {
205 raw_string_ostream(Buf
) << V
.convertToDouble();
207 } else if (&V
.getSemantics() == &APFloat::IEEEsingle
) {
208 raw_string_ostream(Buf
) << (double)V
.convertToFloat();
211 return "<unknown format in ftostr>"; // error
214 // printCFP - Print a floating point constant .. very carefully :)
215 // This makes sure that conversion to/from floating yields the same binary
216 // result so that we don't lose precision.
217 void CppWriter::printCFP(const ConstantFP
*CFP
) {
219 APFloat APF
= APFloat(CFP
->getValueAPF()); // copy
220 if (CFP
->getType() == Type::getFloatTy(CFP
->getContext()))
221 APF
.convert(APFloat::IEEEdouble
, APFloat::rmNearestTiesToEven
, &ignored
);
222 Out
<< "ConstantFP::get(mod->getContext(), ";
226 sprintf(Buffer
, "%A", APF
.convertToDouble());
227 if ((!strncmp(Buffer
, "0x", 2) ||
228 !strncmp(Buffer
, "-0x", 3) ||
229 !strncmp(Buffer
, "+0x", 3)) &&
230 APF
.bitwiseIsEqual(APFloat(atof(Buffer
)))) {
231 if (CFP
->getType() == Type::getDoubleTy(CFP
->getContext()))
232 Out
<< "BitsToDouble(" << Buffer
<< ")";
234 Out
<< "BitsToFloat((float)" << Buffer
<< ")";
238 std::string StrVal
= ftostr(CFP
->getValueAPF());
240 while (StrVal
[0] == ' ')
241 StrVal
.erase(StrVal
.begin());
243 // Check to make sure that the stringized number is not some string like
244 // "Inf" or NaN. Check that the string matches the "[-+]?[0-9]" regex.
245 if (((StrVal
[0] >= '0' && StrVal
[0] <= '9') ||
246 ((StrVal
[0] == '-' || StrVal
[0] == '+') &&
247 (StrVal
[1] >= '0' && StrVal
[1] <= '9'))) &&
248 (CFP
->isExactlyValue(atof(StrVal
.c_str())))) {
249 if (CFP
->getType() == Type::getDoubleTy(CFP
->getContext()))
252 Out
<< StrVal
<< "f";
253 } else if (CFP
->getType() == Type::getDoubleTy(CFP
->getContext()))
254 Out
<< "BitsToDouble(0x"
255 << utohexstr(CFP
->getValueAPF().bitcastToAPInt().getZExtValue())
256 << "ULL) /* " << StrVal
<< " */";
258 Out
<< "BitsToFloat(0x"
259 << utohexstr((uint32_t)CFP
->getValueAPF().
260 bitcastToAPInt().getZExtValue())
261 << "U) /* " << StrVal
<< " */";
269 void CppWriter::printCallingConv(CallingConv::ID cc
){
270 // Print the calling convention.
272 case CallingConv::C
: Out
<< "CallingConv::C"; break;
273 case CallingConv::Fast
: Out
<< "CallingConv::Fast"; break;
274 case CallingConv::Cold
: Out
<< "CallingConv::Cold"; break;
275 case CallingConv::FirstTargetCC
: Out
<< "CallingConv::FirstTargetCC"; break;
276 default: Out
<< cc
; break;
280 void CppWriter::printLinkageType(GlobalValue::LinkageTypes LT
) {
282 case GlobalValue::InternalLinkage
:
283 Out
<< "GlobalValue::InternalLinkage"; break;
284 case GlobalValue::PrivateLinkage
:
285 Out
<< "GlobalValue::PrivateLinkage"; break;
286 case GlobalValue::AvailableExternallyLinkage
:
287 Out
<< "GlobalValue::AvailableExternallyLinkage "; break;
288 case GlobalValue::LinkOnceAnyLinkage
:
289 Out
<< "GlobalValue::LinkOnceAnyLinkage "; break;
290 case GlobalValue::LinkOnceODRLinkage
:
291 Out
<< "GlobalValue::LinkOnceODRLinkage "; break;
292 case GlobalValue::WeakAnyLinkage
:
293 Out
<< "GlobalValue::WeakAnyLinkage"; break;
294 case GlobalValue::WeakODRLinkage
:
295 Out
<< "GlobalValue::WeakODRLinkage"; break;
296 case GlobalValue::AppendingLinkage
:
297 Out
<< "GlobalValue::AppendingLinkage"; break;
298 case GlobalValue::ExternalLinkage
:
299 Out
<< "GlobalValue::ExternalLinkage"; break;
300 case GlobalValue::ExternalWeakLinkage
:
301 Out
<< "GlobalValue::ExternalWeakLinkage"; break;
302 case GlobalValue::CommonLinkage
:
303 Out
<< "GlobalValue::CommonLinkage"; break;
307 void CppWriter::printVisibilityType(GlobalValue::VisibilityTypes VisType
) {
309 case GlobalValue::DefaultVisibility
:
310 Out
<< "GlobalValue::DefaultVisibility";
312 case GlobalValue::HiddenVisibility
:
313 Out
<< "GlobalValue::HiddenVisibility";
315 case GlobalValue::ProtectedVisibility
:
316 Out
<< "GlobalValue::ProtectedVisibility";
321 void CppWriter::printDLLStorageClassType(
322 GlobalValue::DLLStorageClassTypes DSCType
) {
324 case GlobalValue::DefaultStorageClass
:
325 Out
<< "GlobalValue::DefaultStorageClass";
327 case GlobalValue::DLLImportStorageClass
:
328 Out
<< "GlobalValue::DLLImportStorageClass";
330 case GlobalValue::DLLExportStorageClass
:
331 Out
<< "GlobalValue::DLLExportStorageClass";
336 void CppWriter::printThreadLocalMode(GlobalVariable::ThreadLocalMode TLM
) {
338 case GlobalVariable::NotThreadLocal
:
339 Out
<< "GlobalVariable::NotThreadLocal";
341 case GlobalVariable::GeneralDynamicTLSModel
:
342 Out
<< "GlobalVariable::GeneralDynamicTLSModel";
344 case GlobalVariable::LocalDynamicTLSModel
:
345 Out
<< "GlobalVariable::LocalDynamicTLSModel";
347 case GlobalVariable::InitialExecTLSModel
:
348 Out
<< "GlobalVariable::InitialExecTLSModel";
350 case GlobalVariable::LocalExecTLSModel
:
351 Out
<< "GlobalVariable::LocalExecTLSModel";
356 // printEscapedString - Print each character of the specified string, escaping
357 // it if it is not printable or if it is an escape char.
358 void CppWriter::printEscapedString(const std::string
&Str
) {
359 for (unsigned i
= 0, e
= Str
.size(); i
!= e
; ++i
) {
360 unsigned char C
= Str
[i
];
361 if (isprint(C
) && C
!= '"' && C
!= '\\') {
365 << (char) ((C
/16 < 10) ? ( C
/16 +'0') : ( C
/16 -10+'A'))
366 << (char)(((C
&15) < 10) ? ((C
&15)+'0') : ((C
&15)-10+'A'));
371 std::string
CppWriter::getCppName(Type
* Ty
) {
372 switch (Ty
->getTypeID()) {
376 return "Type::getVoidTy(mod->getContext())";
377 case Type::IntegerTyID
: {
378 unsigned BitWidth
= cast
<IntegerType
>(Ty
)->getBitWidth();
379 return "IntegerType::get(mod->getContext(), " + utostr(BitWidth
) + ")";
381 case Type::X86_FP80TyID
:
382 return "Type::getX86_FP80Ty(mod->getContext())";
383 case Type::FloatTyID
:
384 return "Type::getFloatTy(mod->getContext())";
385 case Type::DoubleTyID
:
386 return "Type::getDoubleTy(mod->getContext())";
387 case Type::LabelTyID
:
388 return "Type::getLabelTy(mod->getContext())";
389 case Type::X86_MMXTyID
:
390 return "Type::getX86_MMXTy(mod->getContext())";
393 // Now, see if we've seen the type before and return that
394 TypeMap::iterator I
= TypeNames
.find(Ty
);
395 if (I
!= TypeNames
.end())
398 // Okay, let's build a new name for this type. Start with a prefix
399 const char* prefix
= nullptr;
400 switch (Ty
->getTypeID()) {
401 case Type::FunctionTyID
: prefix
= "FuncTy_"; break;
402 case Type::StructTyID
: prefix
= "StructTy_"; break;
403 case Type::ArrayTyID
: prefix
= "ArrayTy_"; break;
404 case Type::PointerTyID
: prefix
= "PointerTy_"; break;
405 case Type::VectorTyID
: prefix
= "VectorTy_"; break;
406 default: prefix
= "OtherTy_"; break; // prevent breakage
409 // See if the type has a name in the symboltable and build accordingly
411 if (StructType
*STy
= dyn_cast
<StructType
>(Ty
))
413 name
= STy
->getName();
416 name
= utostr(uniqueNum
++);
418 name
= std::string(prefix
) + name
;
422 return TypeNames
[Ty
] = name
;
425 void CppWriter::printCppName(Type
* Ty
) {
426 printEscapedString(getCppName(Ty
));
429 std::string
CppWriter::getCppName(const Value
* val
) {
431 ValueMap::iterator I
= ValueNames
.find(val
);
432 if (I
!= ValueNames
.end() && I
->first
== val
)
435 if (const GlobalVariable
* GV
= dyn_cast
<GlobalVariable
>(val
)) {
436 name
= std::string("gvar_") +
437 getTypePrefix(GV
->getType()->getElementType());
438 } else if (isa
<Function
>(val
)) {
439 name
= std::string("func_");
440 } else if (const Constant
* C
= dyn_cast
<Constant
>(val
)) {
441 name
= std::string("const_") + getTypePrefix(C
->getType());
442 } else if (const Argument
* Arg
= dyn_cast
<Argument
>(val
)) {
444 unsigned argNum
= std::distance(Arg
->getParent()->arg_begin(),
445 Function::const_arg_iterator(Arg
)) + 1;
446 name
= std::string("arg_") + utostr(argNum
);
447 NameSet::iterator NI
= UsedNames
.find(name
);
448 if (NI
!= UsedNames
.end())
449 name
+= std::string("_") + utostr(uniqueNum
++);
450 UsedNames
.insert(name
);
451 return ValueNames
[val
] = name
;
453 name
= getTypePrefix(val
->getType());
456 name
= getTypePrefix(val
->getType());
459 name
+= val
->getName();
461 name
+= utostr(uniqueNum
++);
463 NameSet::iterator NI
= UsedNames
.find(name
);
464 if (NI
!= UsedNames
.end())
465 name
+= std::string("_") + utostr(uniqueNum
++);
466 UsedNames
.insert(name
);
467 return ValueNames
[val
] = name
;
470 void CppWriter::printCppName(const Value
* val
) {
471 printEscapedString(getCppName(val
));
474 void CppWriter::printAttributes(const AttributeSet
&PAL
,
475 const std::string
&name
) {
476 Out
<< "AttributeSet " << name
<< "_PAL;";
478 if (!PAL
.isEmpty()) {
479 Out
<< '{'; in(); nl(Out
);
480 Out
<< "SmallVector<AttributeSet, 4> Attrs;"; nl(Out
);
481 Out
<< "AttributeSet PAS;"; in(); nl(Out
);
482 for (unsigned i
= 0; i
< PAL
.getNumSlots(); ++i
) {
483 unsigned index
= PAL
.getSlotIndex(i
);
484 AttrBuilder
attrs(PAL
.getSlotAttributes(i
), index
);
485 Out
<< "{"; in(); nl(Out
);
486 Out
<< "AttrBuilder B;"; nl(Out
);
488 #define HANDLE_ATTR(X) \
489 if (attrs.contains(Attribute::X)) { \
490 Out << "B.addAttribute(Attribute::" #X ");"; nl(Out); \
491 attrs.removeAttribute(Attribute::X); \
496 HANDLE_ATTR(NoReturn
);
498 HANDLE_ATTR(StructRet
);
499 HANDLE_ATTR(NoUnwind
);
500 HANDLE_ATTR(NoAlias
);
502 HANDLE_ATTR(InAlloca
);
504 HANDLE_ATTR(ReadNone
);
505 HANDLE_ATTR(ReadOnly
);
506 HANDLE_ATTR(NoInline
);
507 HANDLE_ATTR(AlwaysInline
);
508 HANDLE_ATTR(OptimizeNone
);
509 HANDLE_ATTR(OptimizeForSize
);
510 HANDLE_ATTR(StackProtect
);
511 HANDLE_ATTR(StackProtectReq
);
512 HANDLE_ATTR(StackProtectStrong
);
513 HANDLE_ATTR(NoCapture
);
514 HANDLE_ATTR(NoRedZone
);
515 HANDLE_ATTR(NoImplicitFloat
);
517 HANDLE_ATTR(InlineHint
);
518 HANDLE_ATTR(ReturnsTwice
);
519 HANDLE_ATTR(UWTable
);
520 HANDLE_ATTR(NonLazyBind
);
521 HANDLE_ATTR(MinSize
);
524 if (attrs
.contains(Attribute::StackAlignment
)) {
525 Out
<< "B.addStackAlignmentAttr(" << attrs
.getStackAlignment()<<')';
527 attrs
.removeAttribute(Attribute::StackAlignment
);
530 Out
<< "PAS = AttributeSet::get(mod->getContext(), ";
534 Out
<< index
<< "U,";
535 Out
<< " B);"; out(); nl(Out
);
536 Out
<< "}"; out(); nl(Out
);
538 Out
<< "Attrs.push_back(PAS);"; nl(Out
);
540 Out
<< name
<< "_PAL = AttributeSet::get(mod->getContext(), Attrs);";
547 void CppWriter::printType(Type
* Ty
) {
548 // We don't print definitions for primitive types
549 if (Ty
->isFloatingPointTy() || Ty
->isX86_MMXTy() || Ty
->isIntegerTy() ||
550 Ty
->isLabelTy() || Ty
->isMetadataTy() || Ty
->isVoidTy())
553 // If we already defined this type, we don't need to define it again.
554 if (DefinedTypes
.find(Ty
) != DefinedTypes
.end())
557 // Everything below needs the name for the type so get it now.
558 std::string
typeName(getCppName(Ty
));
560 // Print the type definition
561 switch (Ty
->getTypeID()) {
562 case Type::FunctionTyID
: {
563 FunctionType
* FT
= cast
<FunctionType
>(Ty
);
564 Out
<< "std::vector<Type*>" << typeName
<< "_args;";
566 FunctionType::param_iterator PI
= FT
->param_begin();
567 FunctionType::param_iterator PE
= FT
->param_end();
568 for (; PI
!= PE
; ++PI
) {
569 Type
* argTy
= static_cast<Type
*>(*PI
);
571 std::string
argName(getCppName(argTy
));
572 Out
<< typeName
<< "_args.push_back(" << argName
;
576 printType(FT
->getReturnType());
577 std::string
retTypeName(getCppName(FT
->getReturnType()));
578 Out
<< "FunctionType* " << typeName
<< " = FunctionType::get(";
579 in(); nl(Out
) << "/*Result=*/" << retTypeName
;
581 nl(Out
) << "/*Params=*/" << typeName
<< "_args,";
582 nl(Out
) << "/*isVarArg=*/" << (FT
->isVarArg() ? "true" : "false") << ");";
587 case Type::StructTyID
: {
588 StructType
* ST
= cast
<StructType
>(Ty
);
589 if (!ST
->isLiteral()) {
590 Out
<< "StructType *" << typeName
<< " = mod->getTypeByName(\"";
591 printEscapedString(ST
->getName());
594 Out
<< "if (!" << typeName
<< ") {";
596 Out
<< typeName
<< " = ";
597 Out
<< "StructType::create(mod->getContext(), \"";
598 printEscapedString(ST
->getName());
603 // Indicate that this type is now defined.
604 DefinedTypes
.insert(Ty
);
607 Out
<< "std::vector<Type*>" << typeName
<< "_fields;";
609 StructType::element_iterator EI
= ST
->element_begin();
610 StructType::element_iterator EE
= ST
->element_end();
611 for (; EI
!= EE
; ++EI
) {
612 Type
* fieldTy
= static_cast<Type
*>(*EI
);
614 std::string
fieldName(getCppName(fieldTy
));
615 Out
<< typeName
<< "_fields.push_back(" << fieldName
;
620 if (ST
->isLiteral()) {
621 Out
<< "StructType *" << typeName
<< " = ";
622 Out
<< "StructType::get(" << "mod->getContext(), ";
624 Out
<< "if (" << typeName
<< "->isOpaque()) {";
626 Out
<< typeName
<< "->setBody(";
629 Out
<< typeName
<< "_fields, /*isPacked=*/"
630 << (ST
->isPacked() ? "true" : "false") << ");";
632 if (!ST
->isLiteral()) {
638 case Type::ArrayTyID
: {
639 ArrayType
* AT
= cast
<ArrayType
>(Ty
);
640 Type
* ET
= AT
->getElementType();
642 if (DefinedTypes
.find(Ty
) == DefinedTypes
.end()) {
643 std::string
elemName(getCppName(ET
));
644 Out
<< "ArrayType* " << typeName
<< " = ArrayType::get("
646 << ", " << utostr(AT
->getNumElements()) << ");";
651 case Type::PointerTyID
: {
652 PointerType
* PT
= cast
<PointerType
>(Ty
);
653 Type
* ET
= PT
->getElementType();
655 if (DefinedTypes
.find(Ty
) == DefinedTypes
.end()) {
656 std::string
elemName(getCppName(ET
));
657 Out
<< "PointerType* " << typeName
<< " = PointerType::get("
659 << ", " << utostr(PT
->getAddressSpace()) << ");";
664 case Type::VectorTyID
: {
665 VectorType
* PT
= cast
<VectorType
>(Ty
);
666 Type
* ET
= PT
->getElementType();
668 if (DefinedTypes
.find(Ty
) == DefinedTypes
.end()) {
669 std::string
elemName(getCppName(ET
));
670 Out
<< "VectorType* " << typeName
<< " = VectorType::get("
672 << ", " << utostr(PT
->getNumElements()) << ");";
678 error("Invalid TypeID");
681 // Indicate that this type is now defined.
682 DefinedTypes
.insert(Ty
);
684 // Finally, separate the type definition from other with a newline.
688 void CppWriter::printTypes(const Module
* M
) {
689 // Add all of the global variables to the value table.
690 for (Module::const_global_iterator I
= TheModule
->global_begin(),
691 E
= TheModule
->global_end(); I
!= E
; ++I
) {
692 if (I
->hasInitializer())
693 printType(I
->getInitializer()->getType());
694 printType(I
->getType());
697 // Add all the functions to the table
698 for (Module::const_iterator FI
= TheModule
->begin(), FE
= TheModule
->end();
700 printType(FI
->getReturnType());
701 printType(FI
->getFunctionType());
702 // Add all the function arguments
703 for (Function::const_arg_iterator AI
= FI
->arg_begin(),
704 AE
= FI
->arg_end(); AI
!= AE
; ++AI
) {
705 printType(AI
->getType());
708 // Add all of the basic blocks and instructions
709 for (Function::const_iterator BB
= FI
->begin(),
710 E
= FI
->end(); BB
!= E
; ++BB
) {
711 printType(BB
->getType());
712 for (BasicBlock::const_iterator I
= BB
->begin(), E
= BB
->end(); I
!=E
;
714 printType(I
->getType());
715 for (unsigned i
= 0; i
< I
->getNumOperands(); ++i
)
716 printType(I
->getOperand(i
)->getType());
723 // printConstant - Print out a constant pool entry...
724 void CppWriter::printConstant(const Constant
*CV
) {
725 // First, if the constant is actually a GlobalValue (variable or function)
726 // or its already in the constant list then we've printed it already and we
728 if (isa
<GlobalValue
>(CV
) || ValueNames
.find(CV
) != ValueNames
.end())
731 std::string
constName(getCppName(CV
));
732 std::string
typeName(getCppName(CV
->getType()));
734 if (const ConstantInt
*CI
= dyn_cast
<ConstantInt
>(CV
)) {
735 std::string constValue
= CI
->getValue().toString(10, true);
736 Out
<< "ConstantInt* " << constName
737 << " = ConstantInt::get(mod->getContext(), APInt("
738 << cast
<IntegerType
>(CI
->getType())->getBitWidth()
739 << ", StringRef(\"" << constValue
<< "\"), 10));";
740 } else if (isa
<ConstantAggregateZero
>(CV
)) {
741 Out
<< "ConstantAggregateZero* " << constName
742 << " = ConstantAggregateZero::get(" << typeName
<< ");";
743 } else if (isa
<ConstantPointerNull
>(CV
)) {
744 Out
<< "ConstantPointerNull* " << constName
745 << " = ConstantPointerNull::get(" << typeName
<< ");";
746 } else if (const ConstantFP
*CFP
= dyn_cast
<ConstantFP
>(CV
)) {
747 Out
<< "ConstantFP* " << constName
<< " = ";
750 } else if (const ConstantArray
*CA
= dyn_cast
<ConstantArray
>(CV
)) {
751 Out
<< "std::vector<Constant*> " << constName
<< "_elems;";
753 unsigned N
= CA
->getNumOperands();
754 for (unsigned i
= 0; i
< N
; ++i
) {
755 printConstant(CA
->getOperand(i
)); // recurse to print operands
756 Out
<< constName
<< "_elems.push_back("
757 << getCppName(CA
->getOperand(i
)) << ");";
760 Out
<< "Constant* " << constName
<< " = ConstantArray::get("
761 << typeName
<< ", " << constName
<< "_elems);";
762 } else if (const ConstantStruct
*CS
= dyn_cast
<ConstantStruct
>(CV
)) {
763 Out
<< "std::vector<Constant*> " << constName
<< "_fields;";
765 unsigned N
= CS
->getNumOperands();
766 for (unsigned i
= 0; i
< N
; i
++) {
767 printConstant(CS
->getOperand(i
));
768 Out
<< constName
<< "_fields.push_back("
769 << getCppName(CS
->getOperand(i
)) << ");";
772 Out
<< "Constant* " << constName
<< " = ConstantStruct::get("
773 << typeName
<< ", " << constName
<< "_fields);";
774 } else if (const ConstantVector
*CVec
= dyn_cast
<ConstantVector
>(CV
)) {
775 Out
<< "std::vector<Constant*> " << constName
<< "_elems;";
777 unsigned N
= CVec
->getNumOperands();
778 for (unsigned i
= 0; i
< N
; ++i
) {
779 printConstant(CVec
->getOperand(i
));
780 Out
<< constName
<< "_elems.push_back("
781 << getCppName(CVec
->getOperand(i
)) << ");";
784 Out
<< "Constant* " << constName
<< " = ConstantVector::get("
785 << typeName
<< ", " << constName
<< "_elems);";
786 } else if (isa
<UndefValue
>(CV
)) {
787 Out
<< "UndefValue* " << constName
<< " = UndefValue::get("
789 } else if (const ConstantDataSequential
*CDS
=
790 dyn_cast
<ConstantDataSequential
>(CV
)) {
791 if (CDS
->isString()) {
792 Out
<< "Constant *" << constName
<<
793 " = ConstantDataArray::getString(mod->getContext(), \"";
794 StringRef Str
= CDS
->getAsString();
795 bool nullTerminate
= false;
796 if (Str
.back() == 0) {
797 Str
= Str
.drop_back();
798 nullTerminate
= true;
800 printEscapedString(Str
);
801 // Determine if we want null termination or not.
805 Out
<< "\", false);";// No null terminator
807 // TODO: Could generate more efficient code generating CDS calls instead.
808 Out
<< "std::vector<Constant*> " << constName
<< "_elems;";
810 for (unsigned i
= 0; i
!= CDS
->getNumElements(); ++i
) {
811 Constant
*Elt
= CDS
->getElementAsConstant(i
);
813 Out
<< constName
<< "_elems.push_back(" << getCppName(Elt
) << ");";
816 Out
<< "Constant* " << constName
;
818 if (isa
<ArrayType
>(CDS
->getType()))
819 Out
<< " = ConstantArray::get(";
821 Out
<< " = ConstantVector::get(";
822 Out
<< typeName
<< ", " << constName
<< "_elems);";
824 } else if (const ConstantExpr
*CE
= dyn_cast
<ConstantExpr
>(CV
)) {
825 if (CE
->getOpcode() == Instruction::GetElementPtr
) {
826 Out
<< "std::vector<Constant*> " << constName
<< "_indices;";
828 printConstant(CE
->getOperand(0));
829 for (unsigned i
= 1; i
< CE
->getNumOperands(); ++i
) {
830 printConstant(CE
->getOperand(i
));
831 Out
<< constName
<< "_indices.push_back("
832 << getCppName(CE
->getOperand(i
)) << ");";
835 Out
<< "Constant* " << constName
836 << " = ConstantExpr::getGetElementPtr("
837 << getCppName(CE
->getOperand(0)) << ", "
838 << constName
<< "_indices);";
839 } else if (CE
->isCast()) {
840 printConstant(CE
->getOperand(0));
841 Out
<< "Constant* " << constName
<< " = ConstantExpr::getCast(";
842 switch (CE
->getOpcode()) {
843 default: llvm_unreachable("Invalid cast opcode");
844 case Instruction::Trunc
: Out
<< "Instruction::Trunc"; break;
845 case Instruction::ZExt
: Out
<< "Instruction::ZExt"; break;
846 case Instruction::SExt
: Out
<< "Instruction::SExt"; break;
847 case Instruction::FPTrunc
: Out
<< "Instruction::FPTrunc"; break;
848 case Instruction::FPExt
: Out
<< "Instruction::FPExt"; break;
849 case Instruction::FPToUI
: Out
<< "Instruction::FPToUI"; break;
850 case Instruction::FPToSI
: Out
<< "Instruction::FPToSI"; break;
851 case Instruction::UIToFP
: Out
<< "Instruction::UIToFP"; break;
852 case Instruction::SIToFP
: Out
<< "Instruction::SIToFP"; break;
853 case Instruction::PtrToInt
: Out
<< "Instruction::PtrToInt"; break;
854 case Instruction::IntToPtr
: Out
<< "Instruction::IntToPtr"; break;
855 case Instruction::BitCast
: Out
<< "Instruction::BitCast"; break;
857 Out
<< ", " << getCppName(CE
->getOperand(0)) << ", "
858 << getCppName(CE
->getType()) << ");";
860 unsigned N
= CE
->getNumOperands();
861 for (unsigned i
= 0; i
< N
; ++i
) {
862 printConstant(CE
->getOperand(i
));
864 Out
<< "Constant* " << constName
<< " = ConstantExpr::";
865 switch (CE
->getOpcode()) {
866 case Instruction::Add
: Out
<< "getAdd("; break;
867 case Instruction::FAdd
: Out
<< "getFAdd("; break;
868 case Instruction::Sub
: Out
<< "getSub("; break;
869 case Instruction::FSub
: Out
<< "getFSub("; break;
870 case Instruction::Mul
: Out
<< "getMul("; break;
871 case Instruction::FMul
: Out
<< "getFMul("; break;
872 case Instruction::UDiv
: Out
<< "getUDiv("; break;
873 case Instruction::SDiv
: Out
<< "getSDiv("; break;
874 case Instruction::FDiv
: Out
<< "getFDiv("; break;
875 case Instruction::URem
: Out
<< "getURem("; break;
876 case Instruction::SRem
: Out
<< "getSRem("; break;
877 case Instruction::FRem
: Out
<< "getFRem("; break;
878 case Instruction::And
: Out
<< "getAnd("; break;
879 case Instruction::Or
: Out
<< "getOr("; break;
880 case Instruction::Xor
: Out
<< "getXor("; break;
881 case Instruction::ICmp
:
882 Out
<< "getICmp(ICmpInst::ICMP_";
883 switch (CE
->getPredicate()) {
884 case ICmpInst::ICMP_EQ
: Out
<< "EQ"; break;
885 case ICmpInst::ICMP_NE
: Out
<< "NE"; break;
886 case ICmpInst::ICMP_SLT
: Out
<< "SLT"; break;
887 case ICmpInst::ICMP_ULT
: Out
<< "ULT"; break;
888 case ICmpInst::ICMP_SGT
: Out
<< "SGT"; break;
889 case ICmpInst::ICMP_UGT
: Out
<< "UGT"; break;
890 case ICmpInst::ICMP_SLE
: Out
<< "SLE"; break;
891 case ICmpInst::ICMP_ULE
: Out
<< "ULE"; break;
892 case ICmpInst::ICMP_SGE
: Out
<< "SGE"; break;
893 case ICmpInst::ICMP_UGE
: Out
<< "UGE"; break;
894 default: error("Invalid ICmp Predicate");
897 case Instruction::FCmp
:
898 Out
<< "getFCmp(FCmpInst::FCMP_";
899 switch (CE
->getPredicate()) {
900 case FCmpInst::FCMP_FALSE
: Out
<< "FALSE"; break;
901 case FCmpInst::FCMP_ORD
: Out
<< "ORD"; break;
902 case FCmpInst::FCMP_UNO
: Out
<< "UNO"; break;
903 case FCmpInst::FCMP_OEQ
: Out
<< "OEQ"; break;
904 case FCmpInst::FCMP_UEQ
: Out
<< "UEQ"; break;
905 case FCmpInst::FCMP_ONE
: Out
<< "ONE"; break;
906 case FCmpInst::FCMP_UNE
: Out
<< "UNE"; break;
907 case FCmpInst::FCMP_OLT
: Out
<< "OLT"; break;
908 case FCmpInst::FCMP_ULT
: Out
<< "ULT"; break;
909 case FCmpInst::FCMP_OGT
: Out
<< "OGT"; break;
910 case FCmpInst::FCMP_UGT
: Out
<< "UGT"; break;
911 case FCmpInst::FCMP_OLE
: Out
<< "OLE"; break;
912 case FCmpInst::FCMP_ULE
: Out
<< "ULE"; break;
913 case FCmpInst::FCMP_OGE
: Out
<< "OGE"; break;
914 case FCmpInst::FCMP_UGE
: Out
<< "UGE"; break;
915 case FCmpInst::FCMP_TRUE
: Out
<< "TRUE"; break;
916 default: error("Invalid FCmp Predicate");
919 case Instruction::Shl
: Out
<< "getShl("; break;
920 case Instruction::LShr
: Out
<< "getLShr("; break;
921 case Instruction::AShr
: Out
<< "getAShr("; break;
922 case Instruction::Select
: Out
<< "getSelect("; break;
923 case Instruction::ExtractElement
: Out
<< "getExtractElement("; break;
924 case Instruction::InsertElement
: Out
<< "getInsertElement("; break;
925 case Instruction::ShuffleVector
: Out
<< "getShuffleVector("; break;
927 error("Invalid constant expression");
930 Out
<< getCppName(CE
->getOperand(0));
931 for (unsigned i
= 1; i
< CE
->getNumOperands(); ++i
)
932 Out
<< ", " << getCppName(CE
->getOperand(i
));
935 } else if (const BlockAddress
*BA
= dyn_cast
<BlockAddress
>(CV
)) {
936 Out
<< "Constant* " << constName
<< " = ";
937 Out
<< "BlockAddress::get(" << getOpName(BA
->getBasicBlock()) << ");";
939 error("Bad Constant");
940 Out
<< "Constant* " << constName
<< " = 0; ";
945 void CppWriter::printConstants(const Module
* M
) {
946 // Traverse all the global variables looking for constant initializers
947 for (Module::const_global_iterator I
= TheModule
->global_begin(),
948 E
= TheModule
->global_end(); I
!= E
; ++I
)
949 if (I
->hasInitializer())
950 printConstant(I
->getInitializer());
952 // Traverse the LLVM functions looking for constants
953 for (Module::const_iterator FI
= TheModule
->begin(), FE
= TheModule
->end();
955 // Add all of the basic blocks and instructions
956 for (Function::const_iterator BB
= FI
->begin(),
957 E
= FI
->end(); BB
!= E
; ++BB
) {
958 for (BasicBlock::const_iterator I
= BB
->begin(), E
= BB
->end(); I
!=E
;
960 for (unsigned i
= 0; i
< I
->getNumOperands(); ++i
) {
961 if (Constant
* C
= dyn_cast
<Constant
>(I
->getOperand(i
))) {
970 void CppWriter::printVariableUses(const GlobalVariable
*GV
) {
971 nl(Out
) << "// Type Definitions";
973 printType(GV
->getType());
974 if (GV
->hasInitializer()) {
975 const Constant
*Init
= GV
->getInitializer();
976 printType(Init
->getType());
977 if (const Function
*F
= dyn_cast
<Function
>(Init
)) {
978 nl(Out
)<< "/ Function Declarations"; nl(Out
);
979 printFunctionHead(F
);
980 } else if (const GlobalVariable
* gv
= dyn_cast
<GlobalVariable
>(Init
)) {
981 nl(Out
) << "// Global Variable Declarations"; nl(Out
);
982 printVariableHead(gv
);
984 nl(Out
) << "// Global Variable Definitions"; nl(Out
);
985 printVariableBody(gv
);
987 nl(Out
) << "// Constant Definitions"; nl(Out
);
993 void CppWriter::printVariableHead(const GlobalVariable
*GV
) {
994 nl(Out
) << "GlobalVariable* " << getCppName(GV
);
996 Out
<< " = mod->getGlobalVariable(mod->getContext(), ";
997 printEscapedString(GV
->getName());
998 Out
<< ", " << getCppName(GV
->getType()->getElementType()) << ",true)";
999 nl(Out
) << "if (!" << getCppName(GV
) << ") {";
1000 in(); nl(Out
) << getCppName(GV
);
1002 Out
<< " = new GlobalVariable(/*Module=*/*mod, ";
1003 nl(Out
) << "/*Type=*/";
1004 printCppName(GV
->getType()->getElementType());
1006 nl(Out
) << "/*isConstant=*/" << (GV
->isConstant()?"true":"false");
1008 nl(Out
) << "/*Linkage=*/";
1009 printLinkageType(GV
->getLinkage());
1011 nl(Out
) << "/*Initializer=*/0, ";
1012 if (GV
->hasInitializer()) {
1013 Out
<< "// has initializer, specified below";
1015 nl(Out
) << "/*Name=*/\"";
1016 printEscapedString(GV
->getName());
1020 if (GV
->hasSection()) {
1022 Out
<< "->setSection(\"";
1023 printEscapedString(GV
->getSection());
1027 if (GV
->getAlignment()) {
1029 Out
<< "->setAlignment(" << utostr(GV
->getAlignment()) << ");";
1032 if (GV
->getVisibility() != GlobalValue::DefaultVisibility
) {
1034 Out
<< "->setVisibility(";
1035 printVisibilityType(GV
->getVisibility());
1039 if (GV
->getDLLStorageClass() != GlobalValue::DefaultStorageClass
) {
1041 Out
<< "->setDLLStorageClass(";
1042 printDLLStorageClassType(GV
->getDLLStorageClass());
1046 if (GV
->isThreadLocal()) {
1048 Out
<< "->setThreadLocalMode(";
1049 printThreadLocalMode(GV
->getThreadLocalMode());
1054 out(); Out
<< "}"; nl(Out
);
1058 void CppWriter::printVariableBody(const GlobalVariable
*GV
) {
1059 if (GV
->hasInitializer()) {
1061 Out
<< "->setInitializer(";
1062 Out
<< getCppName(GV
->getInitializer()) << ");";
1067 std::string
CppWriter::getOpName(const Value
* V
) {
1068 if (!isa
<Instruction
>(V
) || DefinedValues
.find(V
) != DefinedValues
.end())
1069 return getCppName(V
);
1071 // See if its alread in the map of forward references, if so just return the
1072 // name we already set up for it
1073 ForwardRefMap::const_iterator I
= ForwardRefs
.find(V
);
1074 if (I
!= ForwardRefs
.end())
1077 // This is a new forward reference. Generate a unique name for it
1078 std::string
result(std::string("fwdref_") + utostr(uniqueNum
++));
1080 // Yes, this is a hack. An Argument is the smallest instantiable value that
1081 // we can make as a placeholder for the real value. We'll replace these
1082 // Argument instances later.
1083 Out
<< "Argument* " << result
<< " = new Argument("
1084 << getCppName(V
->getType()) << ");";
1086 ForwardRefs
[V
] = result
;
1090 static StringRef
ConvertAtomicOrdering(AtomicOrdering Ordering
) {
1092 case NotAtomic
: return "NotAtomic";
1093 case Unordered
: return "Unordered";
1094 case Monotonic
: return "Monotonic";
1095 case Acquire
: return "Acquire";
1096 case Release
: return "Release";
1097 case AcquireRelease
: return "AcquireRelease";
1098 case SequentiallyConsistent
: return "SequentiallyConsistent";
1100 llvm_unreachable("Unknown ordering");
1103 static StringRef
ConvertAtomicSynchScope(SynchronizationScope SynchScope
) {
1104 switch (SynchScope
) {
1105 case SingleThread
: return "SingleThread";
1106 case CrossThread
: return "CrossThread";
1108 llvm_unreachable("Unknown synch scope");
1111 // printInstruction - This member is called for each Instruction in a function.
1112 void CppWriter::printInstruction(const Instruction
*I
,
1113 const std::string
& bbname
) {
1114 std::string
iName(getCppName(I
));
1116 // Before we emit this instruction, we need to take care of generating any
1117 // forward references. So, we get the names of all the operands in advance
1118 const unsigned Ops(I
->getNumOperands());
1119 std::string
* opNames
= new std::string
[Ops
];
1120 for (unsigned i
= 0; i
< Ops
; i
++)
1121 opNames
[i
] = getOpName(I
->getOperand(i
));
1123 switch (I
->getOpcode()) {
1125 error("Invalid instruction");
1128 case Instruction::Ret
: {
1129 const ReturnInst
* ret
= cast
<ReturnInst
>(I
);
1130 Out
<< "ReturnInst::Create(mod->getContext(), "
1131 << (ret
->getReturnValue() ? opNames
[0] + ", " : "") << bbname
<< ");";
1134 case Instruction::Br
: {
1135 const BranchInst
* br
= cast
<BranchInst
>(I
);
1136 Out
<< "BranchInst::Create(" ;
1137 if (br
->getNumOperands() == 3) {
1138 Out
<< opNames
[2] << ", "
1139 << opNames
[1] << ", "
1140 << opNames
[0] << ", ";
1142 } else if (br
->getNumOperands() == 1) {
1143 Out
<< opNames
[0] << ", ";
1145 error("Branch with 2 operands?");
1147 Out
<< bbname
<< ");";
1150 case Instruction::Switch
: {
1151 const SwitchInst
*SI
= cast
<SwitchInst
>(I
);
1152 Out
<< "SwitchInst* " << iName
<< " = SwitchInst::Create("
1153 << getOpName(SI
->getCondition()) << ", "
1154 << getOpName(SI
->getDefaultDest()) << ", "
1155 << SI
->getNumCases() << ", " << bbname
<< ");";
1157 for (SwitchInst::ConstCaseIt i
= SI
->case_begin(), e
= SI
->case_end();
1159 const ConstantInt
* CaseVal
= i
.getCaseValue();
1160 const BasicBlock
*BB
= i
.getCaseSuccessor();
1161 Out
<< iName
<< "->addCase("
1162 << getOpName(CaseVal
) << ", "
1163 << getOpName(BB
) << ");";
1168 case Instruction::IndirectBr
: {
1169 const IndirectBrInst
*IBI
= cast
<IndirectBrInst
>(I
);
1170 Out
<< "IndirectBrInst *" << iName
<< " = IndirectBrInst::Create("
1171 << opNames
[0] << ", " << IBI
->getNumDestinations() << ");";
1173 for (unsigned i
= 1; i
!= IBI
->getNumOperands(); ++i
) {
1174 Out
<< iName
<< "->addDestination(" << opNames
[i
] << ");";
1179 case Instruction::Resume
: {
1180 Out
<< "ResumeInst::Create(" << opNames
[0] << ", " << bbname
<< ");";
1183 case Instruction::Invoke
: {
1184 const InvokeInst
* inv
= cast
<InvokeInst
>(I
);
1185 Out
<< "std::vector<Value*> " << iName
<< "_params;";
1187 for (unsigned i
= 0; i
< inv
->getNumArgOperands(); ++i
) {
1188 Out
<< iName
<< "_params.push_back("
1189 << getOpName(inv
->getArgOperand(i
)) << ");";
1192 // FIXME: This shouldn't use magic numbers -3, -2, and -1.
1193 Out
<< "InvokeInst *" << iName
<< " = InvokeInst::Create("
1194 << getOpName(inv
->getCalledValue()) << ", "
1195 << getOpName(inv
->getNormalDest()) << ", "
1196 << getOpName(inv
->getUnwindDest()) << ", "
1197 << iName
<< "_params, \"";
1198 printEscapedString(inv
->getName());
1199 Out
<< "\", " << bbname
<< ");";
1200 nl(Out
) << iName
<< "->setCallingConv(";
1201 printCallingConv(inv
->getCallingConv());
1203 printAttributes(inv
->getAttributes(), iName
);
1204 Out
<< iName
<< "->setAttributes(" << iName
<< "_PAL);";
1208 case Instruction::Unreachable
: {
1209 Out
<< "new UnreachableInst("
1210 << "mod->getContext(), "
1214 case Instruction::Add
:
1215 case Instruction::FAdd
:
1216 case Instruction::Sub
:
1217 case Instruction::FSub
:
1218 case Instruction::Mul
:
1219 case Instruction::FMul
:
1220 case Instruction::UDiv
:
1221 case Instruction::SDiv
:
1222 case Instruction::FDiv
:
1223 case Instruction::URem
:
1224 case Instruction::SRem
:
1225 case Instruction::FRem
:
1226 case Instruction::And
:
1227 case Instruction::Or
:
1228 case Instruction::Xor
:
1229 case Instruction::Shl
:
1230 case Instruction::LShr
:
1231 case Instruction::AShr
:{
1232 Out
<< "BinaryOperator* " << iName
<< " = BinaryOperator::Create(";
1233 switch (I
->getOpcode()) {
1234 case Instruction::Add
: Out
<< "Instruction::Add"; break;
1235 case Instruction::FAdd
: Out
<< "Instruction::FAdd"; break;
1236 case Instruction::Sub
: Out
<< "Instruction::Sub"; break;
1237 case Instruction::FSub
: Out
<< "Instruction::FSub"; break;
1238 case Instruction::Mul
: Out
<< "Instruction::Mul"; break;
1239 case Instruction::FMul
: Out
<< "Instruction::FMul"; break;
1240 case Instruction::UDiv
:Out
<< "Instruction::UDiv"; break;
1241 case Instruction::SDiv
:Out
<< "Instruction::SDiv"; break;
1242 case Instruction::FDiv
:Out
<< "Instruction::FDiv"; break;
1243 case Instruction::URem
:Out
<< "Instruction::URem"; break;
1244 case Instruction::SRem
:Out
<< "Instruction::SRem"; break;
1245 case Instruction::FRem
:Out
<< "Instruction::FRem"; break;
1246 case Instruction::And
: Out
<< "Instruction::And"; break;
1247 case Instruction::Or
: Out
<< "Instruction::Or"; break;
1248 case Instruction::Xor
: Out
<< "Instruction::Xor"; break;
1249 case Instruction::Shl
: Out
<< "Instruction::Shl"; break;
1250 case Instruction::LShr
:Out
<< "Instruction::LShr"; break;
1251 case Instruction::AShr
:Out
<< "Instruction::AShr"; break;
1252 default: Out
<< "Instruction::BadOpCode"; break;
1254 Out
<< ", " << opNames
[0] << ", " << opNames
[1] << ", \"";
1255 printEscapedString(I
->getName());
1256 Out
<< "\", " << bbname
<< ");";
1259 case Instruction::FCmp
: {
1260 Out
<< "FCmpInst* " << iName
<< " = new FCmpInst(*" << bbname
<< ", ";
1261 switch (cast
<FCmpInst
>(I
)->getPredicate()) {
1262 case FCmpInst::FCMP_FALSE
: Out
<< "FCmpInst::FCMP_FALSE"; break;
1263 case FCmpInst::FCMP_OEQ
: Out
<< "FCmpInst::FCMP_OEQ"; break;
1264 case FCmpInst::FCMP_OGT
: Out
<< "FCmpInst::FCMP_OGT"; break;
1265 case FCmpInst::FCMP_OGE
: Out
<< "FCmpInst::FCMP_OGE"; break;
1266 case FCmpInst::FCMP_OLT
: Out
<< "FCmpInst::FCMP_OLT"; break;
1267 case FCmpInst::FCMP_OLE
: Out
<< "FCmpInst::FCMP_OLE"; break;
1268 case FCmpInst::FCMP_ONE
: Out
<< "FCmpInst::FCMP_ONE"; break;
1269 case FCmpInst::FCMP_ORD
: Out
<< "FCmpInst::FCMP_ORD"; break;
1270 case FCmpInst::FCMP_UNO
: Out
<< "FCmpInst::FCMP_UNO"; break;
1271 case FCmpInst::FCMP_UEQ
: Out
<< "FCmpInst::FCMP_UEQ"; break;
1272 case FCmpInst::FCMP_UGT
: Out
<< "FCmpInst::FCMP_UGT"; break;
1273 case FCmpInst::FCMP_UGE
: Out
<< "FCmpInst::FCMP_UGE"; break;
1274 case FCmpInst::FCMP_ULT
: Out
<< "FCmpInst::FCMP_ULT"; break;
1275 case FCmpInst::FCMP_ULE
: Out
<< "FCmpInst::FCMP_ULE"; break;
1276 case FCmpInst::FCMP_UNE
: Out
<< "FCmpInst::FCMP_UNE"; break;
1277 case FCmpInst::FCMP_TRUE
: Out
<< "FCmpInst::FCMP_TRUE"; break;
1278 default: Out
<< "FCmpInst::BAD_ICMP_PREDICATE"; break;
1280 Out
<< ", " << opNames
[0] << ", " << opNames
[1] << ", \"";
1281 printEscapedString(I
->getName());
1285 case Instruction::ICmp
: {
1286 Out
<< "ICmpInst* " << iName
<< " = new ICmpInst(*" << bbname
<< ", ";
1287 switch (cast
<ICmpInst
>(I
)->getPredicate()) {
1288 case ICmpInst::ICMP_EQ
: Out
<< "ICmpInst::ICMP_EQ"; break;
1289 case ICmpInst::ICMP_NE
: Out
<< "ICmpInst::ICMP_NE"; break;
1290 case ICmpInst::ICMP_ULE
: Out
<< "ICmpInst::ICMP_ULE"; break;
1291 case ICmpInst::ICMP_SLE
: Out
<< "ICmpInst::ICMP_SLE"; break;
1292 case ICmpInst::ICMP_UGE
: Out
<< "ICmpInst::ICMP_UGE"; break;
1293 case ICmpInst::ICMP_SGE
: Out
<< "ICmpInst::ICMP_SGE"; break;
1294 case ICmpInst::ICMP_ULT
: Out
<< "ICmpInst::ICMP_ULT"; break;
1295 case ICmpInst::ICMP_SLT
: Out
<< "ICmpInst::ICMP_SLT"; break;
1296 case ICmpInst::ICMP_UGT
: Out
<< "ICmpInst::ICMP_UGT"; break;
1297 case ICmpInst::ICMP_SGT
: Out
<< "ICmpInst::ICMP_SGT"; break;
1298 default: Out
<< "ICmpInst::BAD_ICMP_PREDICATE"; break;
1300 Out
<< ", " << opNames
[0] << ", " << opNames
[1] << ", \"";
1301 printEscapedString(I
->getName());
1305 case Instruction::Alloca
: {
1306 const AllocaInst
* allocaI
= cast
<AllocaInst
>(I
);
1307 Out
<< "AllocaInst* " << iName
<< " = new AllocaInst("
1308 << getCppName(allocaI
->getAllocatedType()) << ", ";
1309 if (allocaI
->isArrayAllocation())
1310 Out
<< opNames
[0] << ", ";
1312 printEscapedString(allocaI
->getName());
1313 Out
<< "\", " << bbname
<< ");";
1314 if (allocaI
->getAlignment())
1315 nl(Out
) << iName
<< "->setAlignment("
1316 << allocaI
->getAlignment() << ");";
1319 case Instruction::Load
: {
1320 const LoadInst
* load
= cast
<LoadInst
>(I
);
1321 Out
<< "LoadInst* " << iName
<< " = new LoadInst("
1322 << opNames
[0] << ", \"";
1323 printEscapedString(load
->getName());
1324 Out
<< "\", " << (load
->isVolatile() ? "true" : "false" )
1325 << ", " << bbname
<< ");";
1326 if (load
->getAlignment())
1327 nl(Out
) << iName
<< "->setAlignment("
1328 << load
->getAlignment() << ");";
1329 if (load
->isAtomic()) {
1330 StringRef Ordering
= ConvertAtomicOrdering(load
->getOrdering());
1331 StringRef CrossThread
= ConvertAtomicSynchScope(load
->getSynchScope());
1332 nl(Out
) << iName
<< "->setAtomic("
1333 << Ordering
<< ", " << CrossThread
<< ");";
1337 case Instruction::Store
: {
1338 const StoreInst
* store
= cast
<StoreInst
>(I
);
1339 Out
<< "StoreInst* " << iName
<< " = new StoreInst("
1340 << opNames
[0] << ", "
1341 << opNames
[1] << ", "
1342 << (store
->isVolatile() ? "true" : "false")
1343 << ", " << bbname
<< ");";
1344 if (store
->getAlignment())
1345 nl(Out
) << iName
<< "->setAlignment("
1346 << store
->getAlignment() << ");";
1347 if (store
->isAtomic()) {
1348 StringRef Ordering
= ConvertAtomicOrdering(store
->getOrdering());
1349 StringRef CrossThread
= ConvertAtomicSynchScope(store
->getSynchScope());
1350 nl(Out
) << iName
<< "->setAtomic("
1351 << Ordering
<< ", " << CrossThread
<< ");";
1355 case Instruction::GetElementPtr
: {
1356 const GetElementPtrInst
* gep
= cast
<GetElementPtrInst
>(I
);
1357 if (gep
->getNumOperands() <= 2) {
1358 Out
<< "GetElementPtrInst* " << iName
<< " = GetElementPtrInst::Create("
1360 if (gep
->getNumOperands() == 2)
1361 Out
<< ", " << opNames
[1];
1363 Out
<< "std::vector<Value*> " << iName
<< "_indices;";
1365 for (unsigned i
= 1; i
< gep
->getNumOperands(); ++i
) {
1366 Out
<< iName
<< "_indices.push_back("
1367 << opNames
[i
] << ");";
1370 Out
<< "Instruction* " << iName
<< " = GetElementPtrInst::Create("
1371 << opNames
[0] << ", " << iName
<< "_indices";
1374 printEscapedString(gep
->getName());
1375 Out
<< "\", " << bbname
<< ");";
1378 case Instruction::PHI
: {
1379 const PHINode
* phi
= cast
<PHINode
>(I
);
1381 Out
<< "PHINode* " << iName
<< " = PHINode::Create("
1382 << getCppName(phi
->getType()) << ", "
1383 << phi
->getNumIncomingValues() << ", \"";
1384 printEscapedString(phi
->getName());
1385 Out
<< "\", " << bbname
<< ");";
1387 for (unsigned i
= 0; i
< phi
->getNumIncomingValues(); ++i
) {
1388 Out
<< iName
<< "->addIncoming("
1389 << opNames
[PHINode::getOperandNumForIncomingValue(i
)] << ", "
1390 << getOpName(phi
->getIncomingBlock(i
)) << ");";
1395 case Instruction::Trunc
:
1396 case Instruction::ZExt
:
1397 case Instruction::SExt
:
1398 case Instruction::FPTrunc
:
1399 case Instruction::FPExt
:
1400 case Instruction::FPToUI
:
1401 case Instruction::FPToSI
:
1402 case Instruction::UIToFP
:
1403 case Instruction::SIToFP
:
1404 case Instruction::PtrToInt
:
1405 case Instruction::IntToPtr
:
1406 case Instruction::BitCast
: {
1407 const CastInst
* cst
= cast
<CastInst
>(I
);
1408 Out
<< "CastInst* " << iName
<< " = new ";
1409 switch (I
->getOpcode()) {
1410 case Instruction::Trunc
: Out
<< "TruncInst"; break;
1411 case Instruction::ZExt
: Out
<< "ZExtInst"; break;
1412 case Instruction::SExt
: Out
<< "SExtInst"; break;
1413 case Instruction::FPTrunc
: Out
<< "FPTruncInst"; break;
1414 case Instruction::FPExt
: Out
<< "FPExtInst"; break;
1415 case Instruction::FPToUI
: Out
<< "FPToUIInst"; break;
1416 case Instruction::FPToSI
: Out
<< "FPToSIInst"; break;
1417 case Instruction::UIToFP
: Out
<< "UIToFPInst"; break;
1418 case Instruction::SIToFP
: Out
<< "SIToFPInst"; break;
1419 case Instruction::PtrToInt
: Out
<< "PtrToIntInst"; break;
1420 case Instruction::IntToPtr
: Out
<< "IntToPtrInst"; break;
1421 case Instruction::BitCast
: Out
<< "BitCastInst"; break;
1422 default: llvm_unreachable("Unreachable");
1424 Out
<< "(" << opNames
[0] << ", "
1425 << getCppName(cst
->getType()) << ", \"";
1426 printEscapedString(cst
->getName());
1427 Out
<< "\", " << bbname
<< ");";
1430 case Instruction::Call
: {
1431 const CallInst
* call
= cast
<CallInst
>(I
);
1432 if (const InlineAsm
* ila
= dyn_cast
<InlineAsm
>(call
->getCalledValue())) {
1433 Out
<< "InlineAsm* " << getCppName(ila
) << " = InlineAsm::get("
1434 << getCppName(ila
->getFunctionType()) << ", \""
1435 << ila
->getAsmString() << "\", \""
1436 << ila
->getConstraintString() << "\","
1437 << (ila
->hasSideEffects() ? "true" : "false") << ");";
1440 if (call
->getNumArgOperands() > 1) {
1441 Out
<< "std::vector<Value*> " << iName
<< "_params;";
1443 for (unsigned i
= 0; i
< call
->getNumArgOperands(); ++i
) {
1444 Out
<< iName
<< "_params.push_back(" << opNames
[i
] << ");";
1447 Out
<< "CallInst* " << iName
<< " = CallInst::Create("
1448 << opNames
[call
->getNumArgOperands()] << ", "
1449 << iName
<< "_params, \"";
1450 } else if (call
->getNumArgOperands() == 1) {
1451 Out
<< "CallInst* " << iName
<< " = CallInst::Create("
1452 << opNames
[call
->getNumArgOperands()] << ", " << opNames
[0] << ", \"";
1454 Out
<< "CallInst* " << iName
<< " = CallInst::Create("
1455 << opNames
[call
->getNumArgOperands()] << ", \"";
1457 printEscapedString(call
->getName());
1458 Out
<< "\", " << bbname
<< ");";
1459 nl(Out
) << iName
<< "->setCallingConv(";
1460 printCallingConv(call
->getCallingConv());
1462 nl(Out
) << iName
<< "->setTailCall("
1463 << (call
->isTailCall() ? "true" : "false");
1466 printAttributes(call
->getAttributes(), iName
);
1467 Out
<< iName
<< "->setAttributes(" << iName
<< "_PAL);";
1471 case Instruction::Select
: {
1472 const SelectInst
* sel
= cast
<SelectInst
>(I
);
1473 Out
<< "SelectInst* " << getCppName(sel
) << " = SelectInst::Create(";
1474 Out
<< opNames
[0] << ", " << opNames
[1] << ", " << opNames
[2] << ", \"";
1475 printEscapedString(sel
->getName());
1476 Out
<< "\", " << bbname
<< ");";
1479 case Instruction::UserOp1
:
1481 case Instruction::UserOp2
: {
1482 /// FIXME: What should be done here?
1485 case Instruction::VAArg
: {
1486 const VAArgInst
* va
= cast
<VAArgInst
>(I
);
1487 Out
<< "VAArgInst* " << getCppName(va
) << " = new VAArgInst("
1488 << opNames
[0] << ", " << getCppName(va
->getType()) << ", \"";
1489 printEscapedString(va
->getName());
1490 Out
<< "\", " << bbname
<< ");";
1493 case Instruction::ExtractElement
: {
1494 const ExtractElementInst
* eei
= cast
<ExtractElementInst
>(I
);
1495 Out
<< "ExtractElementInst* " << getCppName(eei
)
1496 << " = new ExtractElementInst(" << opNames
[0]
1497 << ", " << opNames
[1] << ", \"";
1498 printEscapedString(eei
->getName());
1499 Out
<< "\", " << bbname
<< ");";
1502 case Instruction::InsertElement
: {
1503 const InsertElementInst
* iei
= cast
<InsertElementInst
>(I
);
1504 Out
<< "InsertElementInst* " << getCppName(iei
)
1505 << " = InsertElementInst::Create(" << opNames
[0]
1506 << ", " << opNames
[1] << ", " << opNames
[2] << ", \"";
1507 printEscapedString(iei
->getName());
1508 Out
<< "\", " << bbname
<< ");";
1511 case Instruction::ShuffleVector
: {
1512 const ShuffleVectorInst
* svi
= cast
<ShuffleVectorInst
>(I
);
1513 Out
<< "ShuffleVectorInst* " << getCppName(svi
)
1514 << " = new ShuffleVectorInst(" << opNames
[0]
1515 << ", " << opNames
[1] << ", " << opNames
[2] << ", \"";
1516 printEscapedString(svi
->getName());
1517 Out
<< "\", " << bbname
<< ");";
1520 case Instruction::ExtractValue
: {
1521 const ExtractValueInst
*evi
= cast
<ExtractValueInst
>(I
);
1522 Out
<< "std::vector<unsigned> " << iName
<< "_indices;";
1524 for (unsigned i
= 0; i
< evi
->getNumIndices(); ++i
) {
1525 Out
<< iName
<< "_indices.push_back("
1526 << evi
->idx_begin()[i
] << ");";
1529 Out
<< "ExtractValueInst* " << getCppName(evi
)
1530 << " = ExtractValueInst::Create(" << opNames
[0]
1532 << iName
<< "_indices, \"";
1533 printEscapedString(evi
->getName());
1534 Out
<< "\", " << bbname
<< ");";
1537 case Instruction::InsertValue
: {
1538 const InsertValueInst
*ivi
= cast
<InsertValueInst
>(I
);
1539 Out
<< "std::vector<unsigned> " << iName
<< "_indices;";
1541 for (unsigned i
= 0; i
< ivi
->getNumIndices(); ++i
) {
1542 Out
<< iName
<< "_indices.push_back("
1543 << ivi
->idx_begin()[i
] << ");";
1546 Out
<< "InsertValueInst* " << getCppName(ivi
)
1547 << " = InsertValueInst::Create(" << opNames
[0]
1548 << ", " << opNames
[1] << ", "
1549 << iName
<< "_indices, \"";
1550 printEscapedString(ivi
->getName());
1551 Out
<< "\", " << bbname
<< ");";
1554 case Instruction::Fence
: {
1555 const FenceInst
*fi
= cast
<FenceInst
>(I
);
1556 StringRef Ordering
= ConvertAtomicOrdering(fi
->getOrdering());
1557 StringRef CrossThread
= ConvertAtomicSynchScope(fi
->getSynchScope());
1558 Out
<< "FenceInst* " << iName
1559 << " = new FenceInst(mod->getContext(), "
1560 << Ordering
<< ", " << CrossThread
<< ", " << bbname
1564 case Instruction::AtomicCmpXchg
: {
1565 const AtomicCmpXchgInst
*cxi
= cast
<AtomicCmpXchgInst
>(I
);
1566 StringRef SuccessOrdering
=
1567 ConvertAtomicOrdering(cxi
->getSuccessOrdering());
1568 StringRef FailureOrdering
=
1569 ConvertAtomicOrdering(cxi
->getFailureOrdering());
1570 StringRef CrossThread
= ConvertAtomicSynchScope(cxi
->getSynchScope());
1571 Out
<< "AtomicCmpXchgInst* " << iName
1572 << " = new AtomicCmpXchgInst("
1573 << opNames
[0] << ", " << opNames
[1] << ", " << opNames
[2] << ", "
1574 << SuccessOrdering
<< ", " << FailureOrdering
<< ", "
1575 << CrossThread
<< ", " << bbname
1577 nl(Out
) << iName
<< "->setName(\"";
1578 printEscapedString(cxi
->getName());
1580 nl(Out
) << iName
<< "->setVolatile("
1581 << (cxi
->isVolatile() ? "true" : "false") << ");";
1582 nl(Out
) << iName
<< "->setWeak("
1583 << (cxi
->isWeak() ? "true" : "false") << ");";
1586 case Instruction::AtomicRMW
: {
1587 const AtomicRMWInst
*rmwi
= cast
<AtomicRMWInst
>(I
);
1588 StringRef Ordering
= ConvertAtomicOrdering(rmwi
->getOrdering());
1589 StringRef CrossThread
= ConvertAtomicSynchScope(rmwi
->getSynchScope());
1590 StringRef Operation
;
1591 switch (rmwi
->getOperation()) {
1592 case AtomicRMWInst::Xchg
: Operation
= "AtomicRMWInst::Xchg"; break;
1593 case AtomicRMWInst::Add
: Operation
= "AtomicRMWInst::Add"; break;
1594 case AtomicRMWInst::Sub
: Operation
= "AtomicRMWInst::Sub"; break;
1595 case AtomicRMWInst::And
: Operation
= "AtomicRMWInst::And"; break;
1596 case AtomicRMWInst::Nand
: Operation
= "AtomicRMWInst::Nand"; break;
1597 case AtomicRMWInst::Or
: Operation
= "AtomicRMWInst::Or"; break;
1598 case AtomicRMWInst::Xor
: Operation
= "AtomicRMWInst::Xor"; break;
1599 case AtomicRMWInst::Max
: Operation
= "AtomicRMWInst::Max"; break;
1600 case AtomicRMWInst::Min
: Operation
= "AtomicRMWInst::Min"; break;
1601 case AtomicRMWInst::UMax
: Operation
= "AtomicRMWInst::UMax"; break;
1602 case AtomicRMWInst::UMin
: Operation
= "AtomicRMWInst::UMin"; break;
1603 case AtomicRMWInst::BAD_BINOP
: llvm_unreachable("Bad atomic operation");
1605 Out
<< "AtomicRMWInst* " << iName
1606 << " = new AtomicRMWInst("
1607 << Operation
<< ", "
1608 << opNames
[0] << ", " << opNames
[1] << ", "
1609 << Ordering
<< ", " << CrossThread
<< ", " << bbname
1611 nl(Out
) << iName
<< "->setName(\"";
1612 printEscapedString(rmwi
->getName());
1614 nl(Out
) << iName
<< "->setVolatile("
1615 << (rmwi
->isVolatile() ? "true" : "false") << ");";
1618 case Instruction::LandingPad
: {
1619 const LandingPadInst
*lpi
= cast
<LandingPadInst
>(I
);
1620 Out
<< "LandingPadInst* " << iName
<< " = LandingPadInst::Create(";
1621 printCppName(lpi
->getType());
1622 Out
<< ", " << opNames
[0] << ", " << lpi
->getNumClauses() << ", \"";
1623 printEscapedString(lpi
->getName());
1624 Out
<< "\", " << bbname
<< ");";
1625 nl(Out
) << iName
<< "->setCleanup("
1626 << (lpi
->isCleanup() ? "true" : "false")
1628 for (unsigned i
= 0, e
= lpi
->getNumClauses(); i
!= e
; ++i
)
1629 nl(Out
) << iName
<< "->addClause(" << opNames
[i
+1] << ");";
1633 DefinedValues
.insert(I
);
1638 // Print out the types, constants and declarations needed by one function
1639 void CppWriter::printFunctionUses(const Function
* F
) {
1640 nl(Out
) << "// Type Definitions"; nl(Out
);
1642 // Print the function's return type
1643 printType(F
->getReturnType());
1645 // Print the function's function type
1646 printType(F
->getFunctionType());
1648 // Print the types of each of the function's arguments
1649 for (Function::const_arg_iterator AI
= F
->arg_begin(), AE
= F
->arg_end();
1651 printType(AI
->getType());
1655 // Print type definitions for every type referenced by an instruction and
1656 // make a note of any global values or constants that are referenced
1657 SmallPtrSet
<GlobalValue
*,64> gvs
;
1658 SmallPtrSet
<Constant
*,64> consts
;
1659 for (Function::const_iterator BB
= F
->begin(), BE
= F
->end();
1661 for (BasicBlock::const_iterator I
= BB
->begin(), E
= BB
->end();
1663 // Print the type of the instruction itself
1664 printType(I
->getType());
1666 // Print the type of each of the instruction's operands
1667 for (unsigned i
= 0; i
< I
->getNumOperands(); ++i
) {
1668 Value
* operand
= I
->getOperand(i
);
1669 printType(operand
->getType());
1671 // If the operand references a GVal or Constant, make a note of it
1672 if (GlobalValue
* GV
= dyn_cast
<GlobalValue
>(operand
)) {
1674 if (GenerationType
!= GenFunction
)
1675 if (GlobalVariable
*GVar
= dyn_cast
<GlobalVariable
>(GV
))
1676 if (GVar
->hasInitializer())
1677 consts
.insert(GVar
->getInitializer());
1678 } else if (Constant
* C
= dyn_cast
<Constant
>(operand
)) {
1680 for (unsigned j
= 0; j
< C
->getNumOperands(); ++j
) {
1681 // If the operand references a GVal or Constant, make a note of it
1682 Value
* operand
= C
->getOperand(j
);
1683 printType(operand
->getType());
1684 if (GlobalValue
* GV
= dyn_cast
<GlobalValue
>(operand
)) {
1686 if (GenerationType
!= GenFunction
)
1687 if (GlobalVariable
*GVar
= dyn_cast
<GlobalVariable
>(GV
))
1688 if (GVar
->hasInitializer())
1689 consts
.insert(GVar
->getInitializer());
1697 // Print the function declarations for any functions encountered
1698 nl(Out
) << "// Function Declarations"; nl(Out
);
1699 for (auto *GV
: gvs
) {
1700 if (Function
*Fun
= dyn_cast
<Function
>(GV
)) {
1701 if (!is_inline
|| Fun
!= F
)
1702 printFunctionHead(Fun
);
1706 // Print the global variable declarations for any variables encountered
1707 nl(Out
) << "// Global Variable Declarations"; nl(Out
);
1708 for (auto *GV
: gvs
) {
1709 if (GlobalVariable
*F
= dyn_cast
<GlobalVariable
>(GV
))
1710 printVariableHead(F
);
1713 // Print the constants found
1714 nl(Out
) << "// Constant Definitions"; nl(Out
);
1715 for (const auto *C
: consts
) {
1719 // Process the global variables definitions now that all the constants have
1720 // been emitted. These definitions just couple the gvars with their constant
1722 if (GenerationType
!= GenFunction
) {
1723 nl(Out
) << "// Global Variable Definitions"; nl(Out
);
1724 for (const auto &GV
: gvs
) {
1725 if (GlobalVariable
*Var
= dyn_cast
<GlobalVariable
>(GV
))
1726 printVariableBody(Var
);
1731 void CppWriter::printFunctionHead(const Function
* F
) {
1732 nl(Out
) << "Function* " << getCppName(F
);
1733 Out
<< " = mod->getFunction(\"";
1734 printEscapedString(F
->getName());
1736 nl(Out
) << "if (!" << getCppName(F
) << ") {";
1737 nl(Out
) << getCppName(F
);
1739 Out
<< " = Function::Create(";
1740 nl(Out
,1) << "/*Type=*/" << getCppName(F
->getFunctionType()) << ",";
1741 nl(Out
) << "/*Linkage=*/";
1742 printLinkageType(F
->getLinkage());
1744 nl(Out
) << "/*Name=*/\"";
1745 printEscapedString(F
->getName());
1746 Out
<< "\", mod); " << (F
->isDeclaration()? "// (external, no body)" : "");
1749 Out
<< "->setCallingConv(";
1750 printCallingConv(F
->getCallingConv());
1753 if (F
->hasSection()) {
1755 Out
<< "->setSection(\"" << F
->getSection() << "\");";
1758 if (F
->getAlignment()) {
1760 Out
<< "->setAlignment(" << F
->getAlignment() << ");";
1763 if (F
->getVisibility() != GlobalValue::DefaultVisibility
) {
1765 Out
<< "->setVisibility(";
1766 printVisibilityType(F
->getVisibility());
1770 if (F
->getDLLStorageClass() != GlobalValue::DefaultStorageClass
) {
1772 Out
<< "->setDLLStorageClass(";
1773 printDLLStorageClassType(F
->getDLLStorageClass());
1779 Out
<< "->setGC(\"" << F
->getGC() << "\");";
1784 printAttributes(F
->getAttributes(), getCppName(F
));
1786 Out
<< "->setAttributes(" << getCppName(F
) << "_PAL);";
1790 void CppWriter::printFunctionBody(const Function
*F
) {
1791 if (F
->isDeclaration())
1792 return; // external functions have no bodies.
1794 // Clear the DefinedValues and ForwardRefs maps because we can't have
1795 // cross-function forward refs
1796 ForwardRefs
.clear();
1797 DefinedValues
.clear();
1799 // Create all the argument values
1801 if (!F
->arg_empty()) {
1802 Out
<< "Function::arg_iterator args = " << getCppName(F
)
1803 << "->arg_begin();";
1806 for (Function::const_arg_iterator AI
= F
->arg_begin(), AE
= F
->arg_end();
1808 Out
<< "Value* " << getCppName(AI
) << " = args++;";
1810 if (AI
->hasName()) {
1811 Out
<< getCppName(AI
) << "->setName(\"";
1812 printEscapedString(AI
->getName());
1819 // Create all the basic blocks
1821 for (Function::const_iterator BI
= F
->begin(), BE
= F
->end();
1823 std::string
bbname(getCppName(BI
));
1824 Out
<< "BasicBlock* " << bbname
<<
1825 " = BasicBlock::Create(mod->getContext(), \"";
1827 printEscapedString(BI
->getName());
1828 Out
<< "\"," << getCppName(BI
->getParent()) << ",0);";
1832 // Output all of its basic blocks... for the function
1833 for (Function::const_iterator BI
= F
->begin(), BE
= F
->end();
1835 std::string
bbname(getCppName(BI
));
1836 nl(Out
) << "// Block " << BI
->getName() << " (" << bbname
<< ")";
1839 // Output all of the instructions in the basic block...
1840 for (BasicBlock::const_iterator I
= BI
->begin(), E
= BI
->end();
1842 printInstruction(I
,bbname
);
1846 // Loop over the ForwardRefs and resolve them now that all instructions
1848 if (!ForwardRefs
.empty()) {
1849 nl(Out
) << "// Resolve Forward References";
1853 while (!ForwardRefs
.empty()) {
1854 ForwardRefMap::iterator I
= ForwardRefs
.begin();
1855 Out
<< I
->second
<< "->replaceAllUsesWith("
1856 << getCppName(I
->first
) << "); delete " << I
->second
<< ";";
1858 ForwardRefs
.erase(I
);
1862 void CppWriter::printInline(const std::string
& fname
,
1863 const std::string
& func
) {
1864 const Function
* F
= TheModule
->getFunction(func
);
1866 error(std::string("Function '") + func
+ "' not found in input module");
1869 if (F
->isDeclaration()) {
1870 error(std::string("Function '") + func
+ "' is external!");
1873 nl(Out
) << "BasicBlock* " << fname
<< "(Module* mod, Function *"
1875 unsigned arg_count
= 1;
1876 for (Function::const_arg_iterator AI
= F
->arg_begin(), AE
= F
->arg_end();
1878 Out
<< ", Value* arg_" << arg_count
++;
1883 printFunctionUses(F
);
1884 printFunctionBody(F
);
1886 Out
<< "return " << getCppName(F
->begin()) << ";";
1891 void CppWriter::printModuleBody() {
1892 // Print out all the type definitions
1893 nl(Out
) << "// Type Definitions"; nl(Out
);
1894 printTypes(TheModule
);
1896 // Functions can call each other and global variables can reference them so
1897 // define all the functions first before emitting their function bodies.
1898 nl(Out
) << "// Function Declarations"; nl(Out
);
1899 for (Module::const_iterator I
= TheModule
->begin(), E
= TheModule
->end();
1901 printFunctionHead(I
);
1903 // Process the global variables declarations. We can't initialze them until
1904 // after the constants are printed so just print a header for each global
1905 nl(Out
) << "// Global Variable Declarations\n"; nl(Out
);
1906 for (Module::const_global_iterator I
= TheModule
->global_begin(),
1907 E
= TheModule
->global_end(); I
!= E
; ++I
) {
1908 printVariableHead(I
);
1911 // Print out all the constants definitions. Constants don't recurse except
1912 // through GlobalValues. All GlobalValues have been declared at this point
1913 // so we can proceed to generate the constants.
1914 nl(Out
) << "// Constant Definitions"; nl(Out
);
1915 printConstants(TheModule
);
1917 // Process the global variables definitions now that all the constants have
1918 // been emitted. These definitions just couple the gvars with their constant
1920 nl(Out
) << "// Global Variable Definitions"; nl(Out
);
1921 for (Module::const_global_iterator I
= TheModule
->global_begin(),
1922 E
= TheModule
->global_end(); I
!= E
; ++I
) {
1923 printVariableBody(I
);
1926 // Finally, we can safely put out all of the function bodies.
1927 nl(Out
) << "// Function Definitions"; nl(Out
);
1928 for (Module::const_iterator I
= TheModule
->begin(), E
= TheModule
->end();
1930 if (!I
->isDeclaration()) {
1931 nl(Out
) << "// Function: " << I
->getName() << " (" << getCppName(I
)
1935 printFunctionBody(I
);
1942 void CppWriter::printProgram(const std::string
& fname
,
1943 const std::string
& mName
) {
1944 Out
<< "#include <llvm/Pass.h>\n";
1945 Out
<< "#include <llvm/PassManager.h>\n";
1947 Out
<< "#include <llvm/ADT/SmallVector.h>\n";
1948 Out
<< "#include <llvm/Analysis/Verifier.h>\n";
1949 Out
<< "#include <llvm/IR/BasicBlock.h>\n";
1950 Out
<< "#include <llvm/IR/CallingConv.h>\n";
1951 Out
<< "#include <llvm/IR/Constants.h>\n";
1952 Out
<< "#include <llvm/IR/DerivedTypes.h>\n";
1953 Out
<< "#include <llvm/IR/Function.h>\n";
1954 Out
<< "#include <llvm/IR/GlobalVariable.h>\n";
1955 Out
<< "#include <llvm/IR/IRPrintingPasses.h>\n";
1956 Out
<< "#include <llvm/IR/InlineAsm.h>\n";
1957 Out
<< "#include <llvm/IR/Instructions.h>\n";
1958 Out
<< "#include <llvm/IR/LLVMContext.h>\n";
1959 Out
<< "#include <llvm/IR/Module.h>\n";
1960 Out
<< "#include <llvm/Support/FormattedStream.h>\n";
1961 Out
<< "#include <llvm/Support/MathExtras.h>\n";
1962 Out
<< "#include <algorithm>\n";
1963 Out
<< "using namespace llvm;\n\n";
1964 Out
<< "Module* " << fname
<< "();\n\n";
1965 Out
<< "int main(int argc, char**argv) {\n";
1966 Out
<< " Module* Mod = " << fname
<< "();\n";
1967 Out
<< " verifyModule(*Mod, PrintMessageAction);\n";
1968 Out
<< " PassManager PM;\n";
1969 Out
<< " PM.add(createPrintModulePass(&outs()));\n";
1970 Out
<< " PM.run(*Mod);\n";
1971 Out
<< " return 0;\n";
1973 printModule(fname
,mName
);
1976 void CppWriter::printModule(const std::string
& fname
,
1977 const std::string
& mName
) {
1978 nl(Out
) << "Module* " << fname
<< "() {";
1979 nl(Out
,1) << "// Module Construction";
1980 nl(Out
) << "Module* mod = new Module(\"";
1981 printEscapedString(mName
);
1982 Out
<< "\", getGlobalContext());";
1983 if (!TheModule
->getTargetTriple().empty()) {
1984 nl(Out
) << "mod->setDataLayout(\"" << TheModule
->getDataLayout() << "\");";
1986 if (!TheModule
->getTargetTriple().empty()) {
1987 nl(Out
) << "mod->setTargetTriple(\"" << TheModule
->getTargetTriple()
1991 if (!TheModule
->getModuleInlineAsm().empty()) {
1992 nl(Out
) << "mod->setModuleInlineAsm(\"";
1993 printEscapedString(TheModule
->getModuleInlineAsm());
1999 nl(Out
) << "return mod;";
2004 void CppWriter::printContents(const std::string
& fname
,
2005 const std::string
& mName
) {
2006 Out
<< "\nModule* " << fname
<< "(Module *mod) {\n";
2007 Out
<< "\nmod->setModuleIdentifier(\"";
2008 printEscapedString(mName
);
2011 Out
<< "\nreturn mod;\n";
2015 void CppWriter::printFunction(const std::string
& fname
,
2016 const std::string
& funcName
) {
2017 const Function
* F
= TheModule
->getFunction(funcName
);
2019 error(std::string("Function '") + funcName
+ "' not found in input module");
2022 Out
<< "\nFunction* " << fname
<< "(Module *mod) {\n";
2023 printFunctionUses(F
);
2024 printFunctionHead(F
);
2025 printFunctionBody(F
);
2026 Out
<< "return " << getCppName(F
) << ";\n";
2030 void CppWriter::printFunctions() {
2031 const Module::FunctionListType
&funcs
= TheModule
->getFunctionList();
2032 Module::const_iterator I
= funcs
.begin();
2033 Module::const_iterator IE
= funcs
.end();
2035 for (; I
!= IE
; ++I
) {
2036 const Function
&func
= *I
;
2037 if (!func
.isDeclaration()) {
2038 std::string
name("define_");
2039 name
+= func
.getName();
2040 printFunction(name
, func
.getName());
2045 void CppWriter::printVariable(const std::string
& fname
,
2046 const std::string
& varName
) {
2047 const GlobalVariable
* GV
= TheModule
->getNamedGlobal(varName
);
2050 error(std::string("Variable '") + varName
+ "' not found in input module");
2053 Out
<< "\nGlobalVariable* " << fname
<< "(Module *mod) {\n";
2054 printVariableUses(GV
);
2055 printVariableHead(GV
);
2056 printVariableBody(GV
);
2057 Out
<< "return " << getCppName(GV
) << ";\n";
2061 void CppWriter::printType(const std::string
&fname
,
2062 const std::string
&typeName
) {
2063 Type
* Ty
= TheModule
->getTypeByName(typeName
);
2065 error(std::string("Type '") + typeName
+ "' not found in input module");
2068 Out
<< "\nType* " << fname
<< "(Module *mod) {\n";
2070 Out
<< "return " << getCppName(Ty
) << ";\n";
2074 bool CppWriter::runOnModule(Module
&M
) {
2078 Out
<< "// Generated by llvm2cpp - DO NOT MODIFY!\n\n";
2080 // Get the name of the function we're supposed to generate
2081 std::string fname
= FuncName
.getValue();
2083 // Get the name of the thing we are to generate
2084 std::string tgtname
= NameToGenerate
.getValue();
2085 if (GenerationType
== GenModule
||
2086 GenerationType
== GenContents
||
2087 GenerationType
== GenProgram
||
2088 GenerationType
== GenFunctions
) {
2089 if (tgtname
== "!bad!") {
2090 if (M
.getModuleIdentifier() == "-")
2091 tgtname
= "<stdin>";
2093 tgtname
= M
.getModuleIdentifier();
2095 } else if (tgtname
== "!bad!")
2096 error("You must use the -for option with -gen-{function,variable,type}");
2098 switch (WhatToGenerate(GenerationType
)) {
2101 fname
= "makeLLVMModule";
2102 printProgram(fname
,tgtname
);
2106 fname
= "makeLLVMModule";
2107 printModule(fname
,tgtname
);
2111 fname
= "makeLLVMModuleContents";
2112 printContents(fname
,tgtname
);
2116 fname
= "makeLLVMFunction";
2117 printFunction(fname
,tgtname
);
2124 fname
= "makeLLVMInline";
2125 printInline(fname
,tgtname
);
2129 fname
= "makeLLVMVariable";
2130 printVariable(fname
,tgtname
);
2134 fname
= "makeLLVMType";
2135 printType(fname
,tgtname
);
2142 char CppWriter::ID
= 0;
2144 //===----------------------------------------------------------------------===//
2145 // External Interface declaration
2146 //===----------------------------------------------------------------------===//
2148 bool CPPTargetMachine::addPassesToEmitFile(PassManagerBase
&PM
,
2149 formatted_raw_ostream
&o
,
2150 CodeGenFileType FileType
,
2152 AnalysisID StartAfter
,
2153 AnalysisID StopAfter
) {
2154 if (FileType
!= TargetMachine::CGFT_AssemblyFile
) return true;
2155 PM
.add(new CppWriter(o
));