//
//===----------------------------------------------------------------------===//
-#include "llvm/Assembly/CachedWriter.h"
#include "llvm/Assembly/Writer.h"
#include "llvm/Assembly/PrintModulePass.h"
#include "llvm/Assembly/AsmAnnotationWriter.h"
#include "llvm/CallingConv.h"
#include "llvm/Constants.h"
#include "llvm/DerivedTypes.h"
+#include "llvm/InlineAsm.h"
#include "llvm/Instruction.h"
#include "llvm/Instructions.h"
#include "llvm/Module.h"
#include "llvm/SymbolTable.h"
-#include "llvm/Assembly/Writer.h"
-#include "llvm/Support/CFG.h"
+#include "llvm/TypeSymbolTable.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/STLExtras.h"
+#include "llvm/Support/CFG.h"
+#include "llvm/Support/MathExtras.h"
+#include "llvm/Support/Streams.h"
#include <algorithm>
using namespace llvm;
/// @brief A mapping of Values to slot numbers
typedef std::map<const Value*, unsigned> ValueMap;
- typedef std::map<const Type*, unsigned> TypeMap;
/// @brief A plane with next slot number and ValueMap
struct ValuePlane {
ValuePlane() { next_slot = 0; } ///< Make sure we start at 0
};
- struct TypePlane {
- unsigned next_slot;
- TypeMap map;
- TypePlane() { next_slot = 0; }
- void clear() { map.clear(); next_slot = 0; }
- };
-
/// @brief The map of planes by Type
typedef std::map<const Type*, ValuePlane> TypedPlanes;
/// @{
public:
/// @brief Construct from a module
- SlotMachine(const Module *M );
+ SlotMachine(const Module *M);
/// @brief Construct from a function, starting out in incorp state.
- SlotMachine(const Function *F );
+ SlotMachine(const Function *F);
/// @}
/// @name Accessors
/// plane. Its an error to ask for something not in the SlotMachine.
/// Its an error to ask for a Type*
int getSlot(const Value *V);
- int getSlot(const Type*Ty);
-
- /// Determine if a Value has a slot or not
- bool hasSlot(const Value* V);
- bool hasSlot(const Type* Ty);
/// @}
/// @name Mutators
/// This function does the actual initialization.
inline void initialize();
- /// Values can be crammed into here at will. If they haven't
- /// been inserted already, they get inserted, otherwise they are ignored.
- /// Either way, the slot number for the Value* is returned.
- unsigned createSlot(const Value *V);
- unsigned createSlot(const Type* Ty);
-
- /// Insert a value into the value table. Return the slot number
- /// that it now occupies. BadThings(TM) will happen if you insert a
- /// Value that's already been inserted.
- unsigned insertValue( const Value *V );
- unsigned insertValue( const Type* Ty);
+ /// CreateModuleSlot - Insert the specified GlobalValue* into the slot table.
+ void CreateModuleSlot(const GlobalValue *V);
+
+ /// CreateFunctionSlot - Insert the specified Value* into the slot table.
+ void CreateFunctionSlot(const Value *V);
/// Add all of the module level global variables (and their initializers)
/// and function declarations, but not the contents of those functions.
/// @brief The TypePlanes map for the module level data
TypedPlanes mMap;
- TypePlane mTypes;
/// @brief The TypePlanes map for the function level data
TypedPlanes fMap;
- TypePlane fTypes;
/// @}
} // end namespace llvm
static RegisterPass<PrintModulePass>
-X("printm", "Print module to stderr",PassInfo::Analysis|PassInfo::Optimization);
+X("printm", "Print module to stderr");
static RegisterPass<PrintFunctionPass>
-Y("print","Print function to stderr",PassInfo::Analysis|PassInfo::Optimization);
+Y("print","Print function to stderr");
static void WriteAsOperandInternal(std::ostream &Out, const Value *V,
- bool PrintName,
- std::map<const Type *, std::string> &TypeTable,
- SlotMachine *Machine);
-
-static void WriteAsOperandInternal(std::ostream &Out, const Type *T,
- bool PrintName,
- std::map<const Type *, std::string> &TypeTable,
+ std::map<const Type *, std::string> &TypeTable,
SlotMachine *Machine);
static const Module *getModuleFromVal(const Value *V) {
static void fillTypeNameTable(const Module *M,
std::map<const Type *, std::string> &TypeNames) {
if (!M) return;
- const SymbolTable &ST = M->getSymbolTable();
- SymbolTable::type_const_iterator TI = ST.type_begin();
- for (; TI != ST.type_end(); ++TI ) {
+ const TypeSymbolTable &ST = M->getTypeSymbolTable();
+ TypeSymbolTable::const_iterator TI = ST.begin();
+ for (; TI != ST.end(); ++TI) {
// As a heuristic, don't insert pointer to primitive types, because
// they are used too often to have a single useful name.
//
const FunctionType *FTy = cast<FunctionType>(Ty);
calcTypeName(FTy->getReturnType(), TypeStack, TypeNames, Result);
Result += " (";
+ unsigned Idx = 1;
for (FunctionType::param_iterator I = FTy->param_begin(),
E = FTy->param_end(); I != E; ++I) {
if (I != FTy->param_begin())
Result += ", ";
calcTypeName(*I, TypeStack, TypeNames, Result);
+ if (FTy->getParamAttrs(Idx)) {
+ Result += + " ";
+ Result += FunctionType::getParamAttrsText(FTy->getParamAttrs(Idx));
+ }
+ Idx++;
}
if (FTy->isVarArg()) {
if (FTy->getNumParams()) Result += ", ";
Result += "...";
}
Result += ")";
+ if (FTy->getParamAttrs(0)) {
+ Result += " ";
+ Result += FunctionType::getParamAttrsText(FTy->getParamAttrs(0));
+ }
break;
}
case Type::StructTyID: {
const StructType *STy = cast<StructType>(Ty);
+ if (STy->isPacked())
+ Result += '<';
Result += "{ ";
for (StructType::element_iterator I = STy->element_begin(),
E = STy->element_end(); I != E; ++I) {
calcTypeName(*I, TypeStack, TypeNames, Result);
}
Result += " }";
+ if (STy->isPacked())
+ Result += '>';
break;
}
case Type::PointerTyID:
break;
default:
Result += "<unrecognized-type>";
+ break;
}
TypeStack.pop_back(); // Remove self from stack...
- return;
}
const Module *M) {
Out << ' ';
- // If they want us to print out a type, attempt to make it symbolic if there
- // is a symbol table in the module...
- if (M) {
- std::map<const Type *, std::string> TypeNames;
- fillTypeNameTable(M, TypeNames);
-
- return printTypeInt(Out, Ty, TypeNames);
- } else {
+ // If they want us to print out a type, but there is no context, we can't
+ // print it symbolically.
+ if (!M)
return Out << Ty->getDescription();
+
+ std::map<const Type *, std::string> TypeNames;
+ fillTypeNameTable(M, TypeNames);
+ return printTypeInt(Out, Ty, TypeNames);
+}
+
+// PrintEscapedString - Print each character of the specified string, escaping
+// it if it is not printable or if it is an escape char.
+static void PrintEscapedString(const std::string &Str, std::ostream &Out) {
+ for (unsigned i = 0, e = Str.size(); i != e; ++i) {
+ unsigned char C = Str[i];
+ if (isprint(C) && C != '"' && C != '\\') {
+ Out << C;
+ } else {
+ Out << '\\'
+ << (char) ((C/16 < 10) ? ( C/16 +'0') : ( C/16 -10+'A'))
+ << (char)(((C&15) < 10) ? ((C&15)+'0') : ((C&15)-10+'A'));
+ }
+ }
+}
+
+static const char *getPredicateText(unsigned predicate) {
+ const char * pred = "unknown";
+ switch (predicate) {
+ case FCmpInst::FCMP_FALSE: pred = "false"; break;
+ case FCmpInst::FCMP_OEQ: pred = "oeq"; break;
+ case FCmpInst::FCMP_OGT: pred = "ogt"; break;
+ case FCmpInst::FCMP_OGE: pred = "oge"; break;
+ case FCmpInst::FCMP_OLT: pred = "olt"; break;
+ case FCmpInst::FCMP_OLE: pred = "ole"; break;
+ case FCmpInst::FCMP_ONE: pred = "one"; break;
+ case FCmpInst::FCMP_ORD: pred = "ord"; break;
+ case FCmpInst::FCMP_UNO: pred = "uno"; break;
+ case FCmpInst::FCMP_UEQ: pred = "ueq"; break;
+ case FCmpInst::FCMP_UGT: pred = "ugt"; break;
+ case FCmpInst::FCMP_UGE: pred = "uge"; break;
+ case FCmpInst::FCMP_ULT: pred = "ult"; break;
+ case FCmpInst::FCMP_ULE: pred = "ule"; break;
+ case FCmpInst::FCMP_UNE: pred = "une"; break;
+ case FCmpInst::FCMP_TRUE: pred = "true"; break;
+ case ICmpInst::ICMP_EQ: pred = "eq"; break;
+ case ICmpInst::ICMP_NE: pred = "ne"; break;
+ case ICmpInst::ICMP_SGT: pred = "sgt"; break;
+ case ICmpInst::ICMP_SGE: pred = "sge"; break;
+ case ICmpInst::ICMP_SLT: pred = "slt"; break;
+ case ICmpInst::ICMP_SLE: pred = "sle"; break;
+ case ICmpInst::ICMP_UGT: pred = "ugt"; break;
+ case ICmpInst::ICMP_UGE: pred = "uge"; break;
+ case ICmpInst::ICMP_ULT: pred = "ult"; break;
+ case ICmpInst::ICMP_ULE: pred = "ule"; break;
}
+ return pred;
}
/// @brief Internal constant writer.
static void WriteConstantInt(std::ostream &Out, const Constant *CV,
- bool PrintName,
std::map<const Type *, std::string> &TypeTable,
SlotMachine *Machine) {
+ const int IndentSize = 4;
+ static std::string Indent = "\n";
if (const ConstantBool *CB = dyn_cast<ConstantBool>(CV)) {
- Out << (CB == ConstantBool::True ? "true" : "false");
- } else if (const ConstantSInt *CI = dyn_cast<ConstantSInt>(CV)) {
- Out << CI->getValue();
- } else if (const ConstantUInt *CI = dyn_cast<ConstantUInt>(CV)) {
- Out << CI->getValue();
+ Out << (CB->getValue() ? "true" : "false");
+ } else if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) {
+ Out << CI->getSExtValue();
} else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV)) {
// We would like to output the FP constant value in exponential notation,
// but we cannot do this if doing so will lose precision. Check here to
// Otherwise we could not reparse it to exactly the same value, so we must
// output the string in hexadecimal format!
- //
- // Behave nicely in the face of C TBAA rules... see:
- // http://www.nullstone.com/htmls/category/aliastyp.htm
- //
- union {
- double D;
- uint64_t U;
- } V;
- V.D = CFP->getValue();
assert(sizeof(double) == sizeof(uint64_t) &&
"assuming that double is 64 bits!");
- Out << "0x" << utohexstr(V.U);
+ Out << "0x" << utohexstr(DoubleToBits(CFP->getValue()));
} else if (isa<ConstantAggregateZero>(CV)) {
Out << "zeroinitializer";
// ubytes or an array of sbytes with positive values.
//
const Type *ETy = CA->getType()->getElementType();
- bool isString = (ETy == Type::SByteTy || ETy == Type::UByteTy);
-
- if (ETy == Type::SByteTy)
- for (unsigned i = 0; i < CA->getNumOperands(); ++i)
- if (cast<ConstantSInt>(CA->getOperand(i))->getValue() < 0) {
- isString = false;
- break;
- }
-
- if (isString) {
+ if (CA->isString()) {
Out << "c\"";
- for (unsigned i = 0; i < CA->getNumOperands(); ++i) {
- unsigned char C =
- (unsigned char)cast<ConstantInt>(CA->getOperand(i))->getRawValue();
-
- if (isprint(C) && C != '"' && C != '\\') {
- Out << C;
- } else {
- Out << '\\'
- << (char) ((C/16 < 10) ? ( C/16 +'0') : ( C/16 -10+'A'))
- << (char)(((C&15) < 10) ? ((C&15)+'0') : ((C&15)-10+'A'));
- }
- }
+ PrintEscapedString(CA->getAsString(), Out);
Out << "\"";
} else { // Cannot output in string format...
Out << ' ';
printTypeInt(Out, ETy, TypeTable);
WriteAsOperandInternal(Out, CA->getOperand(0),
- PrintName, TypeTable, Machine);
+ TypeTable, Machine);
for (unsigned i = 1, e = CA->getNumOperands(); i != e; ++i) {
Out << ", ";
printTypeInt(Out, ETy, TypeTable);
- WriteAsOperandInternal(Out, CA->getOperand(i), PrintName,
- TypeTable, Machine);
+ WriteAsOperandInternal(Out, CA->getOperand(i), TypeTable, Machine);
}
}
Out << " ]";
}
} else if (const ConstantStruct *CS = dyn_cast<ConstantStruct>(CV)) {
+ if (CS->getType()->isPacked())
+ Out << '<';
Out << '{';
- if (CS->getNumOperands()) {
- Out << ' ';
+ unsigned N = CS->getNumOperands();
+ if (N) {
+ if (N > 2) {
+ Indent += std::string(IndentSize, ' ');
+ Out << Indent;
+ } else {
+ Out << ' ';
+ }
printTypeInt(Out, CS->getOperand(0)->getType(), TypeTable);
- WriteAsOperandInternal(Out, CS->getOperand(0),
- PrintName, TypeTable, Machine);
+ WriteAsOperandInternal(Out, CS->getOperand(0), TypeTable, Machine);
- for (unsigned i = 1; i < CS->getNumOperands(); i++) {
+ for (unsigned i = 1; i < N; i++) {
Out << ", ";
+ if (N > 2) Out << Indent;
printTypeInt(Out, CS->getOperand(i)->getType(), TypeTable);
- WriteAsOperandInternal(Out, CS->getOperand(i),
- PrintName, TypeTable, Machine);
+ WriteAsOperandInternal(Out, CS->getOperand(i), TypeTable, Machine);
}
+ if (N > 2) Indent.resize(Indent.size() - IndentSize);
}
-
+
Out << " }";
+ if (CS->getType()->isPacked())
+ Out << '>';
} else if (const ConstantPacked *CP = dyn_cast<ConstantPacked>(CV)) {
const Type *ETy = CP->getType()->getElementType();
assert(CP->getNumOperands() > 0 &&
Out << '<';
Out << ' ';
printTypeInt(Out, ETy, TypeTable);
- WriteAsOperandInternal(Out, CP->getOperand(0),
- PrintName, TypeTable, Machine);
+ WriteAsOperandInternal(Out, CP->getOperand(0), TypeTable, Machine);
for (unsigned i = 1, e = CP->getNumOperands(); i != e; ++i) {
Out << ", ";
printTypeInt(Out, ETy, TypeTable);
- WriteAsOperandInternal(Out, CP->getOperand(i), PrintName,
- TypeTable, Machine);
+ WriteAsOperandInternal(Out, CP->getOperand(i), TypeTable, Machine);
}
Out << " >";
} else if (isa<ConstantPointerNull>(CV)) {
Out << "undef";
} else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) {
- Out << CE->getOpcodeName() << " (";
+ Out << CE->getOpcodeName();
+ if (CE->isCompare())
+ Out << " " << getPredicateText(CE->getPredicate());
+ Out << " (";
for (User::const_op_iterator OI=CE->op_begin(); OI != CE->op_end(); ++OI) {
printTypeInt(Out, (*OI)->getType(), TypeTable);
- WriteAsOperandInternal(Out, *OI, PrintName, TypeTable, Machine);
+ WriteAsOperandInternal(Out, *OI, TypeTable, Machine);
if (OI+1 != CE->op_end())
Out << ", ";
}
- if (CE->getOpcode() == Instruction::Cast) {
+ if (CE->isCast()) {
Out << " to ";
printTypeInt(Out, CE->getType(), TypeTable);
}
+
Out << ')';
} else {
/// the whole instruction that generated it.
///
static void WriteAsOperandInternal(std::ostream &Out, const Value *V,
- bool PrintName,
std::map<const Type*, std::string> &TypeTable,
SlotMachine *Machine) {
Out << ' ';
- if ((PrintName || isa<GlobalValue>(V)) && V->hasName())
+ if (V->hasName())
Out << getLLVMName(V->getName());
else {
const Constant *CV = dyn_cast<Constant>(V);
- if (CV && !isa<GlobalValue>(CV))
- WriteConstantInt(Out, CV, PrintName, TypeTable, Machine);
- else {
+ if (CV && !isa<GlobalValue>(CV)) {
+ WriteConstantInt(Out, CV, TypeTable, Machine);
+ } else if (const InlineAsm *IA = dyn_cast<InlineAsm>(V)) {
+ Out << "asm ";
+ if (IA->hasSideEffects())
+ Out << "sideeffect ";
+ Out << '"';
+ PrintEscapedString(IA->getAsmString(), Out);
+ Out << "\", \"";
+ PrintEscapedString(IA->getConstraintString(), Out);
+ Out << '"';
+ } else {
int Slot;
if (Machine) {
Slot = Machine->getSlot(V);
} else {
Machine = createSlotMachine(V);
- if (Machine == 0)
+ if (Machine)
Slot = Machine->getSlot(V);
else
Slot = -1;
/// the whole instruction that generated it.
///
std::ostream &llvm::WriteAsOperand(std::ostream &Out, const Value *V,
- bool PrintType, bool PrintName,
- const Module *Context) {
+ bool PrintType, const Module *Context) {
std::map<const Type *, std::string> TypeNames;
if (Context == 0) Context = getModuleFromVal(V);
if (PrintType)
printTypeInt(Out, V->getType(), TypeNames);
- WriteAsOperandInternal(Out, V, PrintName, TypeNames, 0);
+ WriteAsOperandInternal(Out, V, TypeNames, 0);
return Out;
}
-/// WriteAsOperandInternal - Write the name of the specified value out to
-/// the specified ostream. This can be useful when you just want to print
-/// int %reg126, not the whole instruction that generated it.
-///
-static void WriteAsOperandInternal(std::ostream &Out, const Type *T,
- bool PrintName,
- std::map<const Type*, std::string> &TypeTable,
- SlotMachine *Machine) {
- Out << ' ';
- int Slot;
- if (Machine) {
- Slot = Machine->getSlot(T);
- if (Slot != -1)
- Out << '%' << Slot;
- else
- Out << "<badref>";
- } else {
- Out << T->getDescription();
- }
-}
-
-/// WriteAsOperand - Write the name of the specified value out to the specified
-/// ostream. This can be useful when you just want to print int %reg126, not
-/// the whole instruction that generated it.
-///
-std::ostream &llvm::WriteAsOperand(std::ostream &Out, const Type *Ty,
- bool PrintType, bool PrintName,
- const Module *Context) {
- std::map<const Type *, std::string> TypeNames;
- assert(Context != 0 && "Can't write types as operand without module context");
-
- fillTypeNameTable(Context, TypeNames);
-
- // if (PrintType)
- // printTypeInt(Out, V->getType(), TypeNames);
-
- printTypeInt(Out, Ty, TypeNames);
-
- WriteAsOperandInternal(Out, Ty, PrintName, TypeNames, 0);
- return Out;
-}
namespace llvm {
inline void write(const Constant *CPV) { printConstant(CPV); }
inline void write(const Type *Ty) { printType(Ty); }
- void writeOperand(const Value *Op, bool PrintType, bool PrintName = true);
+ void writeOperand(const Value *Op, bool PrintType);
const Module* getModule() { return TheModule; }
private:
void printModule(const Module *M);
- void printSymbolTable(const SymbolTable &ST);
+ void printTypeSymbolTable(const TypeSymbolTable &ST);
+ void printValueSymbolTable(const SymbolTable &ST);
void printConstant(const Constant *CPV);
void printGlobal(const GlobalVariable *GV);
void printFunction(const Function *F);
- void printArgument(const Argument *FA);
+ void printArgument(const Argument *FA, FunctionType::ParameterAttributes A);
void printBasicBlock(const BasicBlock *BB);
void printInstruction(const Instruction &I);
///
std::ostream &AssemblyWriter::printTypeAtLeastOneLevel(const Type *Ty) {
if (const FunctionType *FTy = dyn_cast<FunctionType>(Ty)) {
- printType(FTy->getReturnType()) << " (";
+ printType(FTy->getReturnType());
+ Out << " (";
+ unsigned Idx = 1;
for (FunctionType::param_iterator I = FTy->param_begin(),
E = FTy->param_end(); I != E; ++I) {
if (I != FTy->param_begin())
Out << ", ";
printType(*I);
+ if (FTy->getParamAttrs(Idx)) {
+ Out << " " << FunctionType::getParamAttrsText(FTy->getParamAttrs(Idx));
+ }
+ Idx++;
}
if (FTy->isVarArg()) {
if (FTy->getNumParams()) Out << ", ";
Out << "...";
}
Out << ')';
+ if (FTy->getParamAttrs(0))
+ Out << ' ' << FunctionType::getParamAttrsText(FTy->getParamAttrs(0));
} else if (const StructType *STy = dyn_cast<StructType>(Ty)) {
+ if (STy->isPacked())
+ Out << '<';
Out << "{ ";
for (StructType::element_iterator I = STy->element_begin(),
E = STy->element_end(); I != E; ++I) {
printType(*I);
}
Out << " }";
+ if (STy->isPacked())
+ Out << '>';
} else if (const PointerType *PTy = dyn_cast<PointerType>(Ty)) {
printType(PTy->getElementType()) << '*';
} else if (const ArrayType *ATy = dyn_cast<ArrayType>(Ty)) {
Out << '<' << PTy->getNumElements() << " x ";
printType(PTy->getElementType()) << '>';
}
- else if (const OpaqueType *OTy = dyn_cast<OpaqueType>(Ty)) {
+ else if (isa<OpaqueType>(Ty)) {
Out << "opaque";
} else {
if (!Ty->isPrimitiveType())
}
-void AssemblyWriter::writeOperand(const Value *Operand, bool PrintType,
- bool PrintName) {
- if (Operand != 0) {
- if (PrintType) { Out << ' '; printType(Operand->getType()); }
- WriteAsOperandInternal(Out, Operand, PrintName, TypeNames, &Machine);
- } else {
+void AssemblyWriter::writeOperand(const Value *Operand, bool PrintType) {
+ if (Operand == 0) {
Out << "<null operand!>";
+ } else {
+ if (PrintType) { Out << ' '; printType(Operand->getType()); }
+ WriteAsOperandInternal(Out, Operand, TypeNames, &Machine);
}
}
M->getModuleIdentifier().find('\n') == std::string::npos)
Out << "; ModuleID = '" << M->getModuleIdentifier() << "'\n";
+ if (!M->getDataLayout().empty())
+ Out << "target datalayout = \"" << M->getDataLayout() << "\"\n";
+
switch (M->getEndianness()) {
case Module::LittleEndian: Out << "target endian = little\n"; break;
case Module::BigEndian: Out << "target endian = big\n"; break;
if (!M->getTargetTriple().empty())
Out << "target triple = \"" << M->getTargetTriple() << "\"\n";
+ if (!M->getModuleInlineAsm().empty()) {
+ // Split the string into lines, to make it easier to read the .ll file.
+ std::string Asm = M->getModuleInlineAsm();
+ size_t CurPos = 0;
+ size_t NewLine = Asm.find_first_of('\n', CurPos);
+ while (NewLine != std::string::npos) {
+ // We found a newline, print the portion of the asm string from the
+ // last newline up to this newline.
+ Out << "module asm \"";
+ PrintEscapedString(std::string(Asm.begin()+CurPos, Asm.begin()+NewLine),
+ Out);
+ Out << "\"\n";
+ CurPos = NewLine+1;
+ NewLine = Asm.find_first_of('\n', CurPos);
+ }
+ Out << "module asm \"";
+ PrintEscapedString(std::string(Asm.begin()+CurPos, Asm.end()), Out);
+ Out << "\"\n";
+ }
+
// Loop over the dependent libraries and emit them.
Module::lib_iterator LI = M->lib_begin();
Module::lib_iterator LE = M->lib_end();
}
// Loop over the symbol table, emitting all named constants.
- printSymbolTable(M->getSymbolTable());
+ printTypeSymbolTable(M->getTypeSymbolTable());
+ printValueSymbolTable(M->getValueSymbolTable());
- for (Module::const_global_iterator I = M->global_begin(), E = M->global_end(); I != E; ++I)
+ for (Module::const_global_iterator I = M->global_begin(), E = M->global_end();
+ I != E; ++I)
printGlobal(I);
Out << "\nimplementation ; Functions:\n";
if (GV->hasName()) Out << getLLVMName(GV->getName()) << " = ";
if (!GV->hasInitializer())
- Out << "external ";
+ switch (GV->getLinkage()) {
+ case GlobalValue::DLLImportLinkage: Out << "dllimport "; break;
+ case GlobalValue::ExternalWeakLinkage: Out << "extern_weak "; break;
+ default: Out << "external "; break;
+ }
else
switch (GV->getLinkage()) {
- case GlobalValue::InternalLinkage: Out << "internal "; break;
- case GlobalValue::LinkOnceLinkage: Out << "linkonce "; break;
- case GlobalValue::WeakLinkage: Out << "weak "; break;
- case GlobalValue::AppendingLinkage: Out << "appending "; break;
- case GlobalValue::ExternalLinkage: break;
+ case GlobalValue::InternalLinkage: Out << "internal "; break;
+ case GlobalValue::LinkOnceLinkage: Out << "linkonce "; break;
+ case GlobalValue::WeakLinkage: Out << "weak "; break;
+ case GlobalValue::AppendingLinkage: Out << "appending "; break;
+ case GlobalValue::DLLImportLinkage: Out << "dllimport "; break;
+ case GlobalValue::DLLExportLinkage: Out << "dllexport "; break;
+ case GlobalValue::ExternalWeakLinkage: Out << "extern_weak "; break;
+ case GlobalValue::ExternalLinkage: break;
case GlobalValue::GhostLinkage:
- std::cerr << "GhostLinkage not allowed in AsmWriter!\n";
+ cerr << "GhostLinkage not allowed in AsmWriter!\n";
abort();
}
if (GV->hasInitializer()) {
Constant* C = cast<Constant>(GV->getInitializer());
assert(C && "GlobalVar initializer isn't constant?");
- writeOperand(GV->getInitializer(), false, isa<GlobalValue>(C));
+ writeOperand(GV->getInitializer(), false);
}
-
+
+ if (GV->hasSection())
+ Out << ", section \"" << GV->getSection() << '"';
+ if (GV->getAlignment())
+ Out << ", align " << GV->getAlignment();
+
printInfoComment(*GV);
Out << "\n";
}
-
-// printSymbolTable - Run through symbol table looking for constants
-// and types. Emit their declarations.
-void AssemblyWriter::printSymbolTable(const SymbolTable &ST) {
-
+void AssemblyWriter::printTypeSymbolTable(const TypeSymbolTable &ST) {
// Print the types.
- for (SymbolTable::type_const_iterator TI = ST.type_begin();
- TI != ST.type_end(); ++TI ) {
+ for (TypeSymbolTable::const_iterator TI = ST.begin(), TE = ST.end();
+ TI != TE; ++TI) {
Out << "\t" << getLLVMName(TI->first) << " = type ";
// Make sure we print out at least one level of the type structure, so
//
printTypeAtLeastOneLevel(TI->second) << "\n";
}
+}
+
+// printSymbolTable - Run through symbol table looking for constants
+// and types. Emit their declarations.
+void AssemblyWriter::printValueSymbolTable(const SymbolTable &ST) {
// Print the constants, in type plane order.
for (SymbolTable::plane_const_iterator PI = ST.plane_begin();
- PI != ST.plane_end(); ++PI ) {
+ PI != ST.plane_end(); ++PI) {
SymbolTable::value_const_iterator VI = ST.value_begin(PI->first);
SymbolTable::value_const_iterator VE = ST.value_end(PI->first);
// Print out name...
Out << "\t" << getLLVMName(CPV->getName()) << " =";
- // Write the value out now...
- writeOperand(CPV, true, false);
+ // Write the value out now.
+ writeOperand(CPV, true);
printInfoComment(*CPV);
Out << "\n";
if (AnnotationWriter) AnnotationWriter->emitFunctionAnnot(F, Out);
if (F->isExternal())
- Out << "declare ";
- else
switch (F->getLinkage()) {
- case GlobalValue::InternalLinkage: Out << "internal "; break;
- case GlobalValue::LinkOnceLinkage: Out << "linkonce "; break;
- case GlobalValue::WeakLinkage: Out << "weak "; break;
- case GlobalValue::AppendingLinkage: Out << "appending "; break;
+ case GlobalValue::DLLImportLinkage: Out << "declare dllimport "; break;
+ case GlobalValue::ExternalWeakLinkage: Out << "declare extern_weak "; break;
+ default: Out << "declare ";
+ }
+ else {
+ Out << "define ";
+ switch (F->getLinkage()) {
+ case GlobalValue::InternalLinkage: Out << "internal "; break;
+ case GlobalValue::LinkOnceLinkage: Out << "linkonce "; break;
+ case GlobalValue::WeakLinkage: Out << "weak "; break;
+ case GlobalValue::AppendingLinkage: Out << "appending "; break;
+ case GlobalValue::DLLImportLinkage: Out << "dllimport "; break;
+ case GlobalValue::DLLExportLinkage: Out << "dllexport "; break;
+ case GlobalValue::ExternalWeakLinkage: Out << "extern_weak "; break;
case GlobalValue::ExternalLinkage: break;
case GlobalValue::GhostLinkage:
- std::cerr << "GhostLinkage not allowed in AsmWriter!\n";
+ cerr << "GhostLinkage not allowed in AsmWriter!\n";
abort();
}
+ }
// Print the calling convention.
switch (F->getCallingConv()) {
case CallingConv::C: break; // default
- case CallingConv::Fast: Out << "fastcc "; break;
- case CallingConv::Cold: Out << "coldcc "; break;
+ case CallingConv::CSRet: Out << "csretcc "; break;
+ case CallingConv::Fast: Out << "fastcc "; break;
+ case CallingConv::Cold: Out << "coldcc "; break;
+ case CallingConv::X86_StdCall: Out << "x86_stdcallcc "; break;
+ case CallingConv::X86_FastCall: Out << "x86_fastcallcc "; break;
default: Out << "cc" << F->getCallingConv() << " "; break;
}
+ const FunctionType *FT = F->getFunctionType();
printType(F->getReturnType()) << ' ';
if (!F->getName().empty())
Out << getLLVMName(F->getName());
Machine.incorporateFunction(F);
// Loop over the arguments, printing them...
- const FunctionType *FT = F->getFunctionType();
- for(Function::const_arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E; ++I)
- printArgument(I);
+ unsigned Idx = 1;
+ for (Function::const_arg_iterator I = F->arg_begin(), E = F->arg_end();
+ I != E; ++I) {
+ // Insert commas as we go... the first arg doesn't get a comma
+ if (I != F->arg_begin()) Out << ", ";
+ printArgument(I, FT->getParamAttrs(Idx));
+ Idx++;
+ }
// Finish printing arguments...
if (FT->isVarArg()) {
Out << "..."; // Output varargs portion of signature!
}
Out << ')';
+ if (FT->getParamAttrs(0))
+ Out << ' ' << FunctionType::getParamAttrsText(FT->getParamAttrs(0));
+ if (F->hasSection())
+ Out << " section \"" << F->getSection() << '"';
+ if (F->getAlignment())
+ Out << " align " << F->getAlignment();
if (F->isExternal()) {
Out << "\n";
/// printArgument - This member is called for every argument that is passed into
/// the function. Simply print it out
///
-void AssemblyWriter::printArgument(const Argument *Arg) {
- // Insert commas as we go... the first arg doesn't get a comma
- if (Arg != Arg->getParent()->arg_begin()) Out << ", ";
-
+void AssemblyWriter::printArgument(const Argument *Arg,
+ FunctionType::ParameterAttributes attrs) {
// Output type...
printType(Arg->getType());
+ if (attrs != FunctionType::NoAttributeSet)
+ Out << ' ' << FunctionType::getParamAttrsText(attrs);
+
// Output name, if available...
if (Arg->hasName())
Out << ' ' << getLLVMName(Arg->getName());
Out << " No predecessors!";
} else {
Out << " preds =";
- writeOperand(*PI, false, true);
+ writeOperand(*PI, false);
for (++PI; PI != PE; ++PI) {
Out << ',';
- writeOperand(*PI, false, true);
+ writeOperand(*PI, false);
}
}
}
}
}
-/// printInstruction - This member is called for each Instruction in a function..
-///
+// This member is called for each Instruction in a function..
void AssemblyWriter::printInstruction(const Instruction &I) {
if (AnnotationWriter) AnnotationWriter->emitInstructionAnnot(&I, Out);
// Print out the opcode...
Out << I.getOpcodeName();
+ // Print out the compare instruction predicates
+ if (const FCmpInst *FCI = dyn_cast<FCmpInst>(&I)) {
+ Out << " " << getPredicateText(FCI->getPredicate());
+ } else if (const ICmpInst *ICI = dyn_cast<ICmpInst>(&I)) {
+ Out << " " << getPredicateText(ICI->getPredicate());
+ }
+
// Print out the type of the operands...
const Value *Operand = I.getNumOperands() ? I.getOperand(0) : 0;
// Print the calling convention being used.
switch (CI->getCallingConv()) {
case CallingConv::C: break; // default
- case CallingConv::Fast: Out << " fastcc"; break;
- case CallingConv::Cold: Out << " coldcc"; break;
+ case CallingConv::CSRet: Out << " csretcc"; break;
+ case CallingConv::Fast: Out << " fastcc"; break;
+ case CallingConv::Cold: Out << " coldcc"; break;
+ case CallingConv::X86_StdCall: Out << "x86_stdcallcc "; break;
+ case CallingConv::X86_FastCall: Out << "x86_fastcallcc "; break;
default: Out << " cc" << CI->getCallingConv(); break;
}
writeOperand(Operand, true);
}
Out << '(';
- if (CI->getNumOperands() > 1) writeOperand(CI->getOperand(1), true);
- for (unsigned op = 2, Eop = I.getNumOperands(); op < Eop; ++op) {
- Out << ',';
+ for (unsigned op = 1, Eop = I.getNumOperands(); op < Eop; ++op) {
+ if (op > 1)
+ Out << ',';
writeOperand(I.getOperand(op), true);
+ if (FTy->getParamAttrs(op) != FunctionType::NoAttributeSet)
+ Out << " " << FTy->getParamAttrsText(FTy->getParamAttrs(op));
}
-
Out << " )";
+ if (FTy->getParamAttrs(0) != FunctionType::NoAttributeSet)
+ Out << ' ' << FTy->getParamAttrsText(FTy->getParamAttrs(0));
} else if (const InvokeInst *II = dyn_cast<InvokeInst>(&I)) {
const PointerType *PTy = cast<PointerType>(Operand->getType());
const FunctionType *FTy = cast<FunctionType>(PTy->getElementType());
// Print the calling convention being used.
switch (II->getCallingConv()) {
case CallingConv::C: break; // default
- case CallingConv::Fast: Out << " fastcc"; break;
- case CallingConv::Cold: Out << " coldcc"; break;
+ case CallingConv::CSRet: Out << " csretcc"; break;
+ case CallingConv::Fast: Out << " fastcc"; break;
+ case CallingConv::Cold: Out << " coldcc"; break;
+ case CallingConv::X86_StdCall: Out << "x86_stdcallcc "; break;
+ case CallingConv::X86_FastCall: Out << "x86_fastcallcc "; break;
default: Out << " cc" << II->getCallingConv(); break;
}
}
Out << '(';
- if (I.getNumOperands() > 3) writeOperand(I.getOperand(3), true);
- for (unsigned op = 4, Eop = I.getNumOperands(); op < Eop; ++op) {
- Out << ',';
+ for (unsigned op = 3, Eop = I.getNumOperands(); op < Eop; ++op) {
+ if (op > 3)
+ Out << ',';
writeOperand(I.getOperand(op), true);
+ if (FTy->getParamAttrs(op-2) != FunctionType::NoAttributeSet)
+ Out << " " << FTy->getParamAttrsText(FTy->getParamAttrs(op-2));
}
- Out << " )\n\t\t\tto";
+ Out << " )";
+ if (FTy->getParamAttrs(0) != FunctionType::NoAttributeSet)
+ Out << " " << FTy->getParamAttrsText(FTy->getParamAttrs(0));
+ Out << "\n\t\t\tto";
writeOperand(II->getNormalDest(), true);
Out << " unwind";
writeOperand(II->getUnwindDest(), true);
Out << ',';
writeOperand(AI->getArraySize(), true);
}
+ if (AI->getAlignment()) {
+ Out << ", align " << AI->getAlignment();
+ }
} else if (isa<CastInst>(I)) {
if (Operand) writeOperand(Operand, true); // Work with broken code
Out << " to ";
// Shift Left & Right print both types even for Ubyte LHS, and select prints
// types even if all operands are bools.
- if (isa<ShiftInst>(I) || isa<SelectInst>(I) || isa<StoreInst>(I)) {
+ if (isa<ShiftInst>(I) || isa<SelectInst>(I) || isa<StoreInst>(I) ||
+ isa<ShuffleVectorInst>(I)) {
PrintAllTypes = true;
} else {
for (unsigned i = 1, E = I.getNumOperands(); i != E; ++i) {
W.write(this);
}
+void InlineAsm::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const {
+ WriteAsOperand(o, this, true, 0);
+}
+
void BasicBlock::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const {
SlotMachine SlotTable(getParent());
AssemblyWriter W(o, SlotTable,
o << ' ' << getType()->getDescription() << ' ';
std::map<const Type *, std::string> TypeTable;
- WriteConstantInt(o, this, false, TypeTable, 0);
+ WriteConstantInt(o, this, TypeTable, 0);
}
void Type::print(std::ostream &o) const {
}
void Argument::print(std::ostream &o) const {
- WriteAsOperand(o, this, true, true,
- getParent() ? getParent()->getParent() : 0);
+ WriteAsOperand(o, this, true, getParent() ? getParent()->getParent() : 0);
}
// Value::dump - allow easy printing of Values from the debugger.
// Located here because so much of the needed functionality is here.
-void Value::dump() const { print(std::cerr); }
+void Value::dump() const { print(*cerr.stream()); cerr << '\n'; }
// Type::dump - allow easy printing of Values from the debugger.
// Located here because so much of the needed functionality is here.
-void Type::dump() const { print(std::cerr); }
-
-//===----------------------------------------------------------------------===//
-// CachedWriter Class Implementation
-//===----------------------------------------------------------------------===//
-
-void CachedWriter::setModule(const Module *M) {
- delete SC; delete AW;
- if (M) {
- SC = new SlotMachine(M );
- AW = new AssemblyWriter(Out, *SC, M, 0);
- } else {
- SC = 0; AW = 0;
- }
-}
-
-CachedWriter::~CachedWriter() {
- delete AW;
- delete SC;
-}
-
-CachedWriter &CachedWriter::operator<<(const Value &V) {
- assert(AW && SC && "CachedWriter does not have a current module!");
- if (const Instruction *I = dyn_cast<Instruction>(&V))
- AW->write(I);
- else if (const BasicBlock *BB = dyn_cast<BasicBlock>(&V))
- AW->write(BB);
- else if (const Function *F = dyn_cast<Function>(&V))
- AW->write(F);
- else if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(&V))
- AW->write(GV);
- else
- AW->writeOperand(&V, true, true);
- return *this;
-}
-
-CachedWriter& CachedWriter::operator<<(const Type &Ty) {
- if (SymbolicTypes) {
- const Module *M = AW->getModule();
- if (M) WriteTypeSymbolic(Out, &Ty, M);
- } else {
- AW->write(&Ty);
- }
- return *this;
-}
+void Type::dump() const { print(*cerr.stream()); cerr << '\n'; }
//===----------------------------------------------------------------------===//
-//===-- SlotMachine Implementation
+// SlotMachine Implementation
//===----------------------------------------------------------------------===//
#if 0
-#define SC_DEBUG(X) std::cerr << X
+#define SC_DEBUG(X) cerr << X
#else
#define SC_DEBUG(X)
#endif
: TheModule(M) ///< Saved for lazy initialization.
, TheFunction(0)
, FunctionProcessed(false)
- , mMap()
- , mTypes()
- , fMap()
- , fTypes()
{
}
// Function level constructor. Causes the contents of the Module and the one
// function provided to be added to the slot table.
-SlotMachine::SlotMachine(const Function *F )
- : TheModule( F ? F->getParent() : 0 ) ///< Saved for lazy initialization
+SlotMachine::SlotMachine(const Function *F)
+ : TheModule(F ? F->getParent() : 0) ///< Saved for lazy initialization
, TheFunction(F) ///< Saved for lazy initialization
, FunctionProcessed(false)
- , mMap()
- , mTypes()
- , fMap()
- , fTypes()
{
}
inline void SlotMachine::initialize(void) {
- if ( TheModule) {
+ if (TheModule) {
processModule();
TheModule = 0; ///< Prevent re-processing next time we're called.
}
- if ( TheFunction && ! FunctionProcessed) {
+ if (TheFunction && !FunctionProcessed)
processFunction();
- }
}
// Iterate through all the global variables, functions, and global
void SlotMachine::processModule() {
SC_DEBUG("begin processModule!\n");
- // Add all of the global variables to the value table...
- for (Module::const_global_iterator I = TheModule->global_begin(), E = TheModule->global_end();
- I != E; ++I)
- createSlot(I);
+ // Add all of the unnamed global variables to the value table.
+ for (Module::const_global_iterator I = TheModule->global_begin(),
+ E = TheModule->global_end(); I != E; ++I)
+ if (!I->hasName())
+ CreateModuleSlot(I);
- // Add all the functions to the table
+ // Add all the unnamed functions to the table.
for (Module::const_iterator I = TheModule->begin(), E = TheModule->end();
I != E; ++I)
- createSlot(I);
+ if (!I->hasName())
+ CreateModuleSlot(I);
SC_DEBUG("end processModule!\n");
}
void SlotMachine::processFunction() {
SC_DEBUG("begin processFunction!\n");
- // Add all the function arguments
+ // Add all the function arguments with no names.
for(Function::const_arg_iterator AI = TheFunction->arg_begin(),
AE = TheFunction->arg_end(); AI != AE; ++AI)
- createSlot(AI);
+ if (!AI->hasName())
+ CreateFunctionSlot(AI);
SC_DEBUG("Inserting Instructions:\n");
- // Add all of the basic blocks and instructions
+ // Add all of the basic blocks and instructions with no names.
for (Function::const_iterator BB = TheFunction->begin(),
E = TheFunction->end(); BB != E; ++BB) {
- createSlot(BB);
- for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I!=E; ++I) {
- createSlot(I);
- }
+ if (!BB->hasName())
+ CreateFunctionSlot(BB);
+ for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I != E; ++I)
+ if (I->getType() != Type::VoidTy && !I->hasName())
+ CreateFunctionSlot(I);
}
FunctionProcessed = true;
SC_DEBUG("end processFunction!\n");
}
-// Clean up after incorporating a function. This is the only way
-// to get out of the function incorporation state that affects the
-// getSlot/createSlot lock. Function incorporation state is indicated
-// by TheFunction != 0.
+/// Clean up after incorporating a function. This is the only way to get out of
+/// the function incorporation state that affects getSlot/Create*Slot. Function
+/// incorporation state is indicated by TheFunction != 0.
void SlotMachine::purgeFunction() {
SC_DEBUG("begin purgeFunction!\n");
fMap.clear(); // Simply discard the function level map
- fTypes.clear();
TheFunction = 0;
FunctionProcessed = false;
SC_DEBUG("end purgeFunction!\n");
}
/// Get the slot number for a value. This function will assert if you
-/// ask for a Value that hasn't previously been inserted with createSlot.
-/// Types are forbidden because Type does not inherit from Value (any more).
+/// ask for a Value that hasn't previously been inserted with Create*Slot.
int SlotMachine::getSlot(const Value *V) {
- assert( V && "Can't get slot for null Value" );
+ assert(V && "Can't get slot for null Value");
assert(!isa<Constant>(V) || isa<GlobalValue>(V) &&
"Can't insert a non-GlobalValue Constant into SlotMachine");
// Find the type plane in the module map
TypedPlanes::const_iterator MI = mMap.find(VTy);
- if ( TheFunction ) {
+ if (TheFunction) {
// Lookup the type in the function map too
TypedPlanes::const_iterator FI = fMap.find(VTy);
// If there is a corresponding type plane in the function map
- if ( FI != fMap.end() ) {
+ if (FI != fMap.end()) {
// Lookup the Value in the function map
ValueMap::const_iterator FVI = FI->second.map.find(V);
// If the value doesn't exist in the function map
- if ( FVI == FI->second.map.end() ) {
+ if (FVI == FI->second.map.end()) {
// Look up the value in the module map.
if (MI == mMap.end()) return -1;
ValueMap::const_iterator MVI = MI->second.map.find(V);
// If we didn't find it, it wasn't inserted
if (MVI == MI->second.map.end()) return -1;
- assert( MVI != MI->second.map.end() && "Value not found");
+ assert(MVI != MI->second.map.end() && "Value not found");
// We found it only at the module level
return MVI->second;
return MVI->second;
}
-/// Get the slot number for a value. This function will assert if you
-/// ask for a Value that hasn't previously been inserted with createSlot.
-/// Types are forbidden because Type does not inherit from Value (any more).
-int SlotMachine::getSlot(const Type *Ty) {
- assert( Ty && "Can't get slot for null Type" );
-
- // Check for uninitialized state and do lazy initialization
- this->initialize();
- if ( TheFunction ) {
- // Lookup the Type in the function map
- TypeMap::const_iterator FTI = fTypes.map.find(Ty);
- // If the Type doesn't exist in the function map
- if ( FTI == fTypes.map.end() ) {
- TypeMap::const_iterator MTI = mTypes.map.find(Ty);
- // If we didn't find it, it wasn't inserted
- if (MTI == mTypes.map.end())
- return -1;
- // We found it only at the module level
- return MTI->second;
-
- // else the value exists in the function map
- } else {
- // Return the slot number as the module's contribution to
- // the type plane plus the index in the function's contribution
- // to the type plane.
- return mTypes.next_slot + FTI->second;
- }
- }
-
- // N.B. Can get here only if either !TheFunction
-
- // Lookup the value in the module's map
- TypeMap::const_iterator MTI = mTypes.map.find(Ty);
- // Make sure we found it.
- if (MTI == mTypes.map.end()) return -1;
- // Return it.
- return MTI->second;
-}
-
-// Create a new slot, or return the existing slot if it is already
-// inserted. Note that the logic here parallels getSlot but instead
-// of asserting when the Value* isn't found, it inserts the value.
-unsigned SlotMachine::createSlot(const Value *V) {
- assert( V && "Can't insert a null Value to SlotMachine");
- assert(!isa<Constant>(V) || isa<GlobalValue>(V) &&
- "Can't insert a non-GlobalValue Constant into SlotMachine");
-
- const Type* VTy = V->getType();
-
- // Just ignore void typed things
- if (VTy == Type::VoidTy) return 0; // FIXME: Wrong return value!
-
- // Look up the type plane for the Value's type from the module map
- TypedPlanes::const_iterator MI = mMap.find(VTy);
-
- if ( TheFunction ) {
- // Get the type plane for the Value's type from the function map
- TypedPlanes::const_iterator FI = fMap.find(VTy);
- // If there is a corresponding type plane in the function map
- if ( FI != fMap.end() ) {
- // Lookup the Value in the function map
- ValueMap::const_iterator FVI = FI->second.map.find(V);
- // If the value doesn't exist in the function map
- if ( FVI == FI->second.map.end() ) {
- // If there is no corresponding type plane in the module map
- if ( MI == mMap.end() )
- return insertValue(V);
- // Look up the value in the module map
- ValueMap::const_iterator MVI = MI->second.map.find(V);
- // If we didn't find it, it wasn't inserted
- if ( MVI == MI->second.map.end() )
- return insertValue(V);
- else
- // We found it only at the module level
- return MVI->second;
-
- // else the value exists in the function map
- } else {
- if ( MI == mMap.end() )
- return FVI->second;
- else
- // Return the slot number as the module's contribution to
- // the type plane plus the index in the function's contribution
- // to the type plane.
- return MI->second.next_slot + FVI->second;
- }
-
- // else there is not a corresponding type plane in the function map
- } else {
- // If the type plane doesn't exists at the module level
- if ( MI == mMap.end() ) {
- return insertValue(V);
- // else type plane exists at the module level, examine it
- } else {
- // Look up the value in the module's map
- ValueMap::const_iterator MVI = MI->second.map.find(V);
- // If we didn't find it there either
- if ( MVI == MI->second.map.end() )
- // Return the slot number as the module's contribution to
- // the type plane plus the index of the function map insertion.
- return MI->second.next_slot + insertValue(V);
- else
- return MVI->second;
- }
- }
- }
-
- // N.B. Can only get here if !TheFunction
-
- // If the module map's type plane is not for the Value's type
- if ( MI != mMap.end() ) {
- // Lookup the value in the module's map
- ValueMap::const_iterator MVI = MI->second.map.find(V);
- if ( MVI != MI->second.map.end() )
- return MVI->second;
- }
-
- return insertValue(V);
-}
-
-// Create a new slot, or return the existing slot if it is already
-// inserted. Note that the logic here parallels getSlot but instead
-// of asserting when the Value* isn't found, it inserts the value.
-unsigned SlotMachine::createSlot(const Type *Ty) {
- assert( Ty && "Can't insert a null Type to SlotMachine");
-
- if ( TheFunction ) {
- // Lookup the Type in the function map
- TypeMap::const_iterator FTI = fTypes.map.find(Ty);
- // If the type doesn't exist in the function map
- if ( FTI == fTypes.map.end() ) {
- // Look up the type in the module map
- TypeMap::const_iterator MTI = mTypes.map.find(Ty);
- // If we didn't find it, it wasn't inserted
- if ( MTI == mTypes.map.end() )
- return insertValue(Ty);
- else
- // We found it only at the module level
- return MTI->second;
-
- // else the value exists in the function map
- } else {
- // Return the slot number as the module's contribution to
- // the type plane plus the index in the function's contribution
- // to the type plane.
- return mTypes.next_slot + FTI->second;
- }
- }
-
- // N.B. Can only get here if !TheFunction
-
- // Lookup the type in the module's map
- TypeMap::const_iterator MTI = mTypes.map.find(Ty);
- if ( MTI != mTypes.map.end() )
- return MTI->second;
-
- return insertValue(Ty);
-}
-
-// Low level insert function. Minimal checking is done. This
-// function is just for the convenience of createSlot (above).
-unsigned SlotMachine::insertValue(const Value *V ) {
+/// CreateModuleSlot - Insert the specified GlobalValue* into the slot table.
+void SlotMachine::CreateModuleSlot(const GlobalValue *V) {
assert(V && "Can't insert a null Value into SlotMachine!");
- assert(!isa<Constant>(V) || isa<GlobalValue>(V) &&
- "Can't insert a non-GlobalValue Constant into SlotMachine");
-
- // If this value does not contribute to a plane (is void)
- // or if the value already has a name then ignore it.
- if (V->getType() == Type::VoidTy || V->hasName() ) {
- SC_DEBUG("ignored value " << *V << "\n");
- return 0; // FIXME: Wrong return value
- }
-
- const Type *VTy = V->getType();
+
unsigned DestSlot = 0;
-
- if ( TheFunction ) {
- TypedPlanes::iterator I = fMap.find( VTy );
- if ( I == fMap.end() )
- I = fMap.insert(std::make_pair(VTy,ValuePlane())).first;
- DestSlot = I->second.map[V] = I->second.next_slot++;
- } else {
- TypedPlanes::iterator I = mMap.find( VTy );
- if ( I == mMap.end() )
- I = mMap.insert(std::make_pair(VTy,ValuePlane())).first;
- DestSlot = I->second.map[V] = I->second.next_slot++;
- }
-
+ const Type *VTy = V->getType();
+
+ ValuePlane &PlaneMap = mMap[VTy];
+ DestSlot = PlaneMap.map[V] = PlaneMap.next_slot++;
+
SC_DEBUG(" Inserting value [" << VTy << "] = " << V << " slot=" <<
DestSlot << " [");
- // G = Global, C = Constant, T = Type, F = Function, o = other
- SC_DEBUG((isa<GlobalVariable>(V) ? 'G' : (isa<Function>(V) ? 'F' :
- (isa<Constant>(V) ? 'C' : 'o'))));
- SC_DEBUG("]\n");
- return DestSlot;
+ // G = Global, F = Function, o = other
+ SC_DEBUG((isa<GlobalVariable>(V) ? 'G' : 'F') << "]\n");
}
-// Low level insert function. Minimal checking is done. This
-// function is just for the convenience of createSlot (above).
-unsigned SlotMachine::insertValue(const Type *Ty ) {
- assert(Ty && "Can't insert a null Type into SlotMachine!");
+/// CreateSlot - Create a new slot for the specified value if it has no name.
+void SlotMachine::CreateFunctionSlot(const Value *V) {
+ const Type *VTy = V->getType();
+ assert(VTy != Type::VoidTy && !V->hasName() && "Doesn't need a slot!");
+
unsigned DestSlot = 0;
-
- if ( TheFunction ) {
- DestSlot = fTypes.map[Ty] = fTypes.next_slot++;
- } else {
- DestSlot = fTypes.map[Ty] = fTypes.next_slot++;
- }
- SC_DEBUG(" Inserting type [" << DestSlot << "] = " << Ty << "\n");
- return DestSlot;
-}
-
-// vim: sw=2
+
+ ValuePlane &PlaneMap = fMap[VTy];
+ DestSlot = PlaneMap.map[V] = PlaneMap.next_slot++;
+
+ // G = Global, F = Function, o = other
+ SC_DEBUG(" Inserting value [" << VTy << "] = " << V << " slot=" <<
+ DestSlot << " [o]\n");
+}
projects / oota-llvm.git / blobdiff