LLVM  3.7.0
CPPBackend.cpp
Go to the documentation of this file.
1 //===-- CPPBackend.cpp - Library for converting LLVM code to C++ code -----===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
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.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "CPPTargetMachine.h"
16 #include "llvm/ADT/SmallPtrSet.h"
17 #include "llvm/ADT/StringExtras.h"
18 #include "llvm/ADT/STLExtras.h"
19 #include "llvm/Config/config.h"
20 #include "llvm/IR/CallingConv.h"
21 #include "llvm/IR/Constants.h"
22 #include "llvm/IR/DerivedTypes.h"
23 #include "llvm/IR/InlineAsm.h"
24 #include "llvm/IR/Instruction.h"
25 #include "llvm/IR/Instructions.h"
27 #include "llvm/IR/Module.h"
28 #include "llvm/MC/MCAsmInfo.h"
29 #include "llvm/MC/MCInstrInfo.h"
31 #include "llvm/Pass.h"
36 #include <algorithm>
37 #include <cctype>
38 #include <cstdio>
39 #include <map>
40 #include <set>
41 using namespace llvm;
42 
44 FuncName("cppfname", cl::desc("Specify the name of the generated function"),
45  cl::value_desc("function name"));
46 
56 };
57 
59  cl::desc("Choose what kind of output to generate"),
61  cl::values(
62  clEnumValN(GenProgram, "program", "Generate a complete program"),
63  clEnumValN(GenModule, "module", "Generate a module definition"),
64  clEnumValN(GenContents, "contents", "Generate contents of a module"),
65  clEnumValN(GenFunction, "function", "Generate a function definition"),
66  clEnumValN(GenFunctions,"functions", "Generate all function definitions"),
67  clEnumValN(GenInline, "inline", "Generate an inline function"),
68  clEnumValN(GenVariable, "variable", "Generate a variable definition"),
69  clEnumValN(GenType, "type", "Generate a type definition"),
71  )
72 );
73 
75  cl::desc("Specify the name of the thing to generate"),
76  cl::init("!bad!"));
77 
78 extern "C" void LLVMInitializeCppBackendTarget() {
79  // Register the target.
81 }
82 
83 namespace {
84  typedef std::vector<Type*> TypeList;
85  typedef std::map<Type*,std::string> TypeMap;
86  typedef std::map<const Value*,std::string> ValueMap;
87  typedef std::set<std::string> NameSet;
88  typedef std::set<Type*> TypeSet;
89  typedef std::set<const Value*> ValueSet;
90  typedef std::map<const Value*,std::string> ForwardRefMap;
91 
92  /// CppWriter - This class is the main chunk of code that converts an LLVM
93  /// module to a C++ translation unit.
94  class CppWriter : public ModulePass {
95  std::unique_ptr<formatted_raw_ostream> OutOwner;
97  const Module *TheModule;
98  uint64_t uniqueNum;
99  TypeMap TypeNames;
100  ValueMap ValueNames;
101  NameSet UsedNames;
102  TypeSet DefinedTypes;
103  ValueSet DefinedValues;
104  ForwardRefMap ForwardRefs;
105  bool is_inline;
106  unsigned indent_level;
107 
108  public:
109  static char ID;
110  explicit CppWriter(std::unique_ptr<formatted_raw_ostream> o)
111  : ModulePass(ID), OutOwner(std::move(o)), Out(*OutOwner), uniqueNum(0),
112  is_inline(false), indent_level(0) {}
113 
114  const char *getPassName() const override { return "C++ backend"; }
115 
116  bool runOnModule(Module &M) override;
117 
118  void printProgram(const std::string& fname, const std::string& modName );
119  void printModule(const std::string& fname, const std::string& modName );
120  void printContents(const std::string& fname, const std::string& modName );
121  void printFunction(const std::string& fname, const std::string& funcName );
122  void printFunctions();
123  void printInline(const std::string& fname, const std::string& funcName );
124  void printVariable(const std::string& fname, const std::string& varName );
125  void printType(const std::string& fname, const std::string& typeName );
126 
127  void error(const std::string& msg);
128 
129 
130  formatted_raw_ostream& nl(formatted_raw_ostream &Out, int delta = 0);
131  inline void in() { indent_level++; }
132  inline void out() { if (indent_level >0) indent_level--; }
133 
134  private:
135  void printLinkageType(GlobalValue::LinkageTypes LT);
136  void printVisibilityType(GlobalValue::VisibilityTypes VisTypes);
137  void printDLLStorageClassType(GlobalValue::DLLStorageClassTypes DSCType);
138  void printThreadLocalMode(GlobalVariable::ThreadLocalMode TLM);
139  void printCallingConv(CallingConv::ID cc);
140  void printEscapedString(const std::string& str);
141  void printCFP(const ConstantFP* CFP);
142 
143  std::string getCppName(Type* val);
144  inline void printCppName(Type* val);
145 
146  std::string getCppName(const Value* val);
147  inline void printCppName(const Value* val);
148 
149  void printAttributes(const AttributeSet &PAL, const std::string &name);
150  void printType(Type* Ty);
151  void printTypes(const Module* M);
152 
153  void printConstant(const Constant *CPV);
154  void printConstants(const Module* M);
155 
156  void printVariableUses(const GlobalVariable *GV);
157  void printVariableHead(const GlobalVariable *GV);
158  void printVariableBody(const GlobalVariable *GV);
159 
160  void printFunctionUses(const Function *F);
161  void printFunctionHead(const Function *F);
162  void printFunctionBody(const Function *F);
163  void printInstruction(const Instruction *I, const std::string& bbname);
164  std::string getOpName(const Value*);
165 
166  void printModuleBody();
167  };
168 } // end anonymous namespace.
169 
170 formatted_raw_ostream &CppWriter::nl(formatted_raw_ostream &Out, int delta) {
171  Out << '\n';
172  if (delta >= 0 || indent_level >= unsigned(-delta))
173  indent_level += delta;
174  Out.indent(indent_level);
175  return Out;
176 }
177 
178 static inline void sanitize(std::string &str) {
179  for (size_t i = 0; i < str.length(); ++i)
180  if (!isalnum(str[i]) && str[i] != '_')
181  str[i] = '_';
182 }
183 
184 static std::string getTypePrefix(Type *Ty) {
185  switch (Ty->getTypeID()) {
186  case Type::VoidTyID: return "void_";
187  case Type::IntegerTyID:
188  return "int" + utostr(cast<IntegerType>(Ty)->getBitWidth()) + "_";
189  case Type::FloatTyID: return "float_";
190  case Type::DoubleTyID: return "double_";
191  case Type::LabelTyID: return "label_";
192  case Type::FunctionTyID: return "func_";
193  case Type::StructTyID: return "struct_";
194  case Type::ArrayTyID: return "array_";
195  case Type::PointerTyID: return "ptr_";
196  case Type::VectorTyID: return "packed_";
197  default: return "other_";
198  }
199 }
200 
201 void CppWriter::error(const std::string& msg) {
202  report_fatal_error(msg);
203 }
204 
205 static inline std::string ftostr(const APFloat& V) {
206  std::string Buf;
207  if (&V.getSemantics() == &APFloat::IEEEdouble) {
209  return Buf;
210  } else if (&V.getSemantics() == &APFloat::IEEEsingle) {
211  raw_string_ostream(Buf) << (double)V.convertToFloat();
212  return Buf;
213  }
214  return "<unknown format in ftostr>"; // error
215 }
216 
217 // printCFP - Print a floating point constant .. very carefully :)
218 // This makes sure that conversion to/from floating yields the same binary
219 // result so that we don't lose precision.
220 void CppWriter::printCFP(const ConstantFP *CFP) {
221  bool ignored;
222  APFloat APF = APFloat(CFP->getValueAPF()); // copy
223  if (CFP->getType() == Type::getFloatTy(CFP->getContext()))
225  Out << "ConstantFP::get(mod->getContext(), ";
226  Out << "APFloat(";
227 #if HAVE_PRINTF_A
228  char Buffer[100];
229  sprintf(Buffer, "%A", APF.convertToDouble());
230  if ((!strncmp(Buffer, "0x", 2) ||
231  !strncmp(Buffer, "-0x", 3) ||
232  !strncmp(Buffer, "+0x", 3)) &&
233  APF.bitwiseIsEqual(APFloat(atof(Buffer)))) {
234  if (CFP->getType() == Type::getDoubleTy(CFP->getContext()))
235  Out << "BitsToDouble(" << Buffer << ")";
236  else
237  Out << "BitsToFloat((float)" << Buffer << ")";
238  Out << ")";
239  } else {
240 #endif
241  std::string StrVal = ftostr(CFP->getValueAPF());
242 
243  while (StrVal[0] == ' ')
244  StrVal.erase(StrVal.begin());
245 
246  // Check to make sure that the stringized number is not some string like
247  // "Inf" or NaN. Check that the string matches the "[-+]?[0-9]" regex.
248  if (((StrVal[0] >= '0' && StrVal[0] <= '9') ||
249  ((StrVal[0] == '-' || StrVal[0] == '+') &&
250  (StrVal[1] >= '0' && StrVal[1] <= '9'))) &&
251  (CFP->isExactlyValue(atof(StrVal.c_str())))) {
252  if (CFP->getType() == Type::getDoubleTy(CFP->getContext()))
253  Out << StrVal;
254  else
255  Out << StrVal << "f";
256  } else if (CFP->getType() == Type::getDoubleTy(CFP->getContext()))
257  Out << "BitsToDouble(0x"
259  << "ULL) /* " << StrVal << " */";
260  else
261  Out << "BitsToFloat(0x"
262  << utohexstr((uint32_t)CFP->getValueAPF().
263  bitcastToAPInt().getZExtValue())
264  << "U) /* " << StrVal << " */";
265  Out << ")";
266 #if HAVE_PRINTF_A
267  }
268 #endif
269  Out << ")";
270 }
271 
272 void CppWriter::printCallingConv(CallingConv::ID cc){
273  // Print the calling convention.
274  switch (cc) {
275  case CallingConv::C: Out << "CallingConv::C"; break;
276  case CallingConv::Fast: Out << "CallingConv::Fast"; break;
277  case CallingConv::Cold: Out << "CallingConv::Cold"; break;
278  case CallingConv::FirstTargetCC: Out << "CallingConv::FirstTargetCC"; break;
279  default: Out << cc; break;
280  }
281 }
282 
283 void CppWriter::printLinkageType(GlobalValue::LinkageTypes LT) {
284  switch (LT) {
286  Out << "GlobalValue::InternalLinkage"; break;
288  Out << "GlobalValue::PrivateLinkage"; break;
290  Out << "GlobalValue::AvailableExternallyLinkage "; break;
292  Out << "GlobalValue::LinkOnceAnyLinkage "; break;
294  Out << "GlobalValue::LinkOnceODRLinkage "; break;
296  Out << "GlobalValue::WeakAnyLinkage"; break;
298  Out << "GlobalValue::WeakODRLinkage"; break;
300  Out << "GlobalValue::AppendingLinkage"; break;
302  Out << "GlobalValue::ExternalLinkage"; break;
304  Out << "GlobalValue::ExternalWeakLinkage"; break;
306  Out << "GlobalValue::CommonLinkage"; break;
307  }
308 }
309 
310 void CppWriter::printVisibilityType(GlobalValue::VisibilityTypes VisType) {
311  switch (VisType) {
313  Out << "GlobalValue::DefaultVisibility";
314  break;
316  Out << "GlobalValue::HiddenVisibility";
317  break;
319  Out << "GlobalValue::ProtectedVisibility";
320  break;
321  }
322 }
323 
324 void CppWriter::printDLLStorageClassType(
326  switch (DSCType) {
328  Out << "GlobalValue::DefaultStorageClass";
329  break;
331  Out << "GlobalValue::DLLImportStorageClass";
332  break;
334  Out << "GlobalValue::DLLExportStorageClass";
335  break;
336  }
337 }
338 
339 void CppWriter::printThreadLocalMode(GlobalVariable::ThreadLocalMode TLM) {
340  switch (TLM) {
342  Out << "GlobalVariable::NotThreadLocal";
343  break;
345  Out << "GlobalVariable::GeneralDynamicTLSModel";
346  break;
348  Out << "GlobalVariable::LocalDynamicTLSModel";
349  break;
351  Out << "GlobalVariable::InitialExecTLSModel";
352  break;
354  Out << "GlobalVariable::LocalExecTLSModel";
355  break;
356  }
357 }
358 
359 // printEscapedString - Print each character of the specified string, escaping
360 // it if it is not printable or if it is an escape char.
361 void CppWriter::printEscapedString(const std::string &Str) {
362  for (unsigned i = 0, e = Str.size(); i != e; ++i) {
363  unsigned char C = Str[i];
364  if (isprint(C) && C != '"' && C != '\\') {
365  Out << C;
366  } else {
367  Out << "\\x"
368  << (char) ((C/16 < 10) ? ( C/16 +'0') : ( C/16 -10+'A'))
369  << (char)(((C&15) < 10) ? ((C&15)+'0') : ((C&15)-10+'A'));
370  }
371  }
372 }
373 
374 std::string CppWriter::getCppName(Type* Ty) {
375  switch (Ty->getTypeID()) {
376  default:
377  break;
378  case Type::VoidTyID:
379  return "Type::getVoidTy(mod->getContext())";
380  case Type::IntegerTyID: {
381  unsigned BitWidth = cast<IntegerType>(Ty)->getBitWidth();
382  return "IntegerType::get(mod->getContext(), " + utostr(BitWidth) + ")";
383  }
384  case Type::X86_FP80TyID:
385  return "Type::getX86_FP80Ty(mod->getContext())";
386  case Type::FloatTyID:
387  return "Type::getFloatTy(mod->getContext())";
388  case Type::DoubleTyID:
389  return "Type::getDoubleTy(mod->getContext())";
390  case Type::LabelTyID:
391  return "Type::getLabelTy(mod->getContext())";
392  case Type::X86_MMXTyID:
393  return "Type::getX86_MMXTy(mod->getContext())";
394  }
395 
396  // Now, see if we've seen the type before and return that
397  TypeMap::iterator I = TypeNames.find(Ty);
398  if (I != TypeNames.end())
399  return I->second;
400 
401  // Okay, let's build a new name for this type. Start with a prefix
402  const char* prefix = nullptr;
403  switch (Ty->getTypeID()) {
404  case Type::FunctionTyID: prefix = "FuncTy_"; break;
405  case Type::StructTyID: prefix = "StructTy_"; break;
406  case Type::ArrayTyID: prefix = "ArrayTy_"; break;
407  case Type::PointerTyID: prefix = "PointerTy_"; break;
408  case Type::VectorTyID: prefix = "VectorTy_"; break;
409  default: prefix = "OtherTy_"; break; // prevent breakage
410  }
411 
412  // See if the type has a name in the symboltable and build accordingly
413  std::string name;
414  if (StructType *STy = dyn_cast<StructType>(Ty))
415  if (STy->hasName())
416  name = STy->getName();
417 
418  if (name.empty())
419  name = utostr(uniqueNum++);
420 
421  name = std::string(prefix) + name;
422  sanitize(name);
423 
424  // Save the name
425  return TypeNames[Ty] = name;
426 }
427 
428 void CppWriter::printCppName(Type* Ty) {
429  printEscapedString(getCppName(Ty));
430 }
431 
432 std::string CppWriter::getCppName(const Value* val) {
433  std::string name;
434  ValueMap::iterator I = ValueNames.find(val);
435  if (I != ValueNames.end() && I->first == val)
436  return I->second;
437 
438  if (const GlobalVariable* GV = dyn_cast<GlobalVariable>(val)) {
439  name = std::string("gvar_") +
440  getTypePrefix(GV->getType()->getElementType());
441  } else if (isa<Function>(val)) {
442  name = std::string("func_");
443  } else if (const Constant* C = dyn_cast<Constant>(val)) {
444  name = std::string("const_") + getTypePrefix(C->getType());
445  } else if (const Argument* Arg = dyn_cast<Argument>(val)) {
446  if (is_inline) {
447  unsigned argNum = std::distance(Arg->getParent()->arg_begin(),
449  name = std::string("arg_") + utostr(argNum);
450  NameSet::iterator NI = UsedNames.find(name);
451  if (NI != UsedNames.end())
452  name += std::string("_") + utostr(uniqueNum++);
453  UsedNames.insert(name);
454  return ValueNames[val] = name;
455  } else {
456  name = getTypePrefix(val->getType());
457  }
458  } else {
459  name = getTypePrefix(val->getType());
460  }
461  if (val->hasName())
462  name += val->getName();
463  else
464  name += utostr(uniqueNum++);
465  sanitize(name);
466  NameSet::iterator NI = UsedNames.find(name);
467  if (NI != UsedNames.end())
468  name += std::string("_") + utostr(uniqueNum++);
469  UsedNames.insert(name);
470  return ValueNames[val] = name;
471 }
472 
473 void CppWriter::printCppName(const Value* val) {
474  printEscapedString(getCppName(val));
475 }
476 
477 void CppWriter::printAttributes(const AttributeSet &PAL,
478  const std::string &name) {
479  Out << "AttributeSet " << name << "_PAL;";
480  nl(Out);
481  if (!PAL.isEmpty()) {
482  Out << '{'; in(); nl(Out);
483  Out << "SmallVector<AttributeSet, 4> Attrs;"; nl(Out);
484  Out << "AttributeSet PAS;"; in(); nl(Out);
485  for (unsigned i = 0; i < PAL.getNumSlots(); ++i) {
486  unsigned index = PAL.getSlotIndex(i);
487  AttrBuilder attrs(PAL.getSlotAttributes(i), index);
488  Out << "{"; in(); nl(Out);
489  Out << "AttrBuilder B;"; nl(Out);
490 
491 #define HANDLE_ATTR(X) \
492  if (attrs.contains(Attribute::X)) { \
493  Out << "B.addAttribute(Attribute::" #X ");"; nl(Out); \
494  attrs.removeAttribute(Attribute::X); \
495  }
496 
497  HANDLE_ATTR(SExt);
498  HANDLE_ATTR(ZExt);
499  HANDLE_ATTR(NoReturn);
500  HANDLE_ATTR(InReg);
501  HANDLE_ATTR(StructRet);
502  HANDLE_ATTR(NoUnwind);
504  HANDLE_ATTR(ByVal);
505  HANDLE_ATTR(InAlloca);
506  HANDLE_ATTR(Nest);
507  HANDLE_ATTR(ReadNone);
508  HANDLE_ATTR(ReadOnly);
509  HANDLE_ATTR(NoInline);
510  HANDLE_ATTR(AlwaysInline);
511  HANDLE_ATTR(OptimizeNone);
512  HANDLE_ATTR(OptimizeForSize);
513  HANDLE_ATTR(StackProtect);
514  HANDLE_ATTR(StackProtectReq);
515  HANDLE_ATTR(StackProtectStrong);
516  HANDLE_ATTR(SafeStack);
517  HANDLE_ATTR(NoCapture);
518  HANDLE_ATTR(NoRedZone);
519  HANDLE_ATTR(NoImplicitFloat);
520  HANDLE_ATTR(Naked);
521  HANDLE_ATTR(InlineHint);
522  HANDLE_ATTR(ReturnsTwice);
523  HANDLE_ATTR(UWTable);
524  HANDLE_ATTR(NonLazyBind);
525  HANDLE_ATTR(MinSize);
526 #undef HANDLE_ATTR
527 
528  if (attrs.contains(Attribute::StackAlignment)) {
529  Out << "B.addStackAlignmentAttr(" << attrs.getStackAlignment()<<')';
530  nl(Out);
531  attrs.removeAttribute(Attribute::StackAlignment);
532  }
533 
534  Out << "PAS = AttributeSet::get(mod->getContext(), ";
535  if (index == ~0U)
536  Out << "~0U,";
537  else
538  Out << index << "U,";
539  Out << " B);"; out(); nl(Out);
540  Out << "}"; out(); nl(Out);
541  nl(Out);
542  Out << "Attrs.push_back(PAS);"; nl(Out);
543  }
544  Out << name << "_PAL = AttributeSet::get(mod->getContext(), Attrs);";
545  nl(Out);
546  out(); nl(Out);
547  Out << '}'; nl(Out);
548  }
549 }
550 
551 void CppWriter::printType(Type* Ty) {
552  // We don't print definitions for primitive types
553  if (Ty->isFloatingPointTy() || Ty->isX86_MMXTy() || Ty->isIntegerTy() ||
554  Ty->isLabelTy() || Ty->isMetadataTy() || Ty->isVoidTy())
555  return;
556 
557  // If we already defined this type, we don't need to define it again.
558  if (DefinedTypes.find(Ty) != DefinedTypes.end())
559  return;
560 
561  // Everything below needs the name for the type so get it now.
562  std::string typeName(getCppName(Ty));
563 
564  // Print the type definition
565  switch (Ty->getTypeID()) {
566  case Type::FunctionTyID: {
567  FunctionType* FT = cast<FunctionType>(Ty);
568  Out << "std::vector<Type*>" << typeName << "_args;";
569  nl(Out);
572  for (; PI != PE; ++PI) {
573  Type* argTy = static_cast<Type*>(*PI);
574  printType(argTy);
575  std::string argName(getCppName(argTy));
576  Out << typeName << "_args.push_back(" << argName;
577  Out << ");";
578  nl(Out);
579  }
580  printType(FT->getReturnType());
581  std::string retTypeName(getCppName(FT->getReturnType()));
582  Out << "FunctionType* " << typeName << " = FunctionType::get(";
583  in(); nl(Out) << "/*Result=*/" << retTypeName;
584  Out << ",";
585  nl(Out) << "/*Params=*/" << typeName << "_args,";
586  nl(Out) << "/*isVarArg=*/" << (FT->isVarArg() ? "true" : "false") << ");";
587  out();
588  nl(Out);
589  break;
590  }
591  case Type::StructTyID: {
592  StructType* ST = cast<StructType>(Ty);
593  if (!ST->isLiteral()) {
594  Out << "StructType *" << typeName << " = mod->getTypeByName(\"";
595  printEscapedString(ST->getName());
596  Out << "\");";
597  nl(Out);
598  Out << "if (!" << typeName << ") {";
599  nl(Out);
600  Out << typeName << " = ";
601  Out << "StructType::create(mod->getContext(), \"";
602  printEscapedString(ST->getName());
603  Out << "\");";
604  nl(Out);
605  Out << "}";
606  nl(Out);
607  // Indicate that this type is now defined.
608  DefinedTypes.insert(Ty);
609  }
610 
611  Out << "std::vector<Type*>" << typeName << "_fields;";
612  nl(Out);
615  for (; EI != EE; ++EI) {
616  Type* fieldTy = static_cast<Type*>(*EI);
617  printType(fieldTy);
618  std::string fieldName(getCppName(fieldTy));
619  Out << typeName << "_fields.push_back(" << fieldName;
620  Out << ");";
621  nl(Out);
622  }
623 
624  if (ST->isLiteral()) {
625  Out << "StructType *" << typeName << " = ";
626  Out << "StructType::get(" << "mod->getContext(), ";
627  } else {
628  Out << "if (" << typeName << "->isOpaque()) {";
629  nl(Out);
630  Out << typeName << "->setBody(";
631  }
632 
633  Out << typeName << "_fields, /*isPacked=*/"
634  << (ST->isPacked() ? "true" : "false") << ");";
635  nl(Out);
636  if (!ST->isLiteral()) {
637  Out << "}";
638  nl(Out);
639  }
640  break;
641  }
642  case Type::ArrayTyID: {
643  ArrayType* AT = cast<ArrayType>(Ty);
644  Type* ET = AT->getElementType();
645  printType(ET);
646  if (DefinedTypes.find(Ty) == DefinedTypes.end()) {
647  std::string elemName(getCppName(ET));
648  Out << "ArrayType* " << typeName << " = ArrayType::get("
649  << elemName << ", " << AT->getNumElements() << ");";
650  nl(Out);
651  }
652  break;
653  }
654  case Type::PointerTyID: {
655  PointerType* PT = cast<PointerType>(Ty);
656  Type* ET = PT->getElementType();
657  printType(ET);
658  if (DefinedTypes.find(Ty) == DefinedTypes.end()) {
659  std::string elemName(getCppName(ET));
660  Out << "PointerType* " << typeName << " = PointerType::get("
661  << elemName << ", " << PT->getAddressSpace() << ");";
662  nl(Out);
663  }
664  break;
665  }
666  case Type::VectorTyID: {
667  VectorType* PT = cast<VectorType>(Ty);
668  Type* ET = PT->getElementType();
669  printType(ET);
670  if (DefinedTypes.find(Ty) == DefinedTypes.end()) {
671  std::string elemName(getCppName(ET));
672  Out << "VectorType* " << typeName << " = VectorType::get("
673  << elemName << ", " << PT->getNumElements() << ");";
674  nl(Out);
675  }
676  break;
677  }
678  default:
679  error("Invalid TypeID");
680  }
681 
682  // Indicate that this type is now defined.
683  DefinedTypes.insert(Ty);
684 
685  // Finally, separate the type definition from other with a newline.
686  nl(Out);
687 }
688 
689 void CppWriter::printTypes(const Module* M) {
690  // Add all of the global variables to the value table.
691  for (Module::const_global_iterator I = TheModule->global_begin(),
692  E = TheModule->global_end(); I != E; ++I) {
693  if (I->hasInitializer())
694  printType(I->getInitializer()->getType());
695  printType(I->getType());
696  }
697 
698  // Add all the functions to the table
699  for (Module::const_iterator FI = TheModule->begin(), FE = TheModule->end();
700  FI != FE; ++FI) {
701  printType(FI->getReturnType());
702  printType(FI->getFunctionType());
703  // Add all the function arguments
704  for (Function::const_arg_iterator AI = FI->arg_begin(),
705  AE = FI->arg_end(); AI != AE; ++AI) {
706  printType(AI->getType());
707  }
708 
709  // Add all of the basic blocks and instructions
710  for (Function::const_iterator BB = FI->begin(),
711  E = FI->end(); BB != E; ++BB) {
712  printType(BB->getType());
713  for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I!=E;
714  ++I) {
715  printType(I->getType());
716  for (unsigned i = 0; i < I->getNumOperands(); ++i)
717  printType(I->getOperand(i)->getType());
718  }
719  }
720  }
721 }
722 
723 
724 // printConstant - Print out a constant pool entry...
725 void CppWriter::printConstant(const Constant *CV) {
726  // First, if the constant is actually a GlobalValue (variable or function)
727  // or its already in the constant list then we've printed it already and we
728  // can just return.
729  if (isa<GlobalValue>(CV) || ValueNames.find(CV) != ValueNames.end())
730  return;
731 
732  std::string constName(getCppName(CV));
733  std::string typeName(getCppName(CV->getType()));
734 
735  if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) {
736  std::string constValue = CI->getValue().toString(10, true);
737  Out << "ConstantInt* " << constName
738  << " = ConstantInt::get(mod->getContext(), APInt("
739  << cast<IntegerType>(CI->getType())->getBitWidth()
740  << ", StringRef(\"" << constValue << "\"), 10));";
741  } else if (isa<ConstantAggregateZero>(CV)) {
742  Out << "ConstantAggregateZero* " << constName
743  << " = ConstantAggregateZero::get(" << typeName << ");";
744  } else if (isa<ConstantPointerNull>(CV)) {
745  Out << "ConstantPointerNull* " << constName
746  << " = ConstantPointerNull::get(" << typeName << ");";
747  } else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV)) {
748  Out << "ConstantFP* " << constName << " = ";
749  printCFP(CFP);
750  Out << ";";
751  } else if (const ConstantArray *CA = dyn_cast<ConstantArray>(CV)) {
752  Out << "std::vector<Constant*> " << constName << "_elems;";
753  nl(Out);
754  unsigned N = CA->getNumOperands();
755  for (unsigned i = 0; i < N; ++i) {
756  printConstant(CA->getOperand(i)); // recurse to print operands
757  Out << constName << "_elems.push_back("
758  << getCppName(CA->getOperand(i)) << ");";
759  nl(Out);
760  }
761  Out << "Constant* " << constName << " = ConstantArray::get("
762  << typeName << ", " << constName << "_elems);";
763  } else if (const ConstantStruct *CS = dyn_cast<ConstantStruct>(CV)) {
764  Out << "std::vector<Constant*> " << constName << "_fields;";
765  nl(Out);
766  unsigned N = CS->getNumOperands();
767  for (unsigned i = 0; i < N; i++) {
768  printConstant(CS->getOperand(i));
769  Out << constName << "_fields.push_back("
770  << getCppName(CS->getOperand(i)) << ");";
771  nl(Out);
772  }
773  Out << "Constant* " << constName << " = ConstantStruct::get("
774  << typeName << ", " << constName << "_fields);";
775  } else if (const ConstantVector *CVec = dyn_cast<ConstantVector>(CV)) {
776  Out << "std::vector<Constant*> " << constName << "_elems;";
777  nl(Out);
778  unsigned N = CVec->getNumOperands();
779  for (unsigned i = 0; i < N; ++i) {
780  printConstant(CVec->getOperand(i));
781  Out << constName << "_elems.push_back("
782  << getCppName(CVec->getOperand(i)) << ");";
783  nl(Out);
784  }
785  Out << "Constant* " << constName << " = ConstantVector::get("
786  << typeName << ", " << constName << "_elems);";
787  } else if (isa<UndefValue>(CV)) {
788  Out << "UndefValue* " << constName << " = UndefValue::get("
789  << typeName << ");";
790  } else if (const ConstantDataSequential *CDS =
791  dyn_cast<ConstantDataSequential>(CV)) {
792  if (CDS->isString()) {
793  Out << "Constant *" << constName <<
794  " = ConstantDataArray::getString(mod->getContext(), \"";
795  StringRef Str = CDS->getAsString();
796  bool nullTerminate = false;
797  if (Str.back() == 0) {
798  Str = Str.drop_back();
799  nullTerminate = true;
800  }
801  printEscapedString(Str);
802  // Determine if we want null termination or not.
803  if (nullTerminate)
804  Out << "\", true);";
805  else
806  Out << "\", false);";// No null terminator
807  } else {
808  // TODO: Could generate more efficient code generating CDS calls instead.
809  Out << "std::vector<Constant*> " << constName << "_elems;";
810  nl(Out);
811  for (unsigned i = 0; i != CDS->getNumElements(); ++i) {
812  Constant *Elt = CDS->getElementAsConstant(i);
813  printConstant(Elt);
814  Out << constName << "_elems.push_back(" << getCppName(Elt) << ");";
815  nl(Out);
816  }
817  Out << "Constant* " << constName;
818 
819  if (isa<ArrayType>(CDS->getType()))
820  Out << " = ConstantArray::get(";
821  else
822  Out << " = ConstantVector::get(";
823  Out << typeName << ", " << constName << "_elems);";
824  }
825  } else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) {
826  if (CE->getOpcode() == Instruction::GetElementPtr) {
827  Out << "std::vector<Constant*> " << constName << "_indices;";
828  nl(Out);
829  printConstant(CE->getOperand(0));
830  for (unsigned i = 1; i < CE->getNumOperands(); ++i ) {
831  printConstant(CE->getOperand(i));
832  Out << constName << "_indices.push_back("
833  << getCppName(CE->getOperand(i)) << ");";
834  nl(Out);
835  }
836  Out << "Constant* " << constName
837  << " = ConstantExpr::getGetElementPtr("
838  << getCppName(CE->getOperand(0)) << ", "
839  << constName << "_indices);";
840  } else if (CE->isCast()) {
841  printConstant(CE->getOperand(0));
842  Out << "Constant* " << constName << " = ConstantExpr::getCast(";
843  switch (CE->getOpcode()) {
844  default: llvm_unreachable("Invalid cast opcode");
845  case Instruction::Trunc: Out << "Instruction::Trunc"; break;
846  case Instruction::ZExt: Out << "Instruction::ZExt"; break;
847  case Instruction::SExt: Out << "Instruction::SExt"; break;
848  case Instruction::FPTrunc: Out << "Instruction::FPTrunc"; break;
849  case Instruction::FPExt: Out << "Instruction::FPExt"; break;
850  case Instruction::FPToUI: Out << "Instruction::FPToUI"; break;
851  case Instruction::FPToSI: Out << "Instruction::FPToSI"; break;
852  case Instruction::UIToFP: Out << "Instruction::UIToFP"; break;
853  case Instruction::SIToFP: Out << "Instruction::SIToFP"; break;
854  case Instruction::PtrToInt: Out << "Instruction::PtrToInt"; break;
855  case Instruction::IntToPtr: Out << "Instruction::IntToPtr"; break;
856  case Instruction::BitCast: Out << "Instruction::BitCast"; break;
857  }
858  Out << ", " << getCppName(CE->getOperand(0)) << ", "
859  << getCppName(CE->getType()) << ");";
860  } else {
861  unsigned N = CE->getNumOperands();
862  for (unsigned i = 0; i < N; ++i ) {
863  printConstant(CE->getOperand(i));
864  }
865  Out << "Constant* " << constName << " = ConstantExpr::";
866  switch (CE->getOpcode()) {
867  case Instruction::Add: Out << "getAdd("; break;
868  case Instruction::FAdd: Out << "getFAdd("; break;
869  case Instruction::Sub: Out << "getSub("; break;
870  case Instruction::FSub: Out << "getFSub("; break;
871  case Instruction::Mul: Out << "getMul("; break;
872  case Instruction::FMul: Out << "getFMul("; break;
873  case Instruction::UDiv: Out << "getUDiv("; break;
874  case Instruction::SDiv: Out << "getSDiv("; break;
875  case Instruction::FDiv: Out << "getFDiv("; break;
876  case Instruction::URem: Out << "getURem("; break;
877  case Instruction::SRem: Out << "getSRem("; break;
878  case Instruction::FRem: Out << "getFRem("; break;
879  case Instruction::And: Out << "getAnd("; break;
880  case Instruction::Or: Out << "getOr("; break;
881  case Instruction::Xor: Out << "getXor("; break;
882  case Instruction::ICmp:
883  Out << "getICmp(ICmpInst::ICMP_";
884  switch (CE->getPredicate()) {
885  case ICmpInst::ICMP_EQ: Out << "EQ"; break;
886  case ICmpInst::ICMP_NE: Out << "NE"; break;
887  case ICmpInst::ICMP_SLT: Out << "SLT"; break;
888  case ICmpInst::ICMP_ULT: Out << "ULT"; break;
889  case ICmpInst::ICMP_SGT: Out << "SGT"; break;
890  case ICmpInst::ICMP_UGT: Out << "UGT"; break;
891  case ICmpInst::ICMP_SLE: Out << "SLE"; break;
892  case ICmpInst::ICMP_ULE: Out << "ULE"; break;
893  case ICmpInst::ICMP_SGE: Out << "SGE"; break;
894  case ICmpInst::ICMP_UGE: Out << "UGE"; break;
895  default: error("Invalid ICmp Predicate");
896  }
897  break;
898  case Instruction::FCmp:
899  Out << "getFCmp(FCmpInst::FCMP_";
900  switch (CE->getPredicate()) {
901  case FCmpInst::FCMP_FALSE: Out << "FALSE"; break;
902  case FCmpInst::FCMP_ORD: Out << "ORD"; break;
903  case FCmpInst::FCMP_UNO: Out << "UNO"; break;
904  case FCmpInst::FCMP_OEQ: Out << "OEQ"; break;
905  case FCmpInst::FCMP_UEQ: Out << "UEQ"; break;
906  case FCmpInst::FCMP_ONE: Out << "ONE"; break;
907  case FCmpInst::FCMP_UNE: Out << "UNE"; break;
908  case FCmpInst::FCMP_OLT: Out << "OLT"; break;
909  case FCmpInst::FCMP_ULT: Out << "ULT"; break;
910  case FCmpInst::FCMP_OGT: Out << "OGT"; break;
911  case FCmpInst::FCMP_UGT: Out << "UGT"; break;
912  case FCmpInst::FCMP_OLE: Out << "OLE"; break;
913  case FCmpInst::FCMP_ULE: Out << "ULE"; break;
914  case FCmpInst::FCMP_OGE: Out << "OGE"; break;
915  case FCmpInst::FCMP_UGE: Out << "UGE"; break;
916  case FCmpInst::FCMP_TRUE: Out << "TRUE"; break;
917  default: error("Invalid FCmp Predicate");
918  }
919  break;
920  case Instruction::Shl: Out << "getShl("; break;
921  case Instruction::LShr: Out << "getLShr("; break;
922  case Instruction::AShr: Out << "getAShr("; break;
923  case Instruction::Select: Out << "getSelect("; break;
924  case Instruction::ExtractElement: Out << "getExtractElement("; break;
925  case Instruction::InsertElement: Out << "getInsertElement("; break;
926  case Instruction::ShuffleVector: Out << "getShuffleVector("; break;
927  default:
928  error("Invalid constant expression");
929  break;
930  }
931  Out << getCppName(CE->getOperand(0));
932  for (unsigned i = 1; i < CE->getNumOperands(); ++i)
933  Out << ", " << getCppName(CE->getOperand(i));
934  Out << ");";
935  }
936  } else if (const BlockAddress *BA = dyn_cast<BlockAddress>(CV)) {
937  Out << "Constant* " << constName << " = ";
938  Out << "BlockAddress::get(" << getOpName(BA->getBasicBlock()) << ");";
939  } else {
940  error("Bad Constant");
941  Out << "Constant* " << constName << " = 0; ";
942  }
943  nl(Out);
944 }
945 
946 void CppWriter::printConstants(const Module* M) {
947  // Traverse all the global variables looking for constant initializers
948  for (Module::const_global_iterator I = TheModule->global_begin(),
949  E = TheModule->global_end(); I != E; ++I)
950  if (I->hasInitializer())
951  printConstant(I->getInitializer());
952 
953  // Traverse the LLVM functions looking for constants
954  for (Module::const_iterator FI = TheModule->begin(), FE = TheModule->end();
955  FI != FE; ++FI) {
956  // Add all of the basic blocks and instructions
957  for (Function::const_iterator BB = FI->begin(),
958  E = FI->end(); BB != E; ++BB) {
959  for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I!=E;
960  ++I) {
961  for (unsigned i = 0; i < I->getNumOperands(); ++i) {
962  if (Constant* C = dyn_cast<Constant>(I->getOperand(i))) {
963  printConstant(C);
964  }
965  }
966  }
967  }
968  }
969 }
970 
971 void CppWriter::printVariableUses(const GlobalVariable *GV) {
972  nl(Out) << "// Type Definitions";
973  nl(Out);
974  printType(GV->getType());
975  if (GV->hasInitializer()) {
976  const Constant *Init = GV->getInitializer();
977  printType(Init->getType());
978  if (const Function *F = dyn_cast<Function>(Init)) {
979  nl(Out)<< "/ Function Declarations"; nl(Out);
980  printFunctionHead(F);
981  } else if (const GlobalVariable* gv = dyn_cast<GlobalVariable>(Init)) {
982  nl(Out) << "// Global Variable Declarations"; nl(Out);
983  printVariableHead(gv);
984 
985  nl(Out) << "// Global Variable Definitions"; nl(Out);
986  printVariableBody(gv);
987  } else {
988  nl(Out) << "// Constant Definitions"; nl(Out);
989  printConstant(Init);
990  }
991  }
992 }
993 
994 void CppWriter::printVariableHead(const GlobalVariable *GV) {
995  nl(Out) << "GlobalVariable* " << getCppName(GV);
996  if (is_inline) {
997  Out << " = mod->getGlobalVariable(mod->getContext(), ";
998  printEscapedString(GV->getName());
999  Out << ", " << getCppName(GV->getType()->getElementType()) << ",true)";
1000  nl(Out) << "if (!" << getCppName(GV) << ") {";
1001  in(); nl(Out) << getCppName(GV);
1002  }
1003  Out << " = new GlobalVariable(/*Module=*/*mod, ";
1004  nl(Out) << "/*Type=*/";
1005  printCppName(GV->getType()->getElementType());
1006  Out << ",";
1007  nl(Out) << "/*isConstant=*/" << (GV->isConstant()?"true":"false");
1008  Out << ",";
1009  nl(Out) << "/*Linkage=*/";
1010  printLinkageType(GV->getLinkage());
1011  Out << ",";
1012  nl(Out) << "/*Initializer=*/0, ";
1013  if (GV->hasInitializer()) {
1014  Out << "// has initializer, specified below";
1015  }
1016  nl(Out) << "/*Name=*/\"";
1017  printEscapedString(GV->getName());
1018  Out << "\");";
1019  nl(Out);
1020 
1021  if (GV->hasSection()) {
1022  printCppName(GV);
1023  Out << "->setSection(\"";
1024  printEscapedString(GV->getSection());
1025  Out << "\");";
1026  nl(Out);
1027  }
1028  if (GV->getAlignment()) {
1029  printCppName(GV);
1030  Out << "->setAlignment(" << GV->getAlignment() << ");";
1031  nl(Out);
1032  }
1034  printCppName(GV);
1035  Out << "->setVisibility(";
1036  printVisibilityType(GV->getVisibility());
1037  Out << ");";
1038  nl(Out);
1039  }
1041  printCppName(GV);
1042  Out << "->setDLLStorageClass(";
1043  printDLLStorageClassType(GV->getDLLStorageClass());
1044  Out << ");";
1045  nl(Out);
1046  }
1047  if (GV->isThreadLocal()) {
1048  printCppName(GV);
1049  Out << "->setThreadLocalMode(";
1050  printThreadLocalMode(GV->getThreadLocalMode());
1051  Out << ");";
1052  nl(Out);
1053  }
1054  if (is_inline) {
1055  out(); Out << "}"; nl(Out);
1056  }
1057 }
1058 
1059 void CppWriter::printVariableBody(const GlobalVariable *GV) {
1060  if (GV->hasInitializer()) {
1061  printCppName(GV);
1062  Out << "->setInitializer(";
1063  Out << getCppName(GV->getInitializer()) << ");";
1064  nl(Out);
1065  }
1066 }
1067 
1068 std::string CppWriter::getOpName(const Value* V) {
1069  if (!isa<Instruction>(V) || DefinedValues.find(V) != DefinedValues.end())
1070  return getCppName(V);
1071 
1072  // See if its alread in the map of forward references, if so just return the
1073  // name we already set up for it
1074  ForwardRefMap::const_iterator I = ForwardRefs.find(V);
1075  if (I != ForwardRefs.end())
1076  return I->second;
1077 
1078  // This is a new forward reference. Generate a unique name for it
1079  std::string result(std::string("fwdref_") + utostr(uniqueNum++));
1080 
1081  // Yes, this is a hack. An Argument is the smallest instantiable value that
1082  // we can make as a placeholder for the real value. We'll replace these
1083  // Argument instances later.
1084  Out << "Argument* " << result << " = new Argument("
1085  << getCppName(V->getType()) << ");";
1086  nl(Out);
1087  ForwardRefs[V] = result;
1088  return result;
1089 }
1090 
1092  switch (Ordering) {
1093  case NotAtomic: return "NotAtomic";
1094  case Unordered: return "Unordered";
1095  case Monotonic: return "Monotonic";
1096  case Acquire: return "Acquire";
1097  case Release: return "Release";
1098  case AcquireRelease: return "AcquireRelease";
1099  case SequentiallyConsistent: return "SequentiallyConsistent";
1100  }
1101  llvm_unreachable("Unknown ordering");
1102 }
1103 
1105  switch (SynchScope) {
1106  case SingleThread: return "SingleThread";
1107  case CrossThread: return "CrossThread";
1108  }
1109  llvm_unreachable("Unknown synch scope");
1110 }
1111 
1112 // printInstruction - This member is called for each Instruction in a function.
1113 void CppWriter::printInstruction(const Instruction *I,
1114  const std::string& bbname) {
1115  std::string iName(getCppName(I));
1116 
1117  // Before we emit this instruction, we need to take care of generating any
1118  // forward references. So, we get the names of all the operands in advance
1119  const unsigned Ops(I->getNumOperands());
1120  std::string* opNames = new std::string[Ops];
1121  for (unsigned i = 0; i < Ops; i++)
1122  opNames[i] = getOpName(I->getOperand(i));
1123 
1124  switch (I->getOpcode()) {
1125  default:
1126  error("Invalid instruction");
1127  break;
1128 
1129  case Instruction::Ret: {
1130  const ReturnInst* ret = cast<ReturnInst>(I);
1131  Out << "ReturnInst::Create(mod->getContext(), "
1132  << (ret->getReturnValue() ? opNames[0] + ", " : "") << bbname << ");";
1133  break;
1134  }
1135  case Instruction::Br: {
1136  const BranchInst* br = cast<BranchInst>(I);
1137  Out << "BranchInst::Create(" ;
1138  if (br->getNumOperands() == 3) {
1139  Out << opNames[2] << ", "
1140  << opNames[1] << ", "
1141  << opNames[0] << ", ";
1142 
1143  } else if (br->getNumOperands() == 1) {
1144  Out << opNames[0] << ", ";
1145  } else {
1146  error("Branch with 2 operands?");
1147  }
1148  Out << bbname << ");";
1149  break;
1150  }
1151  case Instruction::Switch: {
1152  const SwitchInst *SI = cast<SwitchInst>(I);
1153  Out << "SwitchInst* " << iName << " = SwitchInst::Create("
1154  << getOpName(SI->getCondition()) << ", "
1155  << getOpName(SI->getDefaultDest()) << ", "
1156  << SI->getNumCases() << ", " << bbname << ");";
1157  nl(Out);
1158  for (SwitchInst::ConstCaseIt i = SI->case_begin(), e = SI->case_end();
1159  i != e; ++i) {
1160  const ConstantInt* CaseVal = i.getCaseValue();
1161  const BasicBlock *BB = i.getCaseSuccessor();
1162  Out << iName << "->addCase("
1163  << getOpName(CaseVal) << ", "
1164  << getOpName(BB) << ");";
1165  nl(Out);
1166  }
1167  break;
1168  }
1169  case Instruction::IndirectBr: {
1170  const IndirectBrInst *IBI = cast<IndirectBrInst>(I);
1171  Out << "IndirectBrInst *" << iName << " = IndirectBrInst::Create("
1172  << opNames[0] << ", " << IBI->getNumDestinations() << ");";
1173  nl(Out);
1174  for (unsigned i = 1; i != IBI->getNumOperands(); ++i) {
1175  Out << iName << "->addDestination(" << opNames[i] << ");";
1176  nl(Out);
1177  }
1178  break;
1179  }
1180  case Instruction::Resume: {
1181  Out << "ResumeInst::Create(" << opNames[0] << ", " << bbname << ");";
1182  break;
1183  }
1184  case Instruction::Invoke: {
1185  const InvokeInst* inv = cast<InvokeInst>(I);
1186  Out << "std::vector<Value*> " << iName << "_params;";
1187  nl(Out);
1188  for (unsigned i = 0; i < inv->getNumArgOperands(); ++i) {
1189  Out << iName << "_params.push_back("
1190  << getOpName(inv->getArgOperand(i)) << ");";
1191  nl(Out);
1192  }
1193  // FIXME: This shouldn't use magic numbers -3, -2, and -1.
1194  Out << "InvokeInst *" << iName << " = InvokeInst::Create("
1195  << getOpName(inv->getCalledValue()) << ", "
1196  << getOpName(inv->getNormalDest()) << ", "
1197  << getOpName(inv->getUnwindDest()) << ", "
1198  << iName << "_params, \"";
1199  printEscapedString(inv->getName());
1200  Out << "\", " << bbname << ");";
1201  nl(Out) << iName << "->setCallingConv(";
1202  printCallingConv(inv->getCallingConv());
1203  Out << ");";
1204  printAttributes(inv->getAttributes(), iName);
1205  Out << iName << "->setAttributes(" << iName << "_PAL);";
1206  nl(Out);
1207  break;
1208  }
1209  case Instruction::Unreachable: {
1210  Out << "new UnreachableInst("
1211  << "mod->getContext(), "
1212  << bbname << ");";
1213  break;
1214  }
1215  case Instruction::Add:
1216  case Instruction::FAdd:
1217  case Instruction::Sub:
1218  case Instruction::FSub:
1219  case Instruction::Mul:
1220  case Instruction::FMul:
1221  case Instruction::UDiv:
1222  case Instruction::SDiv:
1223  case Instruction::FDiv:
1224  case Instruction::URem:
1225  case Instruction::SRem:
1226  case Instruction::FRem:
1227  case Instruction::And:
1228  case Instruction::Or:
1229  case Instruction::Xor:
1230  case Instruction::Shl:
1231  case Instruction::LShr:
1232  case Instruction::AShr:{
1233  Out << "BinaryOperator* " << iName << " = BinaryOperator::Create(";
1234  switch (I->getOpcode()) {
1235  case Instruction::Add: Out << "Instruction::Add"; break;
1236  case Instruction::FAdd: Out << "Instruction::FAdd"; break;
1237  case Instruction::Sub: Out << "Instruction::Sub"; break;
1238  case Instruction::FSub: Out << "Instruction::FSub"; break;
1239  case Instruction::Mul: Out << "Instruction::Mul"; break;
1240  case Instruction::FMul: Out << "Instruction::FMul"; break;
1241  case Instruction::UDiv:Out << "Instruction::UDiv"; break;
1242  case Instruction::SDiv:Out << "Instruction::SDiv"; break;
1243  case Instruction::FDiv:Out << "Instruction::FDiv"; break;
1244  case Instruction::URem:Out << "Instruction::URem"; break;
1245  case Instruction::SRem:Out << "Instruction::SRem"; break;
1246  case Instruction::FRem:Out << "Instruction::FRem"; break;
1247  case Instruction::And: Out << "Instruction::And"; break;
1248  case Instruction::Or: Out << "Instruction::Or"; break;
1249  case Instruction::Xor: Out << "Instruction::Xor"; break;
1250  case Instruction::Shl: Out << "Instruction::Shl"; break;
1251  case Instruction::LShr:Out << "Instruction::LShr"; break;
1252  case Instruction::AShr:Out << "Instruction::AShr"; break;
1253  default: Out << "Instruction::BadOpCode"; break;
1254  }
1255  Out << ", " << opNames[0] << ", " << opNames[1] << ", \"";
1256  printEscapedString(I->getName());
1257  Out << "\", " << bbname << ");";
1258  break;
1259  }
1260  case Instruction::FCmp: {
1261  Out << "FCmpInst* " << iName << " = new FCmpInst(*" << bbname << ", ";
1262  switch (cast<FCmpInst>(I)->getPredicate()) {
1263  case FCmpInst::FCMP_FALSE: Out << "FCmpInst::FCMP_FALSE"; break;
1264  case FCmpInst::FCMP_OEQ : Out << "FCmpInst::FCMP_OEQ"; break;
1265  case FCmpInst::FCMP_OGT : Out << "FCmpInst::FCMP_OGT"; break;
1266  case FCmpInst::FCMP_OGE : Out << "FCmpInst::FCMP_OGE"; break;
1267  case FCmpInst::FCMP_OLT : Out << "FCmpInst::FCMP_OLT"; break;
1268  case FCmpInst::FCMP_OLE : Out << "FCmpInst::FCMP_OLE"; break;
1269  case FCmpInst::FCMP_ONE : Out << "FCmpInst::FCMP_ONE"; break;
1270  case FCmpInst::FCMP_ORD : Out << "FCmpInst::FCMP_ORD"; break;
1271  case FCmpInst::FCMP_UNO : Out << "FCmpInst::FCMP_UNO"; break;
1272  case FCmpInst::FCMP_UEQ : Out << "FCmpInst::FCMP_UEQ"; break;
1273  case FCmpInst::FCMP_UGT : Out << "FCmpInst::FCMP_UGT"; break;
1274  case FCmpInst::FCMP_UGE : Out << "FCmpInst::FCMP_UGE"; break;
1275  case FCmpInst::FCMP_ULT : Out << "FCmpInst::FCMP_ULT"; break;
1276  case FCmpInst::FCMP_ULE : Out << "FCmpInst::FCMP_ULE"; break;
1277  case FCmpInst::FCMP_UNE : Out << "FCmpInst::FCMP_UNE"; break;
1278  case FCmpInst::FCMP_TRUE : Out << "FCmpInst::FCMP_TRUE"; break;
1279  default: Out << "FCmpInst::BAD_ICMP_PREDICATE"; break;
1280  }
1281  Out << ", " << opNames[0] << ", " << opNames[1] << ", \"";
1282  printEscapedString(I->getName());
1283  Out << "\");";
1284  break;
1285  }
1286  case Instruction::ICmp: {
1287  Out << "ICmpInst* " << iName << " = new ICmpInst(*" << bbname << ", ";
1288  switch (cast<ICmpInst>(I)->getPredicate()) {
1289  case ICmpInst::ICMP_EQ: Out << "ICmpInst::ICMP_EQ"; break;
1290  case ICmpInst::ICMP_NE: Out << "ICmpInst::ICMP_NE"; break;
1291  case ICmpInst::ICMP_ULE: Out << "ICmpInst::ICMP_ULE"; break;
1292  case ICmpInst::ICMP_SLE: Out << "ICmpInst::ICMP_SLE"; break;
1293  case ICmpInst::ICMP_UGE: Out << "ICmpInst::ICMP_UGE"; break;
1294  case ICmpInst::ICMP_SGE: Out << "ICmpInst::ICMP_SGE"; break;
1295  case ICmpInst::ICMP_ULT: Out << "ICmpInst::ICMP_ULT"; break;
1296  case ICmpInst::ICMP_SLT: Out << "ICmpInst::ICMP_SLT"; break;
1297  case ICmpInst::ICMP_UGT: Out << "ICmpInst::ICMP_UGT"; break;
1298  case ICmpInst::ICMP_SGT: Out << "ICmpInst::ICMP_SGT"; break;
1299  default: Out << "ICmpInst::BAD_ICMP_PREDICATE"; break;
1300  }
1301  Out << ", " << opNames[0] << ", " << opNames[1] << ", \"";
1302  printEscapedString(I->getName());
1303  Out << "\");";
1304  break;
1305  }
1306  case Instruction::Alloca: {
1307  const AllocaInst* allocaI = cast<AllocaInst>(I);
1308  Out << "AllocaInst* " << iName << " = new AllocaInst("
1309  << getCppName(allocaI->getAllocatedType()) << ", ";
1310  if (allocaI->isArrayAllocation())
1311  Out << opNames[0] << ", ";
1312  Out << "\"";
1313  printEscapedString(allocaI->getName());
1314  Out << "\", " << bbname << ");";
1315  if (allocaI->getAlignment())
1316  nl(Out) << iName << "->setAlignment("
1317  << allocaI->getAlignment() << ");";
1318  break;
1319  }
1320  case Instruction::Load: {
1321  const LoadInst* load = cast<LoadInst>(I);
1322  Out << "LoadInst* " << iName << " = new LoadInst("
1323  << opNames[0] << ", \"";
1324  printEscapedString(load->getName());
1325  Out << "\", " << (load->isVolatile() ? "true" : "false" )
1326  << ", " << bbname << ");";
1327  if (load->getAlignment())
1328  nl(Out) << iName << "->setAlignment("
1329  << load->getAlignment() << ");";
1330  if (load->isAtomic()) {
1331  StringRef Ordering = ConvertAtomicOrdering(load->getOrdering());
1333  nl(Out) << iName << "->setAtomic("
1334  << Ordering << ", " << CrossThread << ");";
1335  }
1336  break;
1337  }
1338  case Instruction::Store: {
1339  const StoreInst* store = cast<StoreInst>(I);
1340  Out << "StoreInst* " << iName << " = new StoreInst("
1341  << opNames[0] << ", "
1342  << opNames[1] << ", "
1343  << (store->isVolatile() ? "true" : "false")
1344  << ", " << bbname << ");";
1345  if (store->getAlignment())
1346  nl(Out) << iName << "->setAlignment("
1347  << store->getAlignment() << ");";
1348  if (store->isAtomic()) {
1349  StringRef Ordering = ConvertAtomicOrdering(store->getOrdering());
1351  nl(Out) << iName << "->setAtomic("
1352  << Ordering << ", " << CrossThread << ");";
1353  }
1354  break;
1355  }
1356  case Instruction::GetElementPtr: {
1357  const GetElementPtrInst* gep = cast<GetElementPtrInst>(I);
1358  if (gep->getNumOperands() <= 2) {
1359  Out << "GetElementPtrInst* " << iName << " = GetElementPtrInst::Create("
1360  << opNames[0];
1361  if (gep->getNumOperands() == 2)
1362  Out << ", " << opNames[1];
1363  } else {
1364  Out << "std::vector<Value*> " << iName << "_indices;";
1365  nl(Out);
1366  for (unsigned i = 1; i < gep->getNumOperands(); ++i ) {
1367  Out << iName << "_indices.push_back("
1368  << opNames[i] << ");";
1369  nl(Out);
1370  }
1371  Out << "Instruction* " << iName << " = GetElementPtrInst::Create("
1372  << opNames[0] << ", " << iName << "_indices";
1373  }
1374  Out << ", \"";
1375  printEscapedString(gep->getName());
1376  Out << "\", " << bbname << ");";
1377  break;
1378  }
1379  case Instruction::PHI: {
1380  const PHINode* phi = cast<PHINode>(I);
1381 
1382  Out << "PHINode* " << iName << " = PHINode::Create("
1383  << getCppName(phi->getType()) << ", "
1384  << phi->getNumIncomingValues() << ", \"";
1385  printEscapedString(phi->getName());
1386  Out << "\", " << bbname << ");";
1387  nl(Out);
1388  for (unsigned i = 0; i < phi->getNumIncomingValues(); ++i) {
1389  Out << iName << "->addIncoming("
1390  << opNames[PHINode::getOperandNumForIncomingValue(i)] << ", "
1391  << getOpName(phi->getIncomingBlock(i)) << ");";
1392  nl(Out);
1393  }
1394  break;
1395  }
1396  case Instruction::Trunc:
1397  case Instruction::ZExt:
1398  case Instruction::SExt:
1399  case Instruction::FPTrunc:
1400  case Instruction::FPExt:
1401  case Instruction::FPToUI:
1402  case Instruction::FPToSI:
1403  case Instruction::UIToFP:
1404  case Instruction::SIToFP:
1405  case Instruction::PtrToInt:
1406  case Instruction::IntToPtr:
1407  case Instruction::BitCast: {
1408  const CastInst* cst = cast<CastInst>(I);
1409  Out << "CastInst* " << iName << " = new ";
1410  switch (I->getOpcode()) {
1411  case Instruction::Trunc: Out << "TruncInst"; break;
1412  case Instruction::ZExt: Out << "ZExtInst"; break;
1413  case Instruction::SExt: Out << "SExtInst"; break;
1414  case Instruction::FPTrunc: Out << "FPTruncInst"; break;
1415  case Instruction::FPExt: Out << "FPExtInst"; break;
1416  case Instruction::FPToUI: Out << "FPToUIInst"; break;
1417  case Instruction::FPToSI: Out << "FPToSIInst"; break;
1418  case Instruction::UIToFP: Out << "UIToFPInst"; break;
1419  case Instruction::SIToFP: Out << "SIToFPInst"; break;
1420  case Instruction::PtrToInt: Out << "PtrToIntInst"; break;
1421  case Instruction::IntToPtr: Out << "IntToPtrInst"; break;
1422  case Instruction::BitCast: Out << "BitCastInst"; break;
1423  default: llvm_unreachable("Unreachable");
1424  }
1425  Out << "(" << opNames[0] << ", "
1426  << getCppName(cst->getType()) << ", \"";
1427  printEscapedString(cst->getName());
1428  Out << "\", " << bbname << ");";
1429  break;
1430  }
1431  case Instruction::Call: {
1432  const CallInst* call = cast<CallInst>(I);
1433  if (const InlineAsm* ila = dyn_cast<InlineAsm>(call->getCalledValue())) {
1434  Out << "InlineAsm* " << getCppName(ila) << " = InlineAsm::get("
1435  << getCppName(ila->getFunctionType()) << ", \""
1436  << ila->getAsmString() << "\", \""
1437  << ila->getConstraintString() << "\","
1438  << (ila->hasSideEffects() ? "true" : "false") << ");";
1439  nl(Out);
1440  }
1441  if (call->getNumArgOperands() > 1) {
1442  Out << "std::vector<Value*> " << iName << "_params;";
1443  nl(Out);
1444  for (unsigned i = 0; i < call->getNumArgOperands(); ++i) {
1445  Out << iName << "_params.push_back(" << opNames[i] << ");";
1446  nl(Out);
1447  }
1448  Out << "CallInst* " << iName << " = CallInst::Create("
1449  << opNames[call->getNumArgOperands()] << ", "
1450  << iName << "_params, \"";
1451  } else if (call->getNumArgOperands() == 1) {
1452  Out << "CallInst* " << iName << " = CallInst::Create("
1453  << opNames[call->getNumArgOperands()] << ", " << opNames[0] << ", \"";
1454  } else {
1455  Out << "CallInst* " << iName << " = CallInst::Create("
1456  << opNames[call->getNumArgOperands()] << ", \"";
1457  }
1458  printEscapedString(call->getName());
1459  Out << "\", " << bbname << ");";
1460  nl(Out) << iName << "->setCallingConv(";
1461  printCallingConv(call->getCallingConv());
1462  Out << ");";
1463  nl(Out) << iName << "->setTailCall("
1464  << (call->isTailCall() ? "true" : "false");
1465  Out << ");";
1466  nl(Out);
1467  printAttributes(call->getAttributes(), iName);
1468  Out << iName << "->setAttributes(" << iName << "_PAL);";
1469  nl(Out);
1470  break;
1471  }
1472  case Instruction::Select: {
1473  const SelectInst* sel = cast<SelectInst>(I);
1474  Out << "SelectInst* " << getCppName(sel) << " = SelectInst::Create(";
1475  Out << opNames[0] << ", " << opNames[1] << ", " << opNames[2] << ", \"";
1476  printEscapedString(sel->getName());
1477  Out << "\", " << bbname << ");";
1478  break;
1479  }
1480  case Instruction::UserOp1:
1481  /// FALL THROUGH
1482  case Instruction::UserOp2: {
1483  /// FIXME: What should be done here?
1484  break;
1485  }
1486  case Instruction::VAArg: {
1487  const VAArgInst* va = cast<VAArgInst>(I);
1488  Out << "VAArgInst* " << getCppName(va) << " = new VAArgInst("
1489  << opNames[0] << ", " << getCppName(va->getType()) << ", \"";
1490  printEscapedString(va->getName());
1491  Out << "\", " << bbname << ");";
1492  break;
1493  }
1495  const ExtractElementInst* eei = cast<ExtractElementInst>(I);
1496  Out << "ExtractElementInst* " << getCppName(eei)
1497  << " = new ExtractElementInst(" << opNames[0]
1498  << ", " << opNames[1] << ", \"";
1499  printEscapedString(eei->getName());
1500  Out << "\", " << bbname << ");";
1501  break;
1502  }
1503  case Instruction::InsertElement: {
1504  const InsertElementInst* iei = cast<InsertElementInst>(I);
1505  Out << "InsertElementInst* " << getCppName(iei)
1506  << " = InsertElementInst::Create(" << opNames[0]
1507  << ", " << opNames[1] << ", " << opNames[2] << ", \"";
1508  printEscapedString(iei->getName());
1509  Out << "\", " << bbname << ");";
1510  break;
1511  }
1512  case Instruction::ShuffleVector: {
1513  const ShuffleVectorInst* svi = cast<ShuffleVectorInst>(I);
1514  Out << "ShuffleVectorInst* " << getCppName(svi)
1515  << " = new ShuffleVectorInst(" << opNames[0]
1516  << ", " << opNames[1] << ", " << opNames[2] << ", \"";
1517  printEscapedString(svi->getName());
1518  Out << "\", " << bbname << ");";
1519  break;
1520  }
1521  case Instruction::ExtractValue: {
1522  const ExtractValueInst *evi = cast<ExtractValueInst>(I);
1523  Out << "std::vector<unsigned> " << iName << "_indices;";
1524  nl(Out);
1525  for (unsigned i = 0; i < evi->getNumIndices(); ++i) {
1526  Out << iName << "_indices.push_back("
1527  << evi->idx_begin()[i] << ");";
1528  nl(Out);
1529  }
1530  Out << "ExtractValueInst* " << getCppName(evi)
1531  << " = ExtractValueInst::Create(" << opNames[0]
1532  << ", "
1533  << iName << "_indices, \"";
1534  printEscapedString(evi->getName());
1535  Out << "\", " << bbname << ");";
1536  break;
1537  }
1538  case Instruction::InsertValue: {
1539  const InsertValueInst *ivi = cast<InsertValueInst>(I);
1540  Out << "std::vector<unsigned> " << iName << "_indices;";
1541  nl(Out);
1542  for (unsigned i = 0; i < ivi->getNumIndices(); ++i) {
1543  Out << iName << "_indices.push_back("
1544  << ivi->idx_begin()[i] << ");";
1545  nl(Out);
1546  }
1547  Out << "InsertValueInst* " << getCppName(ivi)
1548  << " = InsertValueInst::Create(" << opNames[0]
1549  << ", " << opNames[1] << ", "
1550  << iName << "_indices, \"";
1551  printEscapedString(ivi->getName());
1552  Out << "\", " << bbname << ");";
1553  break;
1554  }
1555  case Instruction::Fence: {
1556  const FenceInst *fi = cast<FenceInst>(I);
1557  StringRef Ordering = ConvertAtomicOrdering(fi->getOrdering());
1559  Out << "FenceInst* " << iName
1560  << " = new FenceInst(mod->getContext(), "
1561  << Ordering << ", " << CrossThread << ", " << bbname
1562  << ");";
1563  break;
1564  }
1565  case Instruction::AtomicCmpXchg: {
1566  const AtomicCmpXchgInst *cxi = cast<AtomicCmpXchgInst>(I);
1567  StringRef SuccessOrdering =
1569  StringRef FailureOrdering =
1571  StringRef CrossThread = ConvertAtomicSynchScope(cxi->getSynchScope());
1572  Out << "AtomicCmpXchgInst* " << iName
1573  << " = new AtomicCmpXchgInst("
1574  << opNames[0] << ", " << opNames[1] << ", " << opNames[2] << ", "
1575  << SuccessOrdering << ", " << FailureOrdering << ", "
1576  << CrossThread << ", " << bbname
1577  << ");";
1578  nl(Out) << iName << "->setName(\"";
1579  printEscapedString(cxi->getName());
1580  Out << "\");";
1581  nl(Out) << iName << "->setVolatile("
1582  << (cxi->isVolatile() ? "true" : "false") << ");";
1583  nl(Out) << iName << "->setWeak("
1584  << (cxi->isWeak() ? "true" : "false") << ");";
1585  break;
1586  }
1587  case Instruction::AtomicRMW: {
1588  const AtomicRMWInst *rmwi = cast<AtomicRMWInst>(I);
1589  StringRef Ordering = ConvertAtomicOrdering(rmwi->getOrdering());
1590  StringRef CrossThread = ConvertAtomicSynchScope(rmwi->getSynchScope());
1591  StringRef Operation;
1592  switch (rmwi->getOperation()) {
1593  case AtomicRMWInst::Xchg: Operation = "AtomicRMWInst::Xchg"; break;
1594  case AtomicRMWInst::Add: Operation = "AtomicRMWInst::Add"; break;
1595  case AtomicRMWInst::Sub: Operation = "AtomicRMWInst::Sub"; break;
1596  case AtomicRMWInst::And: Operation = "AtomicRMWInst::And"; break;
1597  case AtomicRMWInst::Nand: Operation = "AtomicRMWInst::Nand"; break;
1598  case AtomicRMWInst::Or: Operation = "AtomicRMWInst::Or"; break;
1599  case AtomicRMWInst::Xor: Operation = "AtomicRMWInst::Xor"; break;
1600  case AtomicRMWInst::Max: Operation = "AtomicRMWInst::Max"; break;
1601  case AtomicRMWInst::Min: Operation = "AtomicRMWInst::Min"; break;
1602  case AtomicRMWInst::UMax: Operation = "AtomicRMWInst::UMax"; break;
1603  case AtomicRMWInst::UMin: Operation = "AtomicRMWInst::UMin"; break;
1604  case AtomicRMWInst::BAD_BINOP: llvm_unreachable("Bad atomic operation");
1605  }
1606  Out << "AtomicRMWInst* " << iName
1607  << " = new AtomicRMWInst("
1608  << Operation << ", "
1609  << opNames[0] << ", " << opNames[1] << ", "
1610  << Ordering << ", " << CrossThread << ", " << bbname
1611  << ");";
1612  nl(Out) << iName << "->setName(\"";
1613  printEscapedString(rmwi->getName());
1614  Out << "\");";
1615  nl(Out) << iName << "->setVolatile("
1616  << (rmwi->isVolatile() ? "true" : "false") << ");";
1617  break;
1618  }
1619  case Instruction::LandingPad: {
1620  const LandingPadInst *lpi = cast<LandingPadInst>(I);
1621  Out << "LandingPadInst* " << iName << " = LandingPadInst::Create(";
1622  printCppName(lpi->getType());
1623  Out << ", " << opNames[0] << ", " << lpi->getNumClauses() << ", \"";
1624  printEscapedString(lpi->getName());
1625  Out << "\", " << bbname << ");";
1626  nl(Out) << iName << "->setCleanup("
1627  << (lpi->isCleanup() ? "true" : "false")
1628  << ");";
1629  for (unsigned i = 0, e = lpi->getNumClauses(); i != e; ++i)
1630  nl(Out) << iName << "->addClause(" << opNames[i+1] << ");";
1631  break;
1632  }
1633  }
1634  DefinedValues.insert(I);
1635  nl(Out);
1636  delete [] opNames;
1637 }
1638 
1639 // Print out the types, constants and declarations needed by one function
1640 void CppWriter::printFunctionUses(const Function* F) {
1641  nl(Out) << "// Type Definitions"; nl(Out);
1642  if (!is_inline) {
1643  // Print the function's return type
1644  printType(F->getReturnType());
1645 
1646  // Print the function's function type
1647  printType(F->getFunctionType());
1648 
1649  // Print the types of each of the function's arguments
1650  for (Function::const_arg_iterator AI = F->arg_begin(), AE = F->arg_end();
1651  AI != AE; ++AI) {
1652  printType(AI->getType());
1653  }
1654  }
1655 
1656  // Print type definitions for every type referenced by an instruction and
1657  // make a note of any global values or constants that are referenced
1660  for (Function::const_iterator BB = F->begin(), BE = F->end();
1661  BB != BE; ++BB){
1662  for (BasicBlock::const_iterator I = BB->begin(), E = BB->end();
1663  I != E; ++I) {
1664  // Print the type of the instruction itself
1665  printType(I->getType());
1666 
1667  // Print the type of each of the instruction's operands
1668  for (unsigned i = 0; i < I->getNumOperands(); ++i) {
1669  Value* operand = I->getOperand(i);
1670  printType(operand->getType());
1671 
1672  // If the operand references a GVal or Constant, make a note of it
1673  if (GlobalValue* GV = dyn_cast<GlobalValue>(operand)) {
1674  gvs.insert(GV);
1675  if (GenerationType != GenFunction)
1676  if (GlobalVariable *GVar = dyn_cast<GlobalVariable>(GV))
1677  if (GVar->hasInitializer())
1678  consts.insert(GVar->getInitializer());
1679  } else if (Constant* C = dyn_cast<Constant>(operand)) {
1680  consts.insert(C);
1681  for (Value* operand : C->operands()) {
1682  // If the operand references a GVal or Constant, make a note of it
1683  printType(operand->getType());
1684  if (GlobalValue* GV = dyn_cast<GlobalValue>(operand)) {
1685  gvs.insert(GV);
1686  if (GenerationType != GenFunction)
1687  if (GlobalVariable *GVar = dyn_cast<GlobalVariable>(GV))
1688  if (GVar->hasInitializer())
1689  consts.insert(GVar->getInitializer());
1690  }
1691  }
1692  }
1693  }
1694  }
1695  }
1696 
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);
1703  }
1704  }
1705 
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);
1711  }
1712 
1713  // Print the constants found
1714  nl(Out) << "// Constant Definitions"; nl(Out);
1715  for (const auto *C : consts) {
1716  printConstant(C);
1717  }
1718 
1719  // Process the global variables definitions now that all the constants have
1720  // been emitted. These definitions just couple the gvars with their constant
1721  // initializers.
1722  if (GenerationType != GenFunction) {
1723  nl(Out) << "// Global Variable Definitions"; nl(Out);
1724  for (auto *GV : gvs) {
1725  if (GlobalVariable *Var = dyn_cast<GlobalVariable>(GV))
1726  printVariableBody(Var);
1727  }
1728  }
1729 }
1730 
1731 void CppWriter::printFunctionHead(const Function* F) {
1732  nl(Out) << "Function* " << getCppName(F);
1733  Out << " = mod->getFunction(\"";
1734  printEscapedString(F->getName());
1735  Out << "\");";
1736  nl(Out) << "if (!" << getCppName(F) << ") {";
1737  nl(Out) << getCppName(F);
1738 
1739  Out<< " = Function::Create(";
1740  nl(Out,1) << "/*Type=*/" << getCppName(F->getFunctionType()) << ",";
1741  nl(Out) << "/*Linkage=*/";
1742  printLinkageType(F->getLinkage());
1743  Out << ",";
1744  nl(Out) << "/*Name=*/\"";
1745  printEscapedString(F->getName());
1746  Out << "\", mod); " << (F->isDeclaration()? "// (external, no body)" : "");
1747  nl(Out,-1);
1748  printCppName(F);
1749  Out << "->setCallingConv(";
1750  printCallingConv(F->getCallingConv());
1751  Out << ");";
1752  nl(Out);
1753  if (F->hasSection()) {
1754  printCppName(F);
1755  Out << "->setSection(\"" << F->getSection() << "\");";
1756  nl(Out);
1757  }
1758  if (F->getAlignment()) {
1759  printCppName(F);
1760  Out << "->setAlignment(" << F->getAlignment() << ");";
1761  nl(Out);
1762  }
1764  printCppName(F);
1765  Out << "->setVisibility(";
1766  printVisibilityType(F->getVisibility());
1767  Out << ");";
1768  nl(Out);
1769  }
1771  printCppName(F);
1772  Out << "->setDLLStorageClass(";
1773  printDLLStorageClassType(F->getDLLStorageClass());
1774  Out << ");";
1775  nl(Out);
1776  }
1777  if (F->hasGC()) {
1778  printCppName(F);
1779  Out << "->setGC(\"" << F->getGC() << "\");";
1780  nl(Out);
1781  }
1782  Out << "}";
1783  nl(Out);
1784  printAttributes(F->getAttributes(), getCppName(F));
1785  printCppName(F);
1786  Out << "->setAttributes(" << getCppName(F) << "_PAL);";
1787  nl(Out);
1788 }
1789 
1790 void CppWriter::printFunctionBody(const Function *F) {
1791  if (F->isDeclaration())
1792  return; // external functions have no bodies.
1793 
1794  // Clear the DefinedValues and ForwardRefs maps because we can't have
1795  // cross-function forward refs
1796  ForwardRefs.clear();
1797  DefinedValues.clear();
1798 
1799  // Create all the argument values
1800  if (!is_inline) {
1801  if (!F->arg_empty()) {
1802  Out << "Function::arg_iterator args = " << getCppName(F)
1803  << "->arg_begin();";
1804  nl(Out);
1805  }
1806  for (Function::const_arg_iterator AI = F->arg_begin(), AE = F->arg_end();
1807  AI != AE; ++AI) {
1808  Out << "Value* " << getCppName(AI) << " = args++;";
1809  nl(Out);
1810  if (AI->hasName()) {
1811  Out << getCppName(AI) << "->setName(\"";
1812  printEscapedString(AI->getName());
1813  Out << "\");";
1814  nl(Out);
1815  }
1816  }
1817  }
1818 
1819  // Create all the basic blocks
1820  nl(Out);
1821  for (Function::const_iterator BI = F->begin(), BE = F->end();
1822  BI != BE; ++BI) {
1823  std::string bbname(getCppName(BI));
1824  Out << "BasicBlock* " << bbname <<
1825  " = BasicBlock::Create(mod->getContext(), \"";
1826  if (BI->hasName())
1827  printEscapedString(BI->getName());
1828  Out << "\"," << getCppName(BI->getParent()) << ",0);";
1829  nl(Out);
1830  }
1831 
1832  // Output all of its basic blocks... for the function
1833  for (Function::const_iterator BI = F->begin(), BE = F->end();
1834  BI != BE; ++BI) {
1835  std::string bbname(getCppName(BI));
1836  nl(Out) << "// Block " << BI->getName() << " (" << bbname << ")";
1837  nl(Out);
1838 
1839  // Output all of the instructions in the basic block...
1840  for (BasicBlock::const_iterator I = BI->begin(), E = BI->end();
1841  I != E; ++I) {
1842  printInstruction(I,bbname);
1843  }
1844  }
1845 
1846  // Loop over the ForwardRefs and resolve them now that all instructions
1847  // are generated.
1848  if (!ForwardRefs.empty()) {
1849  nl(Out) << "// Resolve Forward References";
1850  nl(Out);
1851  }
1852 
1853  while (!ForwardRefs.empty()) {
1854  ForwardRefMap::iterator I = ForwardRefs.begin();
1855  Out << I->second << "->replaceAllUsesWith("
1856  << getCppName(I->first) << "); delete " << I->second << ";";
1857  nl(Out);
1858  ForwardRefs.erase(I);
1859  }
1860 }
1861 
1862 void CppWriter::printInline(const std::string& fname,
1863  const std::string& func) {
1864  const Function* F = TheModule->getFunction(func);
1865  if (!F) {
1866  error(std::string("Function '") + func + "' not found in input module");
1867  return;
1868  }
1869  if (F->isDeclaration()) {
1870  error(std::string("Function '") + func + "' is external!");
1871  return;
1872  }
1873  nl(Out) << "BasicBlock* " << fname << "(Module* mod, Function *"
1874  << getCppName(F);
1875  unsigned arg_count = 1;
1876  for (Function::const_arg_iterator AI = F->arg_begin(), AE = F->arg_end();
1877  AI != AE; ++AI) {
1878  Out << ", Value* arg_" << arg_count++;
1879  }
1880  Out << ") {";
1881  nl(Out);
1882  is_inline = true;
1883  printFunctionUses(F);
1884  printFunctionBody(F);
1885  is_inline = false;
1886  Out << "return " << getCppName(F->begin()) << ";";
1887  nl(Out) << "}";
1888  nl(Out);
1889 }
1890 
1891 void CppWriter::printModuleBody() {
1892  // Print out all the type definitions
1893  nl(Out) << "// Type Definitions"; nl(Out);
1894  printTypes(TheModule);
1895 
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();
1900  I != E; ++I)
1901  printFunctionHead(I);
1902 
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);
1909  }
1910 
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);
1916 
1917  // Process the global variables definitions now that all the constants have
1918  // been emitted. These definitions just couple the gvars with their constant
1919  // initializers.
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);
1924  }
1925 
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();
1929  I != E; ++I) {
1930  if (!I->isDeclaration()) {
1931  nl(Out) << "// Function: " << I->getName() << " (" << getCppName(I)
1932  << ")";
1933  nl(Out) << "{";
1934  nl(Out,1);
1935  printFunctionBody(I);
1936  nl(Out,-1) << "}";
1937  nl(Out);
1938  }
1939  }
1940 }
1941 
1942 void CppWriter::printProgram(const std::string& fname,
1943  const std::string& mName) {
1944  Out << "#include <llvm/Pass.h>\n";
1945 
1946  Out << "#include <llvm/ADT/SmallVector.h>\n";
1947  Out << "#include <llvm/Analysis/Verifier.h>\n";
1948  Out << "#include <llvm/IR/BasicBlock.h>\n";
1949  Out << "#include <llvm/IR/CallingConv.h>\n";
1950  Out << "#include <llvm/IR/Constants.h>\n";
1951  Out << "#include <llvm/IR/DerivedTypes.h>\n";
1952  Out << "#include <llvm/IR/Function.h>\n";
1953  Out << "#include <llvm/IR/GlobalVariable.h>\n";
1954  Out << "#include <llvm/IR/IRPrintingPasses.h>\n";
1955  Out << "#include <llvm/IR/InlineAsm.h>\n";
1956  Out << "#include <llvm/IR/Instructions.h>\n";
1957  Out << "#include <llvm/IR/LLVMContext.h>\n";
1958  Out << "#include <llvm/IR/LegacyPassManager.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";
1972  Out << "}\n\n";
1973  printModule(fname,mName);
1974 }
1975 
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->getDataLayoutStr()
1985  << "\");";
1986  }
1987  if (!TheModule->getTargetTriple().empty()) {
1988  nl(Out) << "mod->setTargetTriple(\"" << TheModule->getTargetTriple()
1989  << "\");";
1990  }
1991 
1992  if (!TheModule->getModuleInlineAsm().empty()) {
1993  nl(Out) << "mod->setModuleInlineAsm(\"";
1994  printEscapedString(TheModule->getModuleInlineAsm());
1995  Out << "\");";
1996  }
1997  nl(Out);
1998 
1999  printModuleBody();
2000  nl(Out) << "return mod;";
2001  nl(Out,-1) << "}";
2002  nl(Out);
2003 }
2004 
2005 void CppWriter::printContents(const std::string& fname,
2006  const std::string& mName) {
2007  Out << "\nModule* " << fname << "(Module *mod) {\n";
2008  Out << "\nmod->setModuleIdentifier(\"";
2009  printEscapedString(mName);
2010  Out << "\");\n";
2011  printModuleBody();
2012  Out << "\nreturn mod;\n";
2013  Out << "\n}\n";
2014 }
2015 
2016 void CppWriter::printFunction(const std::string& fname,
2017  const std::string& funcName) {
2018  const Function* F = TheModule->getFunction(funcName);
2019  if (!F) {
2020  error(std::string("Function '") + funcName + "' not found in input module");
2021  return;
2022  }
2023  Out << "\nFunction* " << fname << "(Module *mod) {\n";
2024  printFunctionUses(F);
2025  printFunctionHead(F);
2026  printFunctionBody(F);
2027  Out << "return " << getCppName(F) << ";\n";
2028  Out << "}\n";
2029 }
2030 
2031 void CppWriter::printFunctions() {
2032  const Module::FunctionListType &funcs = TheModule->getFunctionList();
2033  Module::const_iterator I = funcs.begin();
2034  Module::const_iterator IE = funcs.end();
2035 
2036  for (; I != IE; ++I) {
2037  const Function &func = *I;
2038  if (!func.isDeclaration()) {
2039  std::string name("define_");
2040  name += func.getName();
2041  printFunction(name, func.getName());
2042  }
2043  }
2044 }
2045 
2046 void CppWriter::printVariable(const std::string& fname,
2047  const std::string& varName) {
2048  const GlobalVariable* GV = TheModule->getNamedGlobal(varName);
2049 
2050  if (!GV) {
2051  error(std::string("Variable '") + varName + "' not found in input module");
2052  return;
2053  }
2054  Out << "\nGlobalVariable* " << fname << "(Module *mod) {\n";
2055  printVariableUses(GV);
2056  printVariableHead(GV);
2057  printVariableBody(GV);
2058  Out << "return " << getCppName(GV) << ";\n";
2059  Out << "}\n";
2060 }
2061 
2062 void CppWriter::printType(const std::string &fname,
2063  const std::string &typeName) {
2064  Type* Ty = TheModule->getTypeByName(typeName);
2065  if (!Ty) {
2066  error(std::string("Type '") + typeName + "' not found in input module");
2067  return;
2068  }
2069  Out << "\nType* " << fname << "(Module *mod) {\n";
2070  printType(Ty);
2071  Out << "return " << getCppName(Ty) << ";\n";
2072  Out << "}\n";
2073 }
2074 
2075 bool CppWriter::runOnModule(Module &M) {
2076  TheModule = &M;
2077 
2078  // Emit a header
2079  Out << "// Generated by llvm2cpp - DO NOT MODIFY!\n\n";
2080 
2081  // Get the name of the function we're supposed to generate
2082  std::string fname = FuncName.getValue();
2083 
2084  // Get the name of the thing we are to generate
2085  std::string tgtname = NameToGenerate.getValue();
2086  if (GenerationType == GenModule ||
2090  if (tgtname == "!bad!") {
2091  if (M.getModuleIdentifier() == "-")
2092  tgtname = "<stdin>";
2093  else
2094  tgtname = M.getModuleIdentifier();
2095  }
2096  } else if (tgtname == "!bad!")
2097  error("You must use the -for option with -gen-{function,variable,type}");
2098 
2099  switch (WhatToGenerate(GenerationType)) {
2100  case GenProgram:
2101  if (fname.empty())
2102  fname = "makeLLVMModule";
2103  printProgram(fname,tgtname);
2104  break;
2105  case GenModule:
2106  if (fname.empty())
2107  fname = "makeLLVMModule";
2108  printModule(fname,tgtname);
2109  break;
2110  case GenContents:
2111  if (fname.empty())
2112  fname = "makeLLVMModuleContents";
2113  printContents(fname,tgtname);
2114  break;
2115  case GenFunction:
2116  if (fname.empty())
2117  fname = "makeLLVMFunction";
2118  printFunction(fname,tgtname);
2119  break;
2120  case GenFunctions:
2121  printFunctions();
2122  break;
2123  case GenInline:
2124  if (fname.empty())
2125  fname = "makeLLVMInline";
2126  printInline(fname,tgtname);
2127  break;
2128  case GenVariable:
2129  if (fname.empty())
2130  fname = "makeLLVMVariable";
2131  printVariable(fname,tgtname);
2132  break;
2133  case GenType:
2134  if (fname.empty())
2135  fname = "makeLLVMType";
2136  printType(fname,tgtname);
2137  break;
2138  }
2139 
2140  return false;
2141 }
2142 
2143 char CppWriter::ID = 0;
2144 
2145 //===----------------------------------------------------------------------===//
2146 // External Interface declaration
2147 //===----------------------------------------------------------------------===//
2148 
2150  PassManagerBase &PM, raw_pwrite_stream &o, CodeGenFileType FileType,
2151  bool DisableVerify, AnalysisID StartBefore, AnalysisID StartAfter,
2153  if (FileType != TargetMachine::CGFT_AssemblyFile)
2154  return true;
2155  auto FOut = llvm::make_unique<formatted_raw_ostream>(o);
2156  PM.add(new CppWriter(std::move(FOut)));
2157  return false;
2158 }
static StringRef ConvertAtomicOrdering(AtomicOrdering Ordering)
static unsigned getBitWidth(Type *Ty, const DataLayout &DL)
Returns the bitwidth of the given scalar or pointer type (if unknown returns 0).
ReturnInst - Return a value (possibly void), from a function.
const Value * getCalledValue() const
getCalledValue - Get a pointer to the function that is invoked by this instruction.
ValuesClass< DataType > LLVM_END_WITH_NULL values(const char *Arg, DataType Val, const char *Desc,...)
Definition: CommandLine.h:536
7: Labels
Definition: Type.h:63
AtomicOrdering getFailureOrdering() const
Returns the ordering constraint on this cmpxchg.
Definition: Instructions.h:597
LinkageTypes getLinkage() const
Definition: GlobalValue.h:289
CaseIt case_end()
Returns a read/write iterator that points one past the last in the SwitchInst.
static Type * getDoubleTy(LLVMContext &C)
Definition: Type.cpp:229
ExtractValueInst - This instruction extracts a struct member or array element value from an aggregate...
Special purpose, only applies to global arrays.
Definition: GlobalValue.h:46
VisibilityTypes getVisibility() const
Definition: GlobalValue.h:139
*p = old <signed v ? old : v
Definition: Instructions.h:704
LLVM Argument representation.
Definition: Argument.h:35
uint64_t getZExtValue() const
Get zero extended value.
Definition: APInt.h:1327
Alignment of stack for function (3 bits) stored as log2 of alignment with +1 bias 0 means unaligned (...
Definition: Attributes.h:106
bool hasName() const
Definition: Value.h:228
bool isVolatile() const
isVolatile - Return true if this is a store to a volatile memory location.
Definition: Instructions.h:351
SynchronizationScope getSynchScope() const
Definition: Instructions.h:383
static const fltSemantics IEEEdouble
Definition: APFloat.h:133
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:114
2: 32-bit floating point type
Definition: Type.h:58
AtomicOrdering getSuccessOrdering() const
Returns the ordering constraint on this cmpxchg.
Definition: Instructions.h:592
FenceInst - an instruction for ordering other memory operations.
Definition: Instructions.h:445
iterator end()
Definition: Function.h:459
Same, but only replaced by something equivalent.
Definition: GlobalValue.h:45
AtomicCmpXchgInst - an instruction that atomically checks whether a specified value is in a memory lo...
Definition: Instructions.h:515
#define clEnumValEnd
Definition: CommandLine.h:498
formatted_raw_ostream - A raw_ostream that wraps another one and keeps track of line and column posit...
unsigned getNumOperands() const
Definition: User.h:138
Available for inspection, not emission.
Definition: GlobalValue.h:41
Type::subtype_iterator param_iterator
Definition: DerivedTypes.h:123
const char * getGC() const
Definition: Function.cpp:384
CallInst - This class represents a function call, abstracting a target machine's calling convention...
raw_ostream & indent(unsigned NumSpaces)
indent - Insert 'NumSpaces' spaces.
CaseIt case_begin()
Returns a read/write iterator that points to the first case in SwitchInst.
unsigned less or equal
Definition: InstrTypes.h:723
unsigned less than
Definition: InstrTypes.h:722
*p = old <unsigned v ? old : v
Definition: Instructions.h:708
0 1 0 0 True if ordered and less than
Definition: InstrTypes.h:703
Like Internal, but omit from symbol table.
Definition: GlobalValue.h:48
void LLVMInitializeCppBackendTarget()
Definition: CPPBackend.cpp:78
*p = old >unsigned v ? old : v
Definition: Instructions.h:706
ShuffleVectorInst - This instruction constructs a fixed permutation of two input vectors.
Externally visible function.
Definition: GlobalValue.h:40
1 1 1 0 True if unordered or not equal
Definition: InstrTypes.h:713
Type * getReturnType() const
Definition: Function.cpp:233
unsigned getNumIndices() const
arg_iterator arg_end()
Definition: Function.h:480
12: Structures
Definition: Type.h:71
The two locations do not alias at all.
Definition: AliasAnalysis.h:78
F(f)
4: 80-bit floating point type (X87)
Definition: Type.h:60
bool addPassesToEmitFile(PassManagerBase &PM, raw_pwrite_stream &Out, CodeGenFileType FileType, bool DisableVerify, AnalysisID StartBefore, AnalysisID StartAfter, AnalysisID StopAfter, MachineFunctionInitializer *MFInitializer) override
Add passes to the specified pass manager to get the specified file emitted.
unsigned getAddressSpace() const
Return the address space of the Pointer type.
Definition: DerivedTypes.h:472
LoadInst - an instruction for reading from memory.
Definition: Instructions.h:177
iterator begin()
Definition: ilist.h:359
AtomicRMWInst - an instruction that atomically reads a memory location, combines it with another valu...
Definition: Instructions.h:674
static std::string ftostr(const APFloat &V)
Definition: CPPBackend.cpp:205
StringRef drop_back(size_t N=1) const
Return a StringRef equal to 'this' but with the last N elements dropped.
Definition: StringRef.h:419
14: Pointers
Definition: Type.h:73
const Constant * getInitializer() const
getInitializer - Return the initializer for this global variable.
11: Functions
Definition: Type.h:70
*p = old >signed v ? old : v
Definition: Instructions.h:702
Tentative definitions.
Definition: GlobalValue.h:50
bool bitwiseIsEqual(const APFloat &) const
Bitwise comparison for equality (QNaNs compare equal, 0!=-0).
Definition: APFloat.cpp:771
LLVM_ATTRIBUTE_NORETURN void report_fatal_error(const char *reason, bool gen_crash_diag=true)
Reports a serious error, calling any installed error handler.
CallingConv::ID getCallingConv() const
getCallingConv()/setCallingConv(CC) - These method get and set the calling convention of this functio...
Definition: Function.h:172
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:188
element_iterator element_end() const
Definition: DerivedTypes.h:280
bool isArrayAllocation() const
isArrayAllocation - Return true if there is an allocation size parameter to the allocation instructio...
1 0 0 1 True if unordered or equal
Definition: InstrTypes.h:708
BlockAddress - The address of a basic block.
Definition: Constants.h:802
static unsigned getOperandNumForIncomingValue(unsigned i)
1 0 0 0 True if unordered: isnan(X) | isnan(Y)
Definition: InstrTypes.h:707
bool isPacked() const
Definition: DerivedTypes.h:242
SelectInst - This class represents the LLVM 'select' instruction.
Value * getReturnValue() const
Convenience accessor. Returns null if there is no return value.
Type::subtype_iterator element_iterator
Definition: DerivedTypes.h:278
static Type * getFloatTy(LLVMContext &C)
Definition: Type.cpp:228
This is the base class for all instructions that perform data casts.
Definition: InstrTypes.h:389
StructType - Class to represent struct types.
Definition: DerivedTypes.h:191
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:98
param_iterator param_end() const
Definition: DerivedTypes.h:125
unsigned getNumArgOperands() const
getNumArgOperands - Return the number of call arguments.
unsigned getNumIndices() const
const Value * getCalledValue() const
getCalledValue - Get a pointer to the function that is invoked by this instruction ...
bool isLiteral() const
isLiteral - Return true if this type is uniqued by structural equivalence, false if it is a struct de...
Definition: DerivedTypes.h:246
0 1 0 1 True if ordered and less than or equal
Definition: InstrTypes.h:704
SynchronizationScope
Definition: Instructions.h:49
Windows NT (Windows on ARM)
element_iterator element_begin() const
Definition: DerivedTypes.h:279
static ConstantInt * ExtractElement(Constant *V, Constant *Idx)
const std::string & getModuleIdentifier() const
Get the module identifier which is, essentially, the name of the module.
Definition: Module.h:242
#define false
Definition: ConvertUTF.c:65
SynchronizationScope getSynchScope() const
Definition: Instructions.h:261
AtomicOrdering
Definition: Instructions.h:38
static cl::opt< WhatToGenerate > GenerationType("cppgen", cl::Optional, cl::desc("Choose what kind of output to generate"), cl::init(GenProgram), cl::values(clEnumValN(GenProgram,"program","Generate a complete program"), clEnumValN(GenModule,"module","Generate a module definition"), clEnumValN(GenContents,"contents","Generate contents of a module"), clEnumValN(GenFunction,"function","Generate a function definition"), clEnumValN(GenFunctions,"functions","Generate all function definitions"), clEnumValN(GenInline,"inline","Generate an inline function"), clEnumValN(GenVariable,"variable","Generate a variable definition"), clEnumValN(GenType,"type","Generate a type definition"), clEnumValEnd))
static void sanitize(std::string &str)
Definition: CPPBackend.cpp:178
ConstantExpr - a constant value that is initialized with an expression using other constant values...
Definition: Constants.h:852
FunctionType - Class to represent function types.
Definition: DerivedTypes.h:96
bool isVolatile() const
isVolatile - Return true if this is a cmpxchg from a volatile memory location.
Definition: Instructions.h:544
AtomicOrdering getOrdering() const
Returns the ordering constraint on this RMW.
Definition: Instructions.h:769
ConstantDataSequential - A vector or array constant whose element type is a simple 1/2/4/8-byte integ...
Definition: Constants.h:557
unsigned getAlignment() const
Definition: GlobalObject.h:46
ArrayType - Class to represent array types.
Definition: DerivedTypes.h:336
static cl::opt< std::string > FuncName("cppfname", cl::desc("Specify the name of the generated function"), cl::value_desc("function name"))
VisibilityTypes
An enumeration for the kinds of visibility of global values.
Definition: GlobalValue.h:54
static std::string utostr(uint64_t X, bool isNeg=false)
Definition: StringExtras.h:93
double convertToDouble() const
Definition: APFloat.cpp:3116
TypeID getTypeID() const
getTypeID - Return the type id for the type.
Definition: Type.h:134
bool isFloatingPointTy() const
isFloatingPointTy - Return true if this is one of the six floating point types
Definition: Type.h:159
unsigned getNumClauses() const
getNumClauses - Get the number of clauses for this landing pad.
static std::error_code error(DiagnosticHandlerFunction DiagnosticHandler, std::error_code EC, const Twine &Message)
StoreInst - an instruction for storing to memory.
Definition: Instructions.h:316
WhatToGenerate
Definition: CPPBackend.cpp:47
unsigned getNumElements() const
Return the number of elements in the Vector type.
Definition: DerivedTypes.h:432
iterator begin()
Definition: Function.h:457
Type * getElementType() const
Definition: DerivedTypes.h:323
bool isAtomic() const
isAtomic - Return true if this instruction has an AtomicOrdering of unordered or higher.
BasicBlock * getNormalDest() const
PointerType - Class to represent pointers.
Definition: DerivedTypes.h:449
unsigned getNumIncomingValues() const
getNumIncomingValues - Return the number of incoming edges
static cl::opt< std::string > NameToGenerate("cppfor", cl::Optional, cl::desc("Specify the name of the thing to generate"), cl::init("!bad!"))
10: Arbitrary bit width integers
Definition: Type.h:69
bool hasSection() const
Definition: GlobalObject.h:56
ExternalWeak linkage description.
Definition: GlobalValue.h:49
GetElementPtrInst - an instruction for type-safe pointer arithmetic to access elements of arrays and ...
Definition: Instructions.h:830
A self-contained host- and target-independent arbitrary-precision floating-point software implementat...
Definition: APFloat.h:122
0: type with no size
Definition: Type.h:56
bool isX86_MMXTy() const
isX86_MMXTy - Return true if this is X86 MMX.
Definition: Type.h:179
Same, but only replaced by something equivalent.
Definition: GlobalValue.h:43
unsigned getNumSlots() const
Return the number of slots used in this attribute list.
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:325
InsertElementInst - This instruction inserts a single (scalar) element into a VectorType value...
LandingPadInst - The landingpad instruction holds all of the information necessary to generate correc...
unsigned getAlignment() const
getAlignment - Return the alignment of the access that is being performed
Definition: Instructions.h:365
* if(!EatIfPresent(lltok::kw_thread_local)) return false
ParseOptionalThreadLocal := /*empty.
SynchronizationScope getSynchScope() const
Returns whether this RMW is atomic between threads or only within a single thread.
Definition: Instructions.h:775
LLVM Basic Block Representation.
Definition: BasicBlock.h:65
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
BranchInst - Conditional or Unconditional Branch instruction.
AttributeSet getSlotAttributes(unsigned Slot) const
Return the attributes at the given slot.
This is an important base class in LLVM.
Definition: Constant.h:41
Target TheCppBackendTarget
This file contains the declarations for the subclasses of Constant, which represent the different fla...
param_iterator param_begin() const
Definition: DerivedTypes.h:124
char back() const
back - Get the last character in the string.
Definition: StringRef.h:122
IndirectBrInst - Indirect Branch Instruction.
APInt Or(const APInt &LHS, const APInt &RHS)
Bitwise OR function for APInt.
Definition: APInt.h:1895
unsigned getAlignment() const
getAlignment - Return the alignment of the memory that is being allocated by the instruction.
Definition: Instructions.h:130
ConstantFP - Floating Point Values [float, double].
Definition: Constants.h:233
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
Definition: SmallPtrSet.h:264
APInt Xor(const APInt &LHS, const APInt &RHS)
Bitwise XOR function for APInt.
Definition: APInt.h:1900
BasicBlock * getIncomingBlock(unsigned i) const
getIncomingBlock - Return incoming basic block number i.
uint64_t getNumElements() const
Definition: DerivedTypes.h:352
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang","erlang-compatible garbage collector")
opStatus convert(const fltSemantics &, roundingMode, bool *)
APFloat::convert - convert a value of one floating point type to another.
Definition: APFloat.cpp:1972
DLLStorageClassTypes
Storage classes of global values for PE targets.
Definition: GlobalValue.h:61
Value * getOperand(unsigned i) const
Definition: User.h:118
0 1 1 1 True if ordered (no nans)
Definition: InstrTypes.h:706
arg_iterator arg_begin()
Definition: Function.h:472
ConstantVector - Constant Vector Declarations.
Definition: Constants.h:461
bool isThreadLocal() const
If the value is "Thread Local", its value isn't shared by the threads.
Definition: GlobalValue.h:152
1 1 1 1 Always true (always folded)
Definition: InstrTypes.h:714
VAArgInst - This class represents the va_arg llvm instruction, which returns an argument of the speci...
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:519
1 1 0 1 True if unordered, less than, or equal
Definition: InstrTypes.h:712
signed greater than
Definition: InstrTypes.h:724
CallingConv::ID getCallingConv() const
getCallingConv/setCallingConv - Get or set the calling convention of this function call...
const char * getSection() const
Definition: GlobalObject.h:57
13: Arrays
Definition: Type.h:72
0 0 1 0 True if ordered and greater than
Definition: InstrTypes.h:701
idx_iterator idx_begin() const
BasicBlock * getUnwindDest() const
See the file comment.
Definition: ValueMap.h:80
AtomicOrdering getOrdering() const
Returns the ordering effect of this store.
Definition: Instructions.h:372
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements...
Definition: SmallPtrSet.h:299
This is the shared class of boolean and integer constants.
Definition: Constants.h:47
15: SIMD 'packed' format, or other vector type
Definition: Type.h:74
1 1 0 0 True if unordered or less than
Definition: InstrTypes.h:711
Keep one copy of function when linking (inline)
Definition: GlobalValue.h:42
Module.h This file contains the declarations for the Module class.
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:222
bool isVolatile() const
isVolatile - Return true if this is a load from a volatile memory location.
Definition: Instructions.h:232
signed less than
Definition: InstrTypes.h:726
AtomicOrdering getOrdering() const
Returns the ordering effect of this fence.
Definition: Instructions.h:250
BinOp getOperation() const
Definition: Instructions.h:726
AttributeSet getAttributes() const
Return the attribute list for this Function.
Definition: Function.h:181
SynchronizationScope getSynchScope() const
Definition: Instructions.h:480
signed less or equal
Definition: InstrTypes.h:727
bool arg_empty() const
Definition: Function.cpp:304
VectorType - Class to represent vector types.
Definition: DerivedTypes.h:362
bool hasInitializer() const
Definitions have initializers, declarations don't.
ConstantArray - Constant Array Declarations.
Definition: Constants.h:356
LinkageTypes
An enumeration for the kinds of linkage for global values.
Definition: GlobalValue.h:39
bool isConstant() const
If the value is a global constant, its value is immutable throughout the runtime execution of the pro...
bool isIntegerTy() const
isIntegerTy - True if this is an instance of IntegerType.
Definition: Type.h:193
StringRef getName() const
getName - Return the name for this struct type if it has an identity.
Definition: Type.cpp:583
APInt bitcastToAPInt() const
Definition: APFloat.cpp:3084
bool hasGC() const
hasGC/getGC/setGC/clearGC - The name of the garbage collection algorithm to use during code generatio...
Definition: Function.cpp:379
Value * getCondition() const
const AttributeSet & getAttributes() const
getAttributes - Return the parameter attributes for this call.
APInt And(const APInt &LHS, const APInt &RHS)
Bitwise AND function for APInt.
Definition: APInt.h:1890
#define clEnumValN(ENUMVAL, FLAGNAME, DESC)
Definition: CommandLine.h:497
ThreadLocalMode getThreadLocalMode() const
Definition: GlobalValue.h:160
Function to be accessible from DLL.
Definition: GlobalValue.h:64
PointerType * getType() const
Global values are always pointers.
Definition: GlobalValue.h:185
Value * getArgOperand(unsigned i) const
getArgOperand/setArgOperand - Return/set the i-th invoke argument.
static const fltSemantics IEEEsingle
Definition: APFloat.h:132
const AttributeSet & getAttributes() const
getAttributes - Return the parameter attributes for this invoke.
BasicBlock * getDefaultDest() const
AtomicOrdering getOrdering() const
Returns the ordering effect of this fence.
Definition: Instructions.h:469
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
Definition: Globals.cpp:128
unsigned getSlotIndex(unsigned Slot) const
Return the index for the given slot.
unsigned greater or equal
Definition: InstrTypes.h:721
unsigned getAlignment() const
getAlignment - Return the alignment of the access that is being performed
Definition: Instructions.h:243
#define I(x, y, z)
Definition: MD5.cpp:54
#define N
FunctionType * getFunctionType() const
Definition: Function.cpp:227
Fast - This calling convention attempts to make calls as fast as possible (e.g.
Definition: CallingConv.h:42
ModulePass class - This class is used to implement unstructured interprocedural optimizations and ana...
Definition: Pass.h:236
bool isTailCall() const
0 1 1 0 True if ordered and operands are unequal
Definition: InstrTypes.h:705
float convertToFloat() const
Definition: APFloat.cpp:3107
cl::opt< std::string > StopAfter("stop-after", cl::desc("Stop compilation after a specific pass"), cl::value_desc("pass-name"), cl::init(""))
cl::opt< std::string > StartAfter("start-after", cl::desc("Resume compilation after a specific pass"), cl::value_desc("pass-name"), cl::init(""))
ExtractElementInst - This instruction extracts a single (scalar) element from a VectorType value...
Keep one copy of named function when linking (weak)
Definition: GlobalValue.h:44
Rename collisions when linking (static functions).
Definition: GlobalValue.h:47
cl::opt< TargetMachine::CodeGenFileType > FileType("filetype", cl::init(TargetMachine::CGFT_AssemblyFile), cl::desc("Choose a file type (not all types are supported by all targets):"), cl::values(clEnumValN(TargetMachine::CGFT_AssemblyFile,"asm","Emit an assembly ('.s') file"), clEnumValN(TargetMachine::CGFT_ObjectFile,"obj","Emit a native object ('.o') file"), clEnumValN(TargetMachine::CGFT_Null,"null","Emit nothing, for performance testing"), clEnumValEnd))
static std::string getTypePrefix(Type *Ty)
Definition: CPPBackend.cpp:184
const void * AnalysisID
Definition: Pass.h:47
1 0 1 0 True if unordered or greater than
Definition: InstrTypes.h:709
unsigned getNumCases() const
getNumCases - return the number of 'cases' in this switch instruction, except the default case ...
Function to be imported from DLL.
Definition: GlobalValue.h:63
static std::string utohexstr(uint64_t X, bool LowerCase=false)
Definition: StringExtras.h:72
const APFloat & getValueAPF() const
Definition: Constants.h:270
bool isVarArg() const
Definition: DerivedTypes.h:120
An abstract base class for streams implementations that also support a pwrite operation.
Definition: raw_ostream.h:321
bool isExactlyValue(const APFloat &V) const
isExactlyValue - We don't rely on operator== working on double values, as it returns true for things ...
Definition: Constants.cpp:758
3: 64-bit floating point type
Definition: Type.h:59
SwitchInst - Multiway switch.
separate const offset from gep
bool isWeak() const
Return true if this cmpxchg may spuriously fail.
Definition: Instructions.h:556
Type * getReturnType() const
Definition: DerivedTypes.h:121
iterator end()
Definition: ilist.h:367
RegisterTargetMachine - Helper template for registering a target machine implementation, for use in the target machine initialization function.
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:465
bool isLabelTy() const
isLabelTy - Return true if this is 'label'.
Definition: Type.h:186
0 0 0 1 True if ordered and equal
Definition: InstrTypes.h:700
LLVM Value Representation.
Definition: Value.h:69
static const char * name
1 0 1 1 True if unordered, greater than, or equal
Definition: InstrTypes.h:710
unsigned getOpcode() const
getOpcode() returns a member of one of the enums like Instruction::Add.
Definition: Instruction.h:112
DLLStorageClassTypes getDLLStorageClass() const
Definition: GlobalValue.h:164
InvokeInst - Invoke instruction.
bool isCleanup() const
isCleanup - Return 'true' if this landingpad instruction is a cleanup.
C - The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
const HexagonInstrInfo bool ShouldCombineAggressively switch(MI->getOpcode())
unsigned greater than
Definition: InstrTypes.h:720
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:40
This interface provides a way to initialize machine functions after they are created by the machine f...
CallingConv::ID getCallingConv() const
getCallingConv/setCallingConv - Get or set the calling convention of this function call...
static StringRef ConvertAtomicSynchScope(SynchronizationScope SynchScope)
idx_iterator idx_begin() const
ArgumentListType::const_iterator const_arg_iterator
Definition: Function.h:63
#define HANDLE_ATTR(X)
9: MMX vectors (64 bits, X86 specific)
Definition: Type.h:65
CodeGenFileType
These enums are meant to be passed into addPassesToEmitFile to indicate what type of file to emit...
Type * getAllocatedType() const
getAllocatedType - Return the type that is being allocated by the instruction.
Definition: Instructions.h:122
0 0 1 1 True if ordered and greater than or equal
Definition: InstrTypes.h:702
SynchronizationScope getSynchScope() const
Returns whether this cmpxchg is atomic between threads or only within a single thread.
Definition: Instructions.h:603
unsigned getNumArgOperands() const
getNumArgOperands - Return the number of invoke arguments.
unsigned getNumDestinations() const
getNumDestinations - return the number of possible destinations in this indirectbr instruction...
bool isEmpty() const
Return true if there are no attributes.
Definition: Attributes.h:390
const fltSemantics & getSemantics() const
Definition: APFloat.h:435
TLM
Definition: LLParser.cpp:1199
0 0 0 0 Always false (always folded)
Definition: InstrTypes.h:699
signed greater or equal
Definition: InstrTypes.h:725
bool isVoidTy() const
isVoidTy - Return true if this is 'void'.
Definition: Type.h:137
AllocaInst - an instruction to allocate memory on the stack.
Definition: Instructions.h:76
InsertValueInst - This instruction inserts a struct field of array element value into an aggregate va...
bool isMetadataTy() const
isMetadataTy - Return true if this is 'metadata'.
Definition: Type.h:189
bool isVolatile() const
isVolatile - Return true if this is a RMW on a volatile memory location.
Definition: Instructions.h:738