2002-04-07 22:31:46 +00:00
|
|
|
//===-- AsmWriter.cpp - Printing LLVM as an assembly file -----------------===//
|
2005-04-21 23:48:37 +00:00
|
|
|
//
|
2003-10-20 19:43:21 +00:00
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-29 20:36:04 +00:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2005-04-21 23:48:37 +00:00
|
|
|
//
|
2003-10-20 19:43:21 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2001-06-06 20:29:01 +00:00
|
|
|
//
|
|
|
|
// This library implements the functionality defined in llvm/Assembly/Writer.h
|
|
|
|
//
|
2002-04-12 18:21:53 +00:00
|
|
|
// Note that these routines must be extremely tolerant of various errors in the
|
2003-05-08 02:44:12 +00:00
|
|
|
// LLVM code, because it can be used for debugging transformations.
|
2002-04-12 18:21:53 +00:00
|
|
|
//
|
2001-06-06 20:29:01 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2002-04-08 22:03:40 +00:00
|
|
|
#include "llvm/Assembly/Writer.h"
|
2002-07-23 18:07:49 +00:00
|
|
|
#include "llvm/Assembly/PrintModulePass.h"
|
2003-10-30 23:41:03 +00:00
|
|
|
#include "llvm/Assembly/AsmAnnotationWriter.h"
|
2005-05-06 20:26:43 +00:00
|
|
|
#include "llvm/CallingConv.h"
|
2004-01-20 19:50:34 +00:00
|
|
|
#include "llvm/Constants.h"
|
2002-04-29 18:46:50 +00:00
|
|
|
#include "llvm/DerivedTypes.h"
|
2006-01-25 18:57:27 +00:00
|
|
|
#include "llvm/InlineAsm.h"
|
2002-07-14 23:14:45 +00:00
|
|
|
#include "llvm/Instruction.h"
|
2004-07-29 16:53:53 +00:00
|
|
|
#include "llvm/Instructions.h"
|
2009-07-20 21:19:07 +00:00
|
|
|
#include "llvm/Operator.h"
|
2009-07-28 21:49:47 +00:00
|
|
|
#include "llvm/Metadata.h"
|
2004-01-20 19:50:34 +00:00
|
|
|
#include "llvm/Module.h"
|
2007-02-05 20:47:22 +00:00
|
|
|
#include "llvm/ValueSymbolTable.h"
|
2007-01-06 07:24:44 +00:00
|
|
|
#include "llvm/TypeSymbolTable.h"
|
2009-03-01 00:03:38 +00:00
|
|
|
#include "llvm/ADT/DenseSet.h"
|
2004-09-01 22:55:40 +00:00
|
|
|
#include "llvm/ADT/StringExtras.h"
|
|
|
|
#include "llvm/ADT/STLExtras.h"
|
2006-11-28 02:09:03 +00:00
|
|
|
#include "llvm/Support/CFG.h"
|
2009-07-08 18:01:40 +00:00
|
|
|
#include "llvm/Support/ErrorHandling.h"
|
2005-08-17 19:34:49 +00:00
|
|
|
#include "llvm/Support/MathExtras.h"
|
2008-08-17 04:17:45 +00:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2001-09-07 16:36:04 +00:00
|
|
|
#include <algorithm>
|
2007-05-22 19:27:35 +00:00
|
|
|
#include <cctype>
|
2009-07-01 19:21:12 +00:00
|
|
|
#include <map>
|
2003-11-21 20:23:48 +00:00
|
|
|
using namespace llvm;
|
2003-11-11 22:41:34 +00:00
|
|
|
|
2005-05-15 16:13:11 +00:00
|
|
|
// Make virtual table appear in this compilation unit.
|
|
|
|
AssemblyAnnotationWriter::~AssemblyAnnotationWriter() {}
|
|
|
|
|
2008-08-19 04:36:02 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Helper Functions
|
|
|
|
//===----------------------------------------------------------------------===//
|
2004-07-04 11:50:43 +00:00
|
|
|
|
2001-10-29 16:37:48 +00:00
|
|
|
static const Module *getModuleFromVal(const Value *V) {
|
2003-07-23 15:30:06 +00:00
|
|
|
if (const Argument *MA = dyn_cast<Argument>(V))
|
2001-10-29 16:37:48 +00:00
|
|
|
return MA->getParent() ? MA->getParent()->getParent() : 0;
|
2008-08-19 04:36:02 +00:00
|
|
|
|
|
|
|
if (const BasicBlock *BB = dyn_cast<BasicBlock>(V))
|
2001-10-29 16:37:48 +00:00
|
|
|
return BB->getParent() ? BB->getParent()->getParent() : 0;
|
2008-08-19 04:36:02 +00:00
|
|
|
|
|
|
|
if (const Instruction *I = dyn_cast<Instruction>(V)) {
|
2002-03-26 18:01:55 +00:00
|
|
|
const Function *M = I->getParent() ? I->getParent()->getParent() : 0;
|
2001-10-29 16:37:48 +00:00
|
|
|
return M ? M->getParent() : 0;
|
2008-08-19 04:36:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (const GlobalValue *GV = dyn_cast<GlobalValue>(V))
|
2001-10-29 16:37:48 +00:00
|
|
|
return GV->getParent();
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-10-28 19:33:02 +00:00
|
|
|
// PrintEscapedString - Print each character of the specified string, escaping
|
|
|
|
// it if it is not printable or if it is an escape char.
|
2009-07-25 23:55:21 +00:00
|
|
|
static void PrintEscapedString(const StringRef &Name, raw_ostream &Out) {
|
|
|
|
for (unsigned i = 0, e = Name.size(); i != e; ++i) {
|
|
|
|
unsigned char C = Name[i];
|
2009-03-15 06:39:52 +00:00
|
|
|
if (isprint(C) && C != '\\' && C != '"')
|
2008-10-28 19:33:02 +00:00
|
|
|
Out << C;
|
|
|
|
else
|
|
|
|
Out << '\\' << hexdigit(C >> 4) << hexdigit(C & 0x0F);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-08-17 17:28:37 +00:00
|
|
|
enum PrefixType {
|
|
|
|
GlobalPrefix,
|
|
|
|
LabelPrefix,
|
2008-10-14 23:28:09 +00:00
|
|
|
LocalPrefix,
|
|
|
|
NoPrefix
|
2008-08-17 17:28:37 +00:00
|
|
|
};
|
|
|
|
|
2008-08-17 04:40:13 +00:00
|
|
|
/// PrintLLVMName - Turn the specified name into an 'LLVM name', which is either
|
|
|
|
/// prefixed with % (if the string only contains simple characters) or is
|
|
|
|
/// surrounded with ""'s (if it has special chars in it). Print it out.
|
2009-07-25 23:55:21 +00:00
|
|
|
static void PrintLLVMName(raw_ostream &OS, const StringRef &Name,
|
|
|
|
PrefixType Prefix) {
|
|
|
|
assert(Name.data() && "Cannot get empty name!");
|
2008-08-17 04:40:13 +00:00
|
|
|
switch (Prefix) {
|
2009-07-14 16:55:14 +00:00
|
|
|
default: llvm_unreachable("Bad prefix!");
|
2008-10-14 23:28:09 +00:00
|
|
|
case NoPrefix: break;
|
2008-08-19 05:16:28 +00:00
|
|
|
case GlobalPrefix: OS << '@'; break;
|
|
|
|
case LabelPrefix: break;
|
|
|
|
case LocalPrefix: OS << '%'; break;
|
2009-03-19 06:31:22 +00:00
|
|
|
}
|
2008-08-17 04:40:13 +00:00
|
|
|
|
|
|
|
// Scan the name to see if it needs quotes first.
|
2009-07-25 23:55:21 +00:00
|
|
|
bool NeedsQuotes = isdigit(Name[0]);
|
2008-08-17 04:40:13 +00:00
|
|
|
if (!NeedsQuotes) {
|
2009-07-25 23:55:21 +00:00
|
|
|
for (unsigned i = 0, e = Name.size(); i != e; ++i) {
|
|
|
|
char C = Name[i];
|
2008-08-17 04:40:13 +00:00
|
|
|
if (!isalnum(C) && C != '-' && C != '.' && C != '_') {
|
|
|
|
NeedsQuotes = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2008-08-19 04:36:02 +00:00
|
|
|
|
2008-08-17 04:40:13 +00:00
|
|
|
// If we didn't need any quotes, just write out the name in one blast.
|
|
|
|
if (!NeedsQuotes) {
|
2009-07-25 23:55:21 +00:00
|
|
|
OS << Name;
|
2008-08-17 04:40:13 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Okay, we need quotes. Output the quotes and escape any scary characters as
|
|
|
|
// needed.
|
|
|
|
OS << '"';
|
2009-07-25 23:55:21 +00:00
|
|
|
PrintEscapedString(Name, OS);
|
2008-08-17 04:40:13 +00:00
|
|
|
OS << '"';
|
|
|
|
}
|
|
|
|
|
2008-08-19 04:36:02 +00:00
|
|
|
/// PrintLLVMName - Turn the specified name into an 'LLVM name', which is either
|
|
|
|
/// prefixed with % (if the string only contains simple characters) or is
|
|
|
|
/// surrounded with ""'s (if it has special chars in it). Print it out.
|
2008-08-23 22:23:09 +00:00
|
|
|
static void PrintLLVMName(raw_ostream &OS, const Value *V) {
|
2009-07-25 23:55:21 +00:00
|
|
|
PrintLLVMName(OS, V->getName(),
|
2008-08-17 04:40:13 +00:00
|
|
|
isa<GlobalValue>(V) ? GlobalPrefix : LocalPrefix);
|
|
|
|
}
|
|
|
|
|
2009-02-28 20:25:14 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// TypePrinting Class: Type printing machinery
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2009-02-28 23:03:55 +00:00
|
|
|
static DenseMap<const Type *, std::string> &getTypeNamesMap(void *M) {
|
|
|
|
return *static_cast<DenseMap<const Type *, std::string>*>(M);
|
2009-02-28 22:34:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void TypePrinting::clear() {
|
|
|
|
getTypeNamesMap(TypeNames).clear();
|
|
|
|
}
|
2009-02-28 20:25:14 +00:00
|
|
|
|
2009-02-28 23:20:19 +00:00
|
|
|
bool TypePrinting::hasTypeName(const Type *Ty) const {
|
|
|
|
return getTypeNamesMap(TypeNames).count(Ty);
|
|
|
|
}
|
|
|
|
|
|
|
|
void TypePrinting::addTypeName(const Type *Ty, const std::string &N) {
|
|
|
|
getTypeNamesMap(TypeNames).insert(std::make_pair(Ty, N));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
TypePrinting::TypePrinting() {
|
2009-02-28 23:03:55 +00:00
|
|
|
TypeNames = new DenseMap<const Type *, std::string>();
|
2009-02-28 20:25:14 +00:00
|
|
|
}
|
|
|
|
|
2009-02-28 22:34:45 +00:00
|
|
|
TypePrinting::~TypePrinting() {
|
|
|
|
delete &getTypeNamesMap(TypeNames);
|
|
|
|
}
|
|
|
|
|
2009-02-28 20:49:40 +00:00
|
|
|
/// CalcTypeName - Write the specified type to the specified raw_ostream, making
|
|
|
|
/// use of type names or up references to shorten the type name where possible.
|
|
|
|
void TypePrinting::CalcTypeName(const Type *Ty,
|
2009-02-28 20:34:19 +00:00
|
|
|
SmallVectorImpl<const Type *> &TypeStack,
|
2009-03-01 01:16:21 +00:00
|
|
|
raw_ostream &OS, bool IgnoreTopLevelName) {
|
2009-02-28 20:25:14 +00:00
|
|
|
// Check to see if the type is named.
|
2009-03-01 01:16:21 +00:00
|
|
|
if (!IgnoreTopLevelName) {
|
2009-03-19 06:31:22 +00:00
|
|
|
DenseMap<const Type *, std::string> &TM = getTypeNamesMap(TypeNames);
|
2009-03-01 01:16:21 +00:00
|
|
|
DenseMap<const Type *, std::string>::iterator I = TM.find(Ty);
|
|
|
|
if (I != TM.end()) {
|
|
|
|
OS << I->second;
|
|
|
|
return;
|
|
|
|
}
|
2009-02-28 20:25:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Check to see if the Type is already on the stack...
|
|
|
|
unsigned Slot = 0, CurSize = TypeStack.size();
|
|
|
|
while (Slot < CurSize && TypeStack[Slot] != Ty) ++Slot; // Scan for type
|
|
|
|
|
|
|
|
// This is another base case for the recursion. In this case, we know
|
|
|
|
// that we have looped back to a type that we have previously visited.
|
|
|
|
// Generate the appropriate upreference to handle this.
|
|
|
|
if (Slot < CurSize) {
|
2009-02-28 21:27:31 +00:00
|
|
|
OS << '\\' << unsigned(CurSize-Slot); // Here's the upreference
|
2009-02-28 20:25:14 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
TypeStack.push_back(Ty); // Recursive case: Add us to the stack..
|
|
|
|
|
|
|
|
switch (Ty->getTypeID()) {
|
2009-02-28 21:27:31 +00:00
|
|
|
case Type::VoidTyID: OS << "void"; break;
|
|
|
|
case Type::FloatTyID: OS << "float"; break;
|
|
|
|
case Type::DoubleTyID: OS << "double"; break;
|
|
|
|
case Type::X86_FP80TyID: OS << "x86_fp80"; break;
|
|
|
|
case Type::FP128TyID: OS << "fp128"; break;
|
|
|
|
case Type::PPC_FP128TyID: OS << "ppc_fp128"; break;
|
|
|
|
case Type::LabelTyID: OS << "label"; break;
|
2009-05-30 05:06:04 +00:00
|
|
|
case Type::MetadataTyID: OS << "metadata"; break;
|
2009-02-28 21:18:43 +00:00
|
|
|
case Type::IntegerTyID:
|
2009-02-28 21:27:31 +00:00
|
|
|
OS << 'i' << cast<IntegerType>(Ty)->getBitWidth();
|
2009-02-28 21:18:43 +00:00
|
|
|
break;
|
|
|
|
|
2009-02-28 20:35:42 +00:00
|
|
|
case Type::FunctionTyID: {
|
|
|
|
const FunctionType *FTy = cast<FunctionType>(Ty);
|
2009-02-28 21:27:31 +00:00
|
|
|
CalcTypeName(FTy->getReturnType(), TypeStack, OS);
|
|
|
|
OS << " (";
|
2009-02-28 20:35:42 +00:00
|
|
|
for (FunctionType::param_iterator I = FTy->param_begin(),
|
|
|
|
E = FTy->param_end(); I != E; ++I) {
|
|
|
|
if (I != FTy->param_begin())
|
2009-02-28 21:27:31 +00:00
|
|
|
OS << ", ";
|
|
|
|
CalcTypeName(*I, TypeStack, OS);
|
2009-02-28 20:25:14 +00:00
|
|
|
}
|
2009-02-28 20:35:42 +00:00
|
|
|
if (FTy->isVarArg()) {
|
2009-02-28 21:27:31 +00:00
|
|
|
if (FTy->getNumParams()) OS << ", ";
|
|
|
|
OS << "...";
|
2009-02-28 20:25:14 +00:00
|
|
|
}
|
2009-02-28 21:27:31 +00:00
|
|
|
OS << ')';
|
2009-02-28 20:35:42 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case Type::StructTyID: {
|
|
|
|
const StructType *STy = cast<StructType>(Ty);
|
|
|
|
if (STy->isPacked())
|
2009-02-28 21:27:31 +00:00
|
|
|
OS << '<';
|
|
|
|
OS << "{ ";
|
2009-02-28 20:35:42 +00:00
|
|
|
for (StructType::element_iterator I = STy->element_begin(),
|
|
|
|
E = STy->element_end(); I != E; ++I) {
|
2009-02-28 21:27:31 +00:00
|
|
|
CalcTypeName(*I, TypeStack, OS);
|
2009-02-28 20:35:42 +00:00
|
|
|
if (next(I) != STy->element_end())
|
2009-02-28 21:27:31 +00:00
|
|
|
OS << ',';
|
|
|
|
OS << ' ';
|
2009-02-28 20:25:14 +00:00
|
|
|
}
|
2009-02-28 21:27:31 +00:00
|
|
|
OS << '}';
|
2009-02-28 20:35:42 +00:00
|
|
|
if (STy->isPacked())
|
2009-02-28 21:27:31 +00:00
|
|
|
OS << '>';
|
2009-02-28 20:35:42 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case Type::PointerTyID: {
|
|
|
|
const PointerType *PTy = cast<PointerType>(Ty);
|
2009-02-28 21:27:31 +00:00
|
|
|
CalcTypeName(PTy->getElementType(), TypeStack, OS);
|
2009-02-28 20:35:42 +00:00
|
|
|
if (unsigned AddressSpace = PTy->getAddressSpace())
|
2009-02-28 21:27:31 +00:00
|
|
|
OS << " addrspace(" << AddressSpace << ')';
|
|
|
|
OS << '*';
|
2009-02-28 20:35:42 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case Type::ArrayTyID: {
|
|
|
|
const ArrayType *ATy = cast<ArrayType>(Ty);
|
2009-02-28 21:27:31 +00:00
|
|
|
OS << '[' << ATy->getNumElements() << " x ";
|
|
|
|
CalcTypeName(ATy->getElementType(), TypeStack, OS);
|
|
|
|
OS << ']';
|
2009-02-28 20:35:42 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case Type::VectorTyID: {
|
|
|
|
const VectorType *PTy = cast<VectorType>(Ty);
|
2009-02-28 21:27:31 +00:00
|
|
|
OS << "<" << PTy->getNumElements() << " x ";
|
|
|
|
CalcTypeName(PTy->getElementType(), TypeStack, OS);
|
|
|
|
OS << '>';
|
2009-02-28 20:35:42 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case Type::OpaqueTyID:
|
2009-02-28 21:27:31 +00:00
|
|
|
OS << "opaque";
|
2009-02-28 20:35:42 +00:00
|
|
|
break;
|
|
|
|
default:
|
2009-02-28 21:27:31 +00:00
|
|
|
OS << "<unrecognized-type>";
|
2009-02-28 20:35:42 +00:00
|
|
|
break;
|
2009-02-28 20:25:14 +00:00
|
|
|
}
|
|
|
|
|
2009-02-28 20:49:40 +00:00
|
|
|
TypeStack.pop_back(); // Remove self from stack.
|
2009-02-28 20:25:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// printTypeInt - The internal guts of printing out a type that has a
|
|
|
|
/// potentially named portion.
|
|
|
|
///
|
2009-03-01 01:16:21 +00:00
|
|
|
void TypePrinting::print(const Type *Ty, raw_ostream &OS,
|
|
|
|
bool IgnoreTopLevelName) {
|
2009-02-28 20:25:14 +00:00
|
|
|
// Check to see if the type is named.
|
2009-02-28 23:03:55 +00:00
|
|
|
DenseMap<const Type*, std::string> &TM = getTypeNamesMap(TypeNames);
|
2009-03-01 01:16:21 +00:00
|
|
|
if (!IgnoreTopLevelName) {
|
|
|
|
DenseMap<const Type*, std::string>::iterator I = TM.find(Ty);
|
|
|
|
if (I != TM.end()) {
|
|
|
|
OS << I->second;
|
|
|
|
return;
|
|
|
|
}
|
2009-02-28 20:25:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Otherwise we have a type that has not been named but is a derived type.
|
|
|
|
// Carefully recurse the type hierarchy to print out any contained symbolic
|
|
|
|
// names.
|
2009-02-28 20:34:19 +00:00
|
|
|
SmallVector<const Type *, 16> TypeStack;
|
2009-02-28 20:25:14 +00:00
|
|
|
std::string TypeName;
|
2009-02-28 20:49:40 +00:00
|
|
|
|
|
|
|
raw_string_ostream TypeOS(TypeName);
|
2009-03-01 01:16:21 +00:00
|
|
|
CalcTypeName(Ty, TypeStack, TypeOS, IgnoreTopLevelName);
|
2009-02-28 20:49:40 +00:00
|
|
|
OS << TypeOS.str();
|
|
|
|
|
|
|
|
// Cache type name for later use.
|
2009-03-01 01:16:21 +00:00
|
|
|
if (!IgnoreTopLevelName)
|
|
|
|
TM.insert(std::make_pair(Ty, TypeOS.str()));
|
2009-02-28 20:25:14 +00:00
|
|
|
}
|
|
|
|
|
2009-03-01 00:03:38 +00:00
|
|
|
namespace {
|
|
|
|
class TypeFinder {
|
|
|
|
// To avoid walking constant expressions multiple times and other IR
|
|
|
|
// objects, we keep several helper maps.
|
|
|
|
DenseSet<const Value*> VisitedConstants;
|
|
|
|
DenseSet<const Type*> VisitedTypes;
|
|
|
|
|
|
|
|
TypePrinting &TP;
|
|
|
|
std::vector<const Type*> &NumberedTypes;
|
|
|
|
public:
|
|
|
|
TypeFinder(TypePrinting &tp, std::vector<const Type*> &numberedTypes)
|
|
|
|
: TP(tp), NumberedTypes(numberedTypes) {}
|
|
|
|
|
|
|
|
void Run(const Module &M) {
|
2009-03-01 00:32:33 +00:00
|
|
|
// Get types from the type symbol table. This gets opaque types referened
|
|
|
|
// only through derived named types.
|
|
|
|
const TypeSymbolTable &ST = M.getTypeSymbolTable();
|
|
|
|
for (TypeSymbolTable::const_iterator TI = ST.begin(), E = ST.end();
|
|
|
|
TI != E; ++TI)
|
|
|
|
IncorporateType(TI->second);
|
|
|
|
|
2009-03-01 00:03:38 +00:00
|
|
|
// Get types from global variables.
|
|
|
|
for (Module::const_global_iterator I = M.global_begin(),
|
|
|
|
E = M.global_end(); I != E; ++I) {
|
|
|
|
IncorporateType(I->getType());
|
|
|
|
if (I->hasInitializer())
|
|
|
|
IncorporateValue(I->getInitializer());
|
|
|
|
}
|
|
|
|
|
|
|
|
// Get types from aliases.
|
|
|
|
for (Module::const_alias_iterator I = M.alias_begin(),
|
|
|
|
E = M.alias_end(); I != E; ++I) {
|
|
|
|
IncorporateType(I->getType());
|
|
|
|
IncorporateValue(I->getAliasee());
|
|
|
|
}
|
|
|
|
|
|
|
|
// Get types from functions.
|
|
|
|
for (Module::const_iterator FI = M.begin(), E = M.end(); FI != E; ++FI) {
|
|
|
|
IncorporateType(FI->getType());
|
|
|
|
|
|
|
|
for (Function::const_iterator BB = FI->begin(), E = FI->end();
|
|
|
|
BB != E;++BB)
|
|
|
|
for (BasicBlock::const_iterator II = BB->begin(),
|
|
|
|
E = BB->end(); II != E; ++II) {
|
|
|
|
const Instruction &I = *II;
|
|
|
|
// Incorporate the type of the instruction and all its operands.
|
|
|
|
IncorporateType(I.getType());
|
|
|
|
for (User::const_op_iterator OI = I.op_begin(), OE = I.op_end();
|
|
|
|
OI != OE; ++OI)
|
|
|
|
IncorporateValue(*OI);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
void IncorporateType(const Type *Ty) {
|
|
|
|
// Check to see if we're already visited this type.
|
2009-03-01 00:32:33 +00:00
|
|
|
if (!VisitedTypes.insert(Ty).second)
|
2009-03-01 00:03:38 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
// If this is a structure or opaque type, add a name for the type.
|
2009-04-04 07:22:01 +00:00
|
|
|
if (((isa<StructType>(Ty) && cast<StructType>(Ty)->getNumElements())
|
|
|
|
|| isa<OpaqueType>(Ty)) && !TP.hasTypeName(Ty)) {
|
2009-03-01 00:03:38 +00:00
|
|
|
TP.addTypeName(Ty, "%"+utostr(unsigned(NumberedTypes.size())));
|
|
|
|
NumberedTypes.push_back(Ty);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Recursively walk all contained types.
|
|
|
|
for (Type::subtype_iterator I = Ty->subtype_begin(),
|
|
|
|
E = Ty->subtype_end(); I != E; ++I)
|
|
|
|
IncorporateType(*I);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// IncorporateValue - This method is used to walk operand lists finding
|
|
|
|
/// types hiding in constant expressions and other operands that won't be
|
|
|
|
/// walked in other ways. GlobalValues, basic blocks, instructions, and
|
|
|
|
/// inst operands are all explicitly enumerated.
|
|
|
|
void IncorporateValue(const Value *V) {
|
|
|
|
if (V == 0 || !isa<Constant>(V) || isa<GlobalValue>(V)) return;
|
|
|
|
|
|
|
|
// Already visited?
|
|
|
|
if (!VisitedConstants.insert(V).second)
|
|
|
|
return;
|
|
|
|
|
|
|
|
// Check this type.
|
|
|
|
IncorporateType(V->getType());
|
|
|
|
|
|
|
|
// Look in operands for types.
|
|
|
|
const Constant *C = cast<Constant>(V);
|
|
|
|
for (Constant::const_op_iterator I = C->op_begin(),
|
|
|
|
E = C->op_end(); I != E;++I)
|
|
|
|
IncorporateValue(*I);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
} // end anonymous namespace
|
|
|
|
|
|
|
|
|
|
|
|
/// AddModuleTypesToPrinter - Add all of the symbolic type names for types in
|
|
|
|
/// the specified module to the TypePrinter and all numbered types to it and the
|
|
|
|
/// NumberedTypes table.
|
|
|
|
static void AddModuleTypesToPrinter(TypePrinting &TP,
|
|
|
|
std::vector<const Type*> &NumberedTypes,
|
|
|
|
const Module *M) {
|
2009-02-28 23:20:19 +00:00
|
|
|
if (M == 0) return;
|
|
|
|
|
|
|
|
// If the module has a symbol table, take all global types and stuff their
|
|
|
|
// names into the TypeNames map.
|
|
|
|
const TypeSymbolTable &ST = M->getTypeSymbolTable();
|
|
|
|
for (TypeSymbolTable::const_iterator TI = ST.begin(), E = ST.end();
|
|
|
|
TI != E; ++TI) {
|
|
|
|
const Type *Ty = cast<Type>(TI->second);
|
|
|
|
|
|
|
|
// As a heuristic, don't insert pointer to primitive types, because
|
|
|
|
// they are used too often to have a single useful name.
|
|
|
|
if (const PointerType *PTy = dyn_cast<PointerType>(Ty)) {
|
|
|
|
const Type *PETy = PTy->getElementType();
|
|
|
|
if ((PETy->isPrimitiveType() || PETy->isInteger()) &&
|
|
|
|
!isa<OpaqueType>(PETy))
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Likewise don't insert primitives either.
|
|
|
|
if (Ty->isInteger() || Ty->isPrimitiveType())
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// Get the name as a string and insert it into TypeNames.
|
|
|
|
std::string NameStr;
|
|
|
|
raw_string_ostream NameOS(NameStr);
|
2009-07-25 23:55:21 +00:00
|
|
|
PrintLLVMName(NameOS, TI->first, LocalPrefix);
|
2009-02-28 23:20:19 +00:00
|
|
|
TP.addTypeName(Ty, NameOS.str());
|
|
|
|
}
|
2009-03-01 00:03:38 +00:00
|
|
|
|
|
|
|
// Walk the entire module to find references to unnamed structure and opaque
|
|
|
|
// types. This is required for correctness by opaque types (because multiple
|
|
|
|
// uses of an unnamed opaque type needs to be referred to by the same ID) and
|
|
|
|
// it shrinks complex recursive structure types substantially in some cases.
|
|
|
|
TypeFinder(TP, NumberedTypes).Run(*M);
|
2009-02-28 23:20:19 +00:00
|
|
|
}
|
|
|
|
|
2009-02-28 20:25:14 +00:00
|
|
|
|
|
|
|
/// WriteTypeSymbolic - This attempts to write the specified type as a symbolic
|
|
|
|
/// type, iff there is an entry in the modules symbol table for the specified
|
2009-02-28 21:05:51 +00:00
|
|
|
/// type or one of it's component types.
|
2009-02-28 20:25:14 +00:00
|
|
|
///
|
2009-02-28 23:20:19 +00:00
|
|
|
void llvm::WriteTypeSymbolic(raw_ostream &OS, const Type *Ty, const Module *M) {
|
|
|
|
TypePrinting Printer;
|
2009-03-01 00:03:38 +00:00
|
|
|
std::vector<const Type*> NumberedTypes;
|
|
|
|
AddModuleTypesToPrinter(Printer, NumberedTypes, M);
|
2009-02-28 23:20:19 +00:00
|
|
|
Printer.print(Ty, OS);
|
2009-02-28 20:25:14 +00:00
|
|
|
}
|
|
|
|
|
2008-08-19 04:36:02 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// SlotTracker Class: Enumerate slot numbers for unnamed values
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
|
|
|
|
/// This class provides computation of slot numbers for LLVM Assembly writing.
|
|
|
|
///
|
|
|
|
class SlotTracker {
|
|
|
|
public:
|
2009-07-08 21:44:25 +00:00
|
|
|
/// ValueMap - A mapping of Values to slot numbers.
|
2008-08-19 04:36:02 +00:00
|
|
|
typedef DenseMap<const Value*, unsigned> ValueMap;
|
|
|
|
|
|
|
|
private:
|
2009-07-08 21:44:25 +00:00
|
|
|
/// TheModule - The module for which we are holding slot numbers.
|
2008-08-19 04:36:02 +00:00
|
|
|
const Module* TheModule;
|
|
|
|
|
2009-07-08 21:44:25 +00:00
|
|
|
/// TheFunction - The function for which we are holding slot numbers.
|
2008-08-19 04:36:02 +00:00
|
|
|
const Function* TheFunction;
|
|
|
|
bool FunctionProcessed;
|
|
|
|
|
2009-07-08 21:44:25 +00:00
|
|
|
/// TheMDNode - The MDNode for which we are holding slot numbers.
|
|
|
|
const MDNode *TheMDNode;
|
|
|
|
|
2009-07-30 00:02:57 +00:00
|
|
|
/// TheNamedMDNode - The MDNode for which we are holding slot numbers.
|
|
|
|
const NamedMDNode *TheNamedMDNode;
|
|
|
|
|
2009-07-08 21:44:25 +00:00
|
|
|
/// mMap - The TypePlanes map for the module level data.
|
2008-08-19 04:36:02 +00:00
|
|
|
ValueMap mMap;
|
|
|
|
unsigned mNext;
|
|
|
|
|
2009-07-08 21:44:25 +00:00
|
|
|
/// fMap - The TypePlanes map for the function level data.
|
2008-08-19 04:36:02 +00:00
|
|
|
ValueMap fMap;
|
|
|
|
unsigned fNext;
|
|
|
|
|
2009-07-08 21:44:25 +00:00
|
|
|
/// mdnMap - Map for MDNodes.
|
|
|
|
ValueMap mdnMap;
|
|
|
|
unsigned mdnNext;
|
2008-08-19 04:36:02 +00:00
|
|
|
public:
|
|
|
|
/// Construct from a module
|
|
|
|
explicit SlotTracker(const Module *M);
|
|
|
|
/// Construct from a function, starting out in incorp state.
|
|
|
|
explicit SlotTracker(const Function *F);
|
2009-07-08 21:44:25 +00:00
|
|
|
/// Construct from a mdnode.
|
|
|
|
explicit SlotTracker(const MDNode *N);
|
2009-07-30 00:02:57 +00:00
|
|
|
/// Construct from a named mdnode.
|
|
|
|
explicit SlotTracker(const NamedMDNode *N);
|
2008-08-19 04:36:02 +00:00
|
|
|
|
|
|
|
/// Return the slot number of the specified value in it's type
|
|
|
|
/// plane. If something is not in the SlotTracker, return -1.
|
|
|
|
int getLocalSlot(const Value *V);
|
|
|
|
int getGlobalSlot(const GlobalValue *V);
|
2009-07-08 21:44:25 +00:00
|
|
|
int getMetadataSlot(const MDNode *N);
|
2008-08-19 04:36:02 +00:00
|
|
|
|
|
|
|
/// If you'd like to deal with a function instead of just a module, use
|
|
|
|
/// this method to get its data into the SlotTracker.
|
|
|
|
void incorporateFunction(const Function *F) {
|
|
|
|
TheFunction = F;
|
|
|
|
FunctionProcessed = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// After calling incorporateFunction, use this method to remove the
|
|
|
|
/// most recently incorporated function from the SlotTracker. This
|
|
|
|
/// will reset the state of the machine back to just the module contents.
|
|
|
|
void purgeFunction();
|
|
|
|
|
2009-07-08 21:44:25 +00:00
|
|
|
/// MDNode map iterators.
|
|
|
|
ValueMap::iterator mdnBegin() { return mdnMap.begin(); }
|
|
|
|
ValueMap::iterator mdnEnd() { return mdnMap.end(); }
|
|
|
|
unsigned mdnSize() { return mdnMap.size(); }
|
|
|
|
|
2008-08-19 04:36:02 +00:00
|
|
|
/// This function does the actual initialization.
|
|
|
|
inline void initialize();
|
|
|
|
|
2009-07-08 21:44:25 +00:00
|
|
|
// Implementation Details
|
|
|
|
private:
|
2008-08-19 04:36:02 +00:00
|
|
|
/// CreateModuleSlot - Insert the specified GlobalValue* into the slot table.
|
|
|
|
void CreateModuleSlot(const GlobalValue *V);
|
2009-07-08 21:44:25 +00:00
|
|
|
|
|
|
|
/// CreateMetadataSlot - Insert the specified MDNode* into the slot table.
|
|
|
|
void CreateMetadataSlot(const MDNode *N);
|
|
|
|
|
2008-08-19 04:36:02 +00:00
|
|
|
/// 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.
|
|
|
|
void processModule();
|
|
|
|
|
2009-07-08 21:44:25 +00:00
|
|
|
/// Add all of the functions arguments, basic blocks, and instructions.
|
2008-08-19 04:36:02 +00:00
|
|
|
void processFunction();
|
|
|
|
|
2009-07-08 21:44:25 +00:00
|
|
|
/// Add all MDNode operands.
|
|
|
|
void processMDNode();
|
|
|
|
|
2009-07-30 00:02:57 +00:00
|
|
|
/// Add all MDNode operands.
|
|
|
|
void processNamedMDNode();
|
|
|
|
|
2008-08-19 04:36:02 +00:00
|
|
|
SlotTracker(const SlotTracker &); // DO NOT IMPLEMENT
|
|
|
|
void operator=(const SlotTracker &); // DO NOT IMPLEMENT
|
|
|
|
};
|
|
|
|
|
|
|
|
} // end anonymous namespace
|
|
|
|
|
|
|
|
|
|
|
|
static SlotTracker *createSlotTracker(const Value *V) {
|
|
|
|
if (const Argument *FA = dyn_cast<Argument>(V))
|
|
|
|
return new SlotTracker(FA->getParent());
|
|
|
|
|
|
|
|
if (const Instruction *I = dyn_cast<Instruction>(V))
|
|
|
|
return new SlotTracker(I->getParent()->getParent());
|
|
|
|
|
|
|
|
if (const BasicBlock *BB = dyn_cast<BasicBlock>(V))
|
|
|
|
return new SlotTracker(BB->getParent());
|
|
|
|
|
|
|
|
if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(V))
|
|
|
|
return new SlotTracker(GV->getParent());
|
|
|
|
|
|
|
|
if (const GlobalAlias *GA = dyn_cast<GlobalAlias>(V))
|
|
|
|
return new SlotTracker(GA->getParent());
|
|
|
|
|
|
|
|
if (const Function *Func = dyn_cast<Function>(V))
|
|
|
|
return new SlotTracker(Func);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#if 0
|
2009-07-25 01:43:01 +00:00
|
|
|
#define ST_DEBUG(X) errs() << X
|
2008-08-19 04:36:02 +00:00
|
|
|
#else
|
2008-08-19 04:47:09 +00:00
|
|
|
#define ST_DEBUG(X)
|
2008-08-19 04:36:02 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
// Module level constructor. Causes the contents of the Module (sans functions)
|
|
|
|
// to be added to the slot table.
|
|
|
|
SlotTracker::SlotTracker(const Module *M)
|
2009-07-08 21:44:25 +00:00
|
|
|
: TheModule(M), TheFunction(0), FunctionProcessed(false), TheMDNode(0),
|
2009-07-30 00:02:57 +00:00
|
|
|
TheNamedMDNode(0), mNext(0), fNext(0), mdnNext(0) {
|
2008-08-19 04:36:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Function level constructor. Causes the contents of the Module and the one
|
|
|
|
// function provided to be added to the slot table.
|
|
|
|
SlotTracker::SlotTracker(const Function *F)
|
2008-08-19 05:06:27 +00:00
|
|
|
: TheModule(F ? F->getParent() : 0), TheFunction(F), FunctionProcessed(false),
|
2009-07-30 00:02:57 +00:00
|
|
|
TheMDNode(0), TheNamedMDNode(0), mNext(0), fNext(0), mdnNext(0) {
|
2009-07-08 21:44:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Constructor to handle single MDNode.
|
|
|
|
SlotTracker::SlotTracker(const MDNode *C)
|
|
|
|
: TheModule(0), TheFunction(0), FunctionProcessed(false), TheMDNode(C),
|
2009-07-30 00:02:57 +00:00
|
|
|
TheNamedMDNode(0), mNext(0), fNext(0), mdnNext(0) {
|
|
|
|
}
|
|
|
|
|
|
|
|
// Constructor to handle single NamedMDNode.
|
|
|
|
SlotTracker::SlotTracker(const NamedMDNode *N)
|
|
|
|
: TheModule(0), TheFunction(0), FunctionProcessed(false), TheMDNode(0),
|
|
|
|
TheNamedMDNode(N), mNext(0), fNext(0), mdnNext(0) {
|
2008-08-19 04:36:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
inline void SlotTracker::initialize() {
|
|
|
|
if (TheModule) {
|
|
|
|
processModule();
|
|
|
|
TheModule = 0; ///< Prevent re-processing next time we're called.
|
|
|
|
}
|
2008-08-19 05:06:27 +00:00
|
|
|
|
2008-08-19 04:36:02 +00:00
|
|
|
if (TheFunction && !FunctionProcessed)
|
|
|
|
processFunction();
|
2009-07-08 21:44:25 +00:00
|
|
|
|
|
|
|
if (TheMDNode)
|
|
|
|
processMDNode();
|
2009-07-30 00:02:57 +00:00
|
|
|
|
|
|
|
if (TheNamedMDNode)
|
|
|
|
processNamedMDNode();
|
2008-08-19 04:36:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Iterate through all the global variables, functions, and global
|
|
|
|
// variable initializers and create slots for them.
|
|
|
|
void SlotTracker::processModule() {
|
2008-08-19 04:47:09 +00:00
|
|
|
ST_DEBUG("begin processModule!\n");
|
2008-08-19 04:36:02 +00:00
|
|
|
|
|
|
|
// Add all of the unnamed global variables to the value table.
|
|
|
|
for (Module::const_global_iterator I = TheModule->global_begin(),
|
2009-07-08 21:44:25 +00:00
|
|
|
E = TheModule->global_end(); I != E; ++I) {
|
2008-08-19 04:36:02 +00:00
|
|
|
if (!I->hasName())
|
|
|
|
CreateModuleSlot(I);
|
2009-07-08 21:44:25 +00:00
|
|
|
if (I->hasInitializer()) {
|
|
|
|
if (MDNode *N = dyn_cast<MDNode>(I->getInitializer()))
|
|
|
|
CreateMetadataSlot(N);
|
|
|
|
}
|
|
|
|
}
|
2008-08-19 04:36:02 +00:00
|
|
|
|
2009-07-29 22:04:47 +00:00
|
|
|
// Add metadata used by named metadata.
|
|
|
|
for (Module::const_named_metadata_iterator
|
|
|
|
I = TheModule->named_metadata_begin(),
|
|
|
|
E = TheModule->named_metadata_end(); I != E; ++I) {
|
|
|
|
const NamedMDNode *NMD = I;
|
|
|
|
for (unsigned i = 0, e = NMD->getNumElements(); i != e; ++i) {
|
|
|
|
MDNode *MD = dyn_cast_or_null<MDNode>(NMD->getElement(i));
|
2009-07-30 01:02:04 +00:00
|
|
|
if (MD)
|
|
|
|
CreateMetadataSlot(MD);
|
2009-07-29 22:04:47 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-08-19 04:36:02 +00:00
|
|
|
// Add all the unnamed functions to the table.
|
|
|
|
for (Module::const_iterator I = TheModule->begin(), E = TheModule->end();
|
|
|
|
I != E; ++I)
|
|
|
|
if (!I->hasName())
|
|
|
|
CreateModuleSlot(I);
|
|
|
|
|
2008-08-19 04:47:09 +00:00
|
|
|
ST_DEBUG("end processModule!\n");
|
2008-08-19 04:36:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Process the arguments, basic blocks, and instructions of a function.
|
|
|
|
void SlotTracker::processFunction() {
|
2008-08-19 04:47:09 +00:00
|
|
|
ST_DEBUG("begin processFunction!\n");
|
2008-08-19 04:36:02 +00:00
|
|
|
fNext = 0;
|
|
|
|
|
|
|
|
// Add all the function arguments with no names.
|
|
|
|
for(Function::const_arg_iterator AI = TheFunction->arg_begin(),
|
|
|
|
AE = TheFunction->arg_end(); AI != AE; ++AI)
|
|
|
|
if (!AI->hasName())
|
|
|
|
CreateFunctionSlot(AI);
|
|
|
|
|
2008-08-19 04:47:09 +00:00
|
|
|
ST_DEBUG("Inserting Instructions:\n");
|
2008-08-19 04:36:02 +00:00
|
|
|
|
|
|
|
// Add all of the basic blocks and instructions with no names.
|
|
|
|
for (Function::const_iterator BB = TheFunction->begin(),
|
|
|
|
E = TheFunction->end(); BB != E; ++BB) {
|
|
|
|
if (!BB->hasName())
|
|
|
|
CreateFunctionSlot(BB);
|
2009-07-08 21:44:25 +00:00
|
|
|
for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I != E;
|
|
|
|
++I) {
|
2008-08-19 04:36:02 +00:00
|
|
|
if (I->getType() != Type::VoidTy && !I->hasName())
|
|
|
|
CreateFunctionSlot(I);
|
2009-07-08 21:44:25 +00:00
|
|
|
for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i)
|
|
|
|
if (MDNode *N = dyn_cast<MDNode>(I->getOperand(i)))
|
|
|
|
CreateMetadataSlot(N);
|
|
|
|
}
|
2008-08-19 04:36:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
FunctionProcessed = true;
|
|
|
|
|
2008-08-19 04:47:09 +00:00
|
|
|
ST_DEBUG("end processFunction!\n");
|
2008-08-19 04:36:02 +00:00
|
|
|
}
|
|
|
|
|
2009-07-08 21:44:25 +00:00
|
|
|
/// processMDNode - Process TheMDNode.
|
|
|
|
void SlotTracker::processMDNode() {
|
|
|
|
ST_DEBUG("begin processMDNode!\n");
|
|
|
|
mdnNext = 0;
|
|
|
|
CreateMetadataSlot(TheMDNode);
|
|
|
|
TheMDNode = 0;
|
|
|
|
ST_DEBUG("end processMDNode!\n");
|
|
|
|
}
|
|
|
|
|
2009-07-30 00:02:57 +00:00
|
|
|
/// processNamedMDNode - Process TheNamedMDNode.
|
|
|
|
void SlotTracker::processNamedMDNode() {
|
|
|
|
ST_DEBUG("begin processNamedMDNode!\n");
|
|
|
|
mdnNext = 0;
|
|
|
|
for (unsigned i = 0, e = TheNamedMDNode->getNumElements(); i != e; ++i) {
|
|
|
|
MDNode *MD = dyn_cast_or_null<MDNode>(TheNamedMDNode->getElement(i));
|
|
|
|
if (MD)
|
|
|
|
CreateMetadataSlot(MD);
|
|
|
|
}
|
|
|
|
TheNamedMDNode = 0;
|
|
|
|
ST_DEBUG("end processNamedMDNode!\n");
|
|
|
|
}
|
|
|
|
|
2008-08-19 04:36:02 +00:00
|
|
|
/// Clean up after incorporating a function. This is the only way to get out of
|
|
|
|
/// the function incorporation state that affects get*Slot/Create*Slot. Function
|
|
|
|
/// incorporation state is indicated by TheFunction != 0.
|
|
|
|
void SlotTracker::purgeFunction() {
|
2008-08-19 04:47:09 +00:00
|
|
|
ST_DEBUG("begin purgeFunction!\n");
|
2008-08-19 04:36:02 +00:00
|
|
|
fMap.clear(); // Simply discard the function level map
|
|
|
|
TheFunction = 0;
|
|
|
|
FunctionProcessed = false;
|
2008-08-19 04:47:09 +00:00
|
|
|
ST_DEBUG("end purgeFunction!\n");
|
2008-08-19 04:36:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// getGlobalSlot - Get the slot number of a global value.
|
|
|
|
int SlotTracker::getGlobalSlot(const GlobalValue *V) {
|
|
|
|
// Check for uninitialized state and do lazy initialization.
|
|
|
|
initialize();
|
|
|
|
|
|
|
|
// Find the type plane in the module map
|
|
|
|
ValueMap::iterator MI = mMap.find(V);
|
2008-10-01 19:58:59 +00:00
|
|
|
return MI == mMap.end() ? -1 : (int)MI->second;
|
2008-08-19 04:36:02 +00:00
|
|
|
}
|
|
|
|
|
2009-07-08 21:44:25 +00:00
|
|
|
/// getGlobalSlot - Get the slot number of a MDNode.
|
|
|
|
int SlotTracker::getMetadataSlot(const MDNode *N) {
|
|
|
|
// Check for uninitialized state and do lazy initialization.
|
|
|
|
initialize();
|
|
|
|
|
|
|
|
// Find the type plane in the module map
|
|
|
|
ValueMap::iterator MI = mdnMap.find(N);
|
|
|
|
return MI == mdnMap.end() ? -1 : (int)MI->second;
|
|
|
|
}
|
|
|
|
|
2008-08-19 04:36:02 +00:00
|
|
|
|
|
|
|
/// getLocalSlot - Get the slot number for a value that is local to a function.
|
|
|
|
int SlotTracker::getLocalSlot(const Value *V) {
|
|
|
|
assert(!isa<Constant>(V) && "Can't get a constant or global slot with this!");
|
|
|
|
|
|
|
|
// Check for uninitialized state and do lazy initialization.
|
|
|
|
initialize();
|
|
|
|
|
|
|
|
ValueMap::iterator FI = fMap.find(V);
|
2008-10-01 19:58:59 +00:00
|
|
|
return FI == fMap.end() ? -1 : (int)FI->second;
|
2008-08-19 04:36:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// CreateModuleSlot - Insert the specified GlobalValue* into the slot table.
|
|
|
|
void SlotTracker::CreateModuleSlot(const GlobalValue *V) {
|
|
|
|
assert(V && "Can't insert a null Value into SlotTracker!");
|
|
|
|
assert(V->getType() != Type::VoidTy && "Doesn't need a slot!");
|
|
|
|
assert(!V->hasName() && "Doesn't need a slot!");
|
|
|
|
|
|
|
|
unsigned DestSlot = mNext++;
|
|
|
|
mMap[V] = DestSlot;
|
|
|
|
|
2008-08-19 04:47:09 +00:00
|
|
|
ST_DEBUG(" Inserting value [" << V->getType() << "] = " << V << " slot=" <<
|
2008-08-19 04:36:02 +00:00
|
|
|
DestSlot << " [");
|
|
|
|
// G = Global, F = Function, A = Alias, o = other
|
2008-08-19 04:47:09 +00:00
|
|
|
ST_DEBUG((isa<GlobalVariable>(V) ? 'G' :
|
2008-08-19 04:36:02 +00:00
|
|
|
(isa<Function>(V) ? 'F' :
|
|
|
|
(isa<GlobalAlias>(V) ? 'A' : 'o'))) << "]\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
/// CreateSlot - Create a new slot for the specified value if it has no name.
|
|
|
|
void SlotTracker::CreateFunctionSlot(const Value *V) {
|
|
|
|
assert(V->getType() != Type::VoidTy && !V->hasName() &&
|
|
|
|
"Doesn't need a slot!");
|
|
|
|
|
|
|
|
unsigned DestSlot = fNext++;
|
|
|
|
fMap[V] = DestSlot;
|
|
|
|
|
|
|
|
// G = Global, F = Function, o = other
|
2008-08-19 04:47:09 +00:00
|
|
|
ST_DEBUG(" Inserting value [" << V->getType() << "] = " << V << " slot=" <<
|
2008-08-19 04:36:02 +00:00
|
|
|
DestSlot << " [o]\n");
|
|
|
|
}
|
|
|
|
|
2009-07-08 21:44:25 +00:00
|
|
|
/// CreateModuleSlot - Insert the specified MDNode* into the slot table.
|
|
|
|
void SlotTracker::CreateMetadataSlot(const MDNode *N) {
|
|
|
|
assert(N && "Can't insert a null Value into SlotTracker!");
|
|
|
|
|
|
|
|
ValueMap::iterator I = mdnMap.find(N);
|
|
|
|
if (I != mdnMap.end())
|
|
|
|
return;
|
|
|
|
|
|
|
|
unsigned DestSlot = mdnNext++;
|
|
|
|
mdnMap[N] = DestSlot;
|
2008-08-19 04:36:02 +00:00
|
|
|
|
2009-07-08 21:44:25 +00:00
|
|
|
for (MDNode::const_elem_iterator MDI = N->elem_begin(),
|
|
|
|
MDE = N->elem_end(); MDI != MDE; ++MDI) {
|
|
|
|
const Value *TV = *MDI;
|
|
|
|
if (TV)
|
|
|
|
if (const MDNode *N2 = dyn_cast<MDNode>(TV))
|
|
|
|
CreateMetadataSlot(N2);
|
|
|
|
}
|
|
|
|
}
|
2008-08-19 04:36:02 +00:00
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// AsmWriter Implementation
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2008-08-23 22:23:09 +00:00
|
|
|
static void WriteAsOperandInternal(raw_ostream &Out, const Value *V,
|
2009-02-28 20:25:14 +00:00
|
|
|
TypePrinting &TypePrinter,
|
2008-08-19 04:36:02 +00:00
|
|
|
SlotTracker *Machine);
|
|
|
|
|
|
|
|
|
|
|
|
|
2006-12-06 06:40:49 +00:00
|
|
|
static const char *getPredicateText(unsigned predicate) {
|
2006-12-04 05:19:18 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2009-07-08 21:44:25 +00:00
|
|
|
static void WriteMDNodes(raw_ostream &Out, TypePrinting &TypePrinter,
|
|
|
|
SlotTracker &Machine) {
|
|
|
|
SmallVector<const MDNode *, 16> Nodes;
|
|
|
|
Nodes.resize(Machine.mdnSize());
|
|
|
|
for (SlotTracker::ValueMap::iterator I =
|
|
|
|
Machine.mdnBegin(), E = Machine.mdnEnd(); I != E; ++I)
|
|
|
|
Nodes[I->second] = cast<MDNode>(I->first);
|
|
|
|
|
|
|
|
for (unsigned i = 0, e = Nodes.size(); i != e; ++i) {
|
2009-07-08 21:57:07 +00:00
|
|
|
Out << '!' << i << " = metadata ";
|
2009-07-08 21:44:25 +00:00
|
|
|
const MDNode *Node = Nodes[i];
|
|
|
|
Out << "!{";
|
|
|
|
for (MDNode::const_elem_iterator NI = Node->elem_begin(),
|
|
|
|
NE = Node->elem_end(); NI != NE;) {
|
|
|
|
const Value *V = *NI;
|
|
|
|
if (!V)
|
|
|
|
Out << "null";
|
|
|
|
else if (const MDNode *N = dyn_cast<MDNode>(V)) {
|
|
|
|
Out << "metadata ";
|
|
|
|
Out << '!' << Machine.getMetadataSlot(N);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
TypePrinter.print((*NI)->getType(), Out);
|
|
|
|
Out << ' ';
|
|
|
|
WriteAsOperandInternal(Out, *NI, TypePrinter, &Machine);
|
|
|
|
}
|
|
|
|
if (++NI != NE)
|
|
|
|
Out << ", ";
|
|
|
|
}
|
|
|
|
Out << "}\n";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-07-20 21:19:07 +00:00
|
|
|
static void WriteOptimizationInfo(raw_ostream &Out, const User *U) {
|
|
|
|
if (const OverflowingBinaryOperator *OBO =
|
|
|
|
dyn_cast<OverflowingBinaryOperator>(U)) {
|
|
|
|
if (OBO->hasNoUnsignedOverflow())
|
2009-07-27 16:11:46 +00:00
|
|
|
Out << " nuw";
|
2009-07-20 21:19:07 +00:00
|
|
|
if (OBO->hasNoSignedOverflow())
|
2009-07-27 16:11:46 +00:00
|
|
|
Out << " nsw";
|
2009-07-20 21:19:07 +00:00
|
|
|
} else if (const SDivOperator *Div = dyn_cast<SDivOperator>(U)) {
|
|
|
|
if (Div->isExact())
|
2009-07-27 16:11:46 +00:00
|
|
|
Out << " exact";
|
2009-07-27 21:53:46 +00:00
|
|
|
} else if (const GEPOperator *GEP = dyn_cast<GEPOperator>(U)) {
|
|
|
|
if (GEP->isInBounds())
|
|
|
|
Out << " inbounds";
|
2009-07-20 21:19:07 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-08-23 22:23:09 +00:00
|
|
|
static void WriteConstantInt(raw_ostream &Out, const Constant *CV,
|
2009-02-28 20:25:14 +00:00
|
|
|
TypePrinting &TypePrinter, SlotTracker *Machine) {
|
2007-01-11 12:24:14 +00:00
|
|
|
if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) {
|
2008-08-17 07:19:36 +00:00
|
|
|
if (CI->getType() == Type::Int1Ty) {
|
2007-01-12 04:24:46 +00:00
|
|
|
Out << (CI->getZExtValue() ? "true" : "false");
|
2008-08-17 07:19:36 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
Out << CI->getValue();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV)) {
|
2007-09-12 03:30:33 +00:00
|
|
|
if (&CFP->getValueAPF().getSemantics() == &APFloat::IEEEdouble ||
|
|
|
|
&CFP->getValueAPF().getSemantics() == &APFloat::IEEEsingle) {
|
|
|
|
// 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
|
|
|
|
// make sure that we only output it in exponential format if we can parse
|
|
|
|
// the value back and get the same value.
|
|
|
|
//
|
2009-01-21 20:32:55 +00:00
|
|
|
bool ignored;
|
2007-09-12 03:30:33 +00:00
|
|
|
bool isDouble = &CFP->getValueAPF().getSemantics()==&APFloat::IEEEdouble;
|
2008-08-17 07:19:36 +00:00
|
|
|
double Val = isDouble ? CFP->getValueAPF().convertToDouble() :
|
|
|
|
CFP->getValueAPF().convertToFloat();
|
2007-09-12 03:30:33 +00:00
|
|
|
std::string StrVal = ftostr(CFP->getValueAPF());
|
|
|
|
|
|
|
|
// Check to make sure that the stringized number is not some string like
|
|
|
|
// "Inf" or NaN, that atof will accept, but the lexer will not. Check
|
|
|
|
// that the string matches the "[-+]?[0-9]" regex.
|
|
|
|
//
|
|
|
|
if ((StrVal[0] >= '0' && StrVal[0] <= '9') ||
|
|
|
|
((StrVal[0] == '-' || StrVal[0] == '+') &&
|
|
|
|
(StrVal[1] >= '0' && StrVal[1] <= '9'))) {
|
|
|
|
// Reparse stringized version!
|
|
|
|
if (atof(StrVal.c_str()) == Val) {
|
|
|
|
Out << StrVal;
|
|
|
|
return;
|
|
|
|
}
|
2002-04-18 18:53:13 +00:00
|
|
|
}
|
2007-09-12 03:30:33 +00:00
|
|
|
// Otherwise we could not reparse it to exactly the same value, so we must
|
2009-01-21 20:32:55 +00:00
|
|
|
// output the string in hexadecimal format! Note that loading and storing
|
|
|
|
// floating point types changes the bits of NaNs on some hosts, notably
|
|
|
|
// x86, so we must not use these types.
|
2007-09-12 03:30:33 +00:00
|
|
|
assert(sizeof(double) == sizeof(uint64_t) &&
|
|
|
|
"assuming that double is 64 bits!");
|
2008-11-10 04:30:26 +00:00
|
|
|
char Buffer[40];
|
2009-01-21 20:32:55 +00:00
|
|
|
APFloat apf = CFP->getValueAPF();
|
|
|
|
// Floats are represented in ASCII IR as double, convert.
|
|
|
|
if (!isDouble)
|
|
|
|
apf.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven,
|
|
|
|
&ignored);
|
|
|
|
Out << "0x" <<
|
|
|
|
utohex_buffer(uint64_t(apf.bitcastToAPInt().getZExtValue()),
|
|
|
|
Buffer+40);
|
2008-08-19 05:06:27 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Some form of long double. These appear as a magic letter identifying
|
|
|
|
// the type, then a fixed number of hex digits.
|
|
|
|
Out << "0x";
|
2009-03-23 21:16:53 +00:00
|
|
|
if (&CFP->getValueAPF().getSemantics() == &APFloat::x87DoubleExtended) {
|
2008-08-19 05:06:27 +00:00
|
|
|
Out << 'K';
|
2009-03-23 21:16:53 +00:00
|
|
|
// api needed to prevent premature destruction
|
|
|
|
APInt api = CFP->getValueAPF().bitcastToAPInt();
|
|
|
|
const uint64_t* p = api.getRawData();
|
|
|
|
uint64_t word = p[1];
|
|
|
|
int shiftcount=12;
|
|
|
|
int width = api.getBitWidth();
|
|
|
|
for (int j=0; j<width; j+=4, shiftcount-=4) {
|
|
|
|
unsigned int nibble = (word>>shiftcount) & 15;
|
|
|
|
if (nibble < 10)
|
|
|
|
Out << (unsigned char)(nibble + '0');
|
|
|
|
else
|
|
|
|
Out << (unsigned char)(nibble - 10 + 'A');
|
|
|
|
if (shiftcount == 0 && j+4 < width) {
|
|
|
|
word = *p;
|
|
|
|
shiftcount = 64;
|
|
|
|
if (width-j-4 < 64)
|
|
|
|
shiftcount = width-j-4;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
} else if (&CFP->getValueAPF().getSemantics() == &APFloat::IEEEquad)
|
2008-08-19 05:06:27 +00:00
|
|
|
Out << 'L';
|
|
|
|
else if (&CFP->getValueAPF().getSemantics() == &APFloat::PPCDoubleDouble)
|
|
|
|
Out << 'M';
|
|
|
|
else
|
2009-07-14 16:55:14 +00:00
|
|
|
llvm_unreachable("Unsupported floating point type");
|
2008-08-19 05:06:27 +00:00
|
|
|
// api needed to prevent premature destruction
|
2008-10-09 18:53:47 +00:00
|
|
|
APInt api = CFP->getValueAPF().bitcastToAPInt();
|
2008-08-19 05:06:27 +00:00
|
|
|
const uint64_t* p = api.getRawData();
|
|
|
|
uint64_t word = *p;
|
|
|
|
int shiftcount=60;
|
|
|
|
int width = api.getBitWidth();
|
|
|
|
for (int j=0; j<width; j+=4, shiftcount-=4) {
|
|
|
|
unsigned int nibble = (word>>shiftcount) & 15;
|
|
|
|
if (nibble < 10)
|
|
|
|
Out << (unsigned char)(nibble + '0');
|
2007-09-12 03:30:33 +00:00
|
|
|
else
|
2008-08-19 05:06:27 +00:00
|
|
|
Out << (unsigned char)(nibble - 10 + 'A');
|
|
|
|
if (shiftcount == 0 && j+4 < width) {
|
|
|
|
word = *(++p);
|
|
|
|
shiftcount = 64;
|
|
|
|
if (width-j-4 < 64)
|
|
|
|
shiftcount = width-j-4;
|
2007-09-12 03:30:33 +00:00
|
|
|
}
|
|
|
|
}
|
2008-08-19 05:06:27 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (isa<ConstantAggregateZero>(CV)) {
|
2004-02-15 05:55:15 +00:00
|
|
|
Out << "zeroinitializer";
|
2008-08-19 05:06:27 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (const ConstantArray *CA = dyn_cast<ConstantArray>(CV)) {
|
2002-04-18 18:53:13 +00:00
|
|
|
// As a special case, print the array as a string if it is an array of
|
2008-05-12 16:34:30 +00:00
|
|
|
// i8 with ConstantInt values.
|
2005-04-21 23:48:37 +00:00
|
|
|
//
|
2002-04-18 18:53:13 +00:00
|
|
|
const Type *ETy = CA->getType()->getElementType();
|
2006-01-23 23:03:36 +00:00
|
|
|
if (CA->isString()) {
|
2002-04-18 18:53:13 +00:00
|
|
|
Out << "c\"";
|
2006-01-23 23:03:36 +00:00
|
|
|
PrintEscapedString(CA->getAsString(), Out);
|
2008-08-19 05:06:27 +00:00
|
|
|
Out << '"';
|
2002-04-18 18:53:13 +00:00
|
|
|
} else { // Cannot output in string format...
|
2004-06-04 21:11:51 +00:00
|
|
|
Out << '[';
|
2002-04-16 21:36:08 +00:00
|
|
|
if (CA->getNumOperands()) {
|
2009-02-28 21:26:53 +00:00
|
|
|
TypePrinter.print(ETy, Out);
|
2008-09-14 17:21:12 +00:00
|
|
|
Out << ' ';
|
2002-04-16 21:36:08 +00:00
|
|
|
WriteAsOperandInternal(Out, CA->getOperand(0),
|
2009-02-28 20:25:14 +00:00
|
|
|
TypePrinter, Machine);
|
2002-04-16 21:36:08 +00:00
|
|
|
for (unsigned i = 1, e = CA->getNumOperands(); i != e; ++i) {
|
|
|
|
Out << ", ";
|
2009-02-28 21:26:53 +00:00
|
|
|
TypePrinter.print(ETy, Out);
|
2008-09-14 17:21:12 +00:00
|
|
|
Out << ' ';
|
2009-02-28 20:25:14 +00:00
|
|
|
WriteAsOperandInternal(Out, CA->getOperand(i), TypePrinter, Machine);
|
2002-04-16 21:36:08 +00:00
|
|
|
}
|
|
|
|
}
|
2008-09-14 17:21:12 +00:00
|
|
|
Out << ']';
|
2002-04-16 21:36:08 +00:00
|
|
|
}
|
2008-08-19 05:06:27 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (const ConstantStruct *CS = dyn_cast<ConstantStruct>(CV)) {
|
2007-01-08 18:21:30 +00:00
|
|
|
if (CS->getType()->isPacked())
|
|
|
|
Out << '<';
|
2004-06-04 21:11:51 +00:00
|
|
|
Out << '{';
|
2006-02-25 12:27:03 +00:00
|
|
|
unsigned N = CS->getNumOperands();
|
|
|
|
if (N) {
|
2008-08-19 04:47:09 +00:00
|
|
|
Out << ' ';
|
2009-02-28 21:26:53 +00:00
|
|
|
TypePrinter.print(CS->getOperand(0)->getType(), Out);
|
2008-09-14 17:21:12 +00:00
|
|
|
Out << ' ';
|
2002-04-16 21:36:08 +00:00
|
|
|
|
2009-02-28 20:25:14 +00:00
|
|
|
WriteAsOperandInternal(Out, CS->getOperand(0), TypePrinter, Machine);
|
2002-04-16 21:36:08 +00:00
|
|
|
|
2006-02-25 12:27:03 +00:00
|
|
|
for (unsigned i = 1; i < N; i++) {
|
2002-04-16 21:36:08 +00:00
|
|
|
Out << ", ";
|
2009-02-28 21:26:53 +00:00
|
|
|
TypePrinter.print(CS->getOperand(i)->getType(), Out);
|
2008-09-14 17:21:12 +00:00
|
|
|
Out << ' ';
|
2002-04-16 21:36:08 +00:00
|
|
|
|
2009-02-28 20:25:14 +00:00
|
|
|
WriteAsOperandInternal(Out, CS->getOperand(i), TypePrinter, Machine);
|
2002-04-16 21:36:08 +00:00
|
|
|
}
|
2008-09-14 17:21:12 +00:00
|
|
|
Out << ' ';
|
2002-04-16 21:36:08 +00:00
|
|
|
}
|
2006-02-25 12:27:03 +00:00
|
|
|
|
2008-09-14 17:21:12 +00:00
|
|
|
Out << '}';
|
2007-01-08 18:21:30 +00:00
|
|
|
if (CS->getType()->isPacked())
|
|
|
|
Out << '>';
|
2008-08-19 05:06:27 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (const ConstantVector *CP = dyn_cast<ConstantVector>(CV)) {
|
|
|
|
const Type *ETy = CP->getType()->getElementType();
|
|
|
|
assert(CP->getNumOperands() > 0 &&
|
|
|
|
"Number of operands for a PackedConst must be > 0");
|
2009-02-11 00:25:25 +00:00
|
|
|
Out << '<';
|
2009-02-28 21:26:53 +00:00
|
|
|
TypePrinter.print(ETy, Out);
|
2008-09-14 17:21:12 +00:00
|
|
|
Out << ' ';
|
2009-02-28 20:25:14 +00:00
|
|
|
WriteAsOperandInternal(Out, CP->getOperand(0), TypePrinter, Machine);
|
2008-08-19 05:06:27 +00:00
|
|
|
for (unsigned i = 1, e = CP->getNumOperands(); i != e; ++i) {
|
2008-08-19 05:26:17 +00:00
|
|
|
Out << ", ";
|
2009-02-28 21:26:53 +00:00
|
|
|
TypePrinter.print(ETy, Out);
|
2008-09-14 17:21:12 +00:00
|
|
|
Out << ' ';
|
2009-02-28 20:25:14 +00:00
|
|
|
WriteAsOperandInternal(Out, CP->getOperand(i), TypePrinter, Machine);
|
2008-08-19 05:06:27 +00:00
|
|
|
}
|
2009-02-11 00:25:25 +00:00
|
|
|
Out << '>';
|
2008-08-19 05:06:27 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (isa<ConstantPointerNull>(CV)) {
|
2002-04-16 21:36:08 +00:00
|
|
|
Out << "null";
|
2008-08-19 05:06:27 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (isa<UndefValue>(CV)) {
|
2004-10-16 18:08:06 +00:00
|
|
|
Out << "undef";
|
2008-08-19 05:06:27 +00:00
|
|
|
return;
|
|
|
|
}
|
2009-04-04 07:22:01 +00:00
|
|
|
|
2009-07-08 21:44:25 +00:00
|
|
|
if (const MDNode *Node = dyn_cast<MDNode>(CV)) {
|
|
|
|
Out << "!" << Machine->getMetadataSlot(Node);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-08-19 05:06:27 +00:00
|
|
|
if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) {
|
2006-12-04 05:19:18 +00:00
|
|
|
Out << CE->getOpcodeName();
|
2009-07-27 16:11:46 +00:00
|
|
|
WriteOptimizationInfo(Out, CE);
|
2006-12-04 05:19:18 +00:00
|
|
|
if (CE->isCompare())
|
2008-08-19 05:06:27 +00:00
|
|
|
Out << ' ' << getPredicateText(CE->getPredicate());
|
2006-12-04 05:19:18 +00:00
|
|
|
Out << " (";
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2002-07-14 23:14:45 +00:00
|
|
|
for (User::const_op_iterator OI=CE->op_begin(); OI != CE->op_end(); ++OI) {
|
2009-02-28 21:26:53 +00:00
|
|
|
TypePrinter.print((*OI)->getType(), Out);
|
2008-09-14 17:21:12 +00:00
|
|
|
Out << ' ';
|
2009-02-28 20:25:14 +00:00
|
|
|
WriteAsOperandInternal(Out, *OI, TypePrinter, Machine);
|
2002-07-14 23:14:45 +00:00
|
|
|
if (OI+1 != CE->op_end())
|
2002-07-30 18:54:25 +00:00
|
|
|
Out << ", ";
|
2002-07-14 23:14:45 +00:00
|
|
|
}
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2008-05-31 19:12:39 +00:00
|
|
|
if (CE->hasIndices()) {
|
|
|
|
const SmallVector<unsigned, 4> &Indices = CE->getIndices();
|
|
|
|
for (unsigned i = 0, e = Indices.size(); i != e; ++i)
|
|
|
|
Out << ", " << Indices[i];
|
|
|
|
}
|
|
|
|
|
2006-11-27 01:05:10 +00:00
|
|
|
if (CE->isCast()) {
|
2002-08-15 19:37:43 +00:00
|
|
|
Out << " to ";
|
2009-02-28 21:26:53 +00:00
|
|
|
TypePrinter.print(CE->getType(), Out);
|
2002-08-15 19:37:43 +00:00
|
|
|
}
|
2006-11-27 01:05:10 +00:00
|
|
|
|
2004-06-04 21:11:51 +00:00
|
|
|
Out << ')';
|
2008-08-19 05:06:27 +00:00
|
|
|
return;
|
2002-04-16 21:36:08 +00:00
|
|
|
}
|
2008-08-19 05:06:27 +00:00
|
|
|
|
|
|
|
Out << "<placeholder or erroneous Constant>";
|
2002-04-16 21:36:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2004-03-02 00:22:19 +00:00
|
|
|
/// 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.
|
|
|
|
///
|
2008-08-23 22:23:09 +00:00
|
|
|
static void WriteAsOperandInternal(raw_ostream &Out, const Value *V,
|
2009-02-28 20:25:14 +00:00
|
|
|
TypePrinting &TypePrinter,
|
2008-08-19 04:26:57 +00:00
|
|
|
SlotTracker *Machine) {
|
2008-08-17 04:40:13 +00:00
|
|
|
if (V->hasName()) {
|
|
|
|
PrintLLVMName(Out, V);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
const Constant *CV = dyn_cast<Constant>(V);
|
|
|
|
if (CV && !isa<GlobalValue>(CV)) {
|
2009-02-28 20:25:14 +00:00
|
|
|
WriteConstantInt(Out, CV, TypePrinter, Machine);
|
2008-08-19 05:06:27 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (const InlineAsm *IA = dyn_cast<InlineAsm>(V)) {
|
2008-08-17 04:40:13 +00:00
|
|
|
Out << "asm ";
|
|
|
|
if (IA->hasSideEffects())
|
|
|
|
Out << "sideeffect ";
|
|
|
|
Out << '"';
|
|
|
|
PrintEscapedString(IA->getAsmString(), Out);
|
|
|
|
Out << "\", \"";
|
|
|
|
PrintEscapedString(IA->getConstraintString(), Out);
|
|
|
|
Out << '"';
|
2008-08-19 05:06:27 +00:00
|
|
|
return;
|
|
|
|
}
|
2009-07-22 17:43:22 +00:00
|
|
|
|
2009-07-23 01:07:34 +00:00
|
|
|
if (const MDNode *N = dyn_cast<MDNode>(V)) {
|
|
|
|
Out << '!' << Machine->getMetadataSlot(N);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-07-22 17:43:22 +00:00
|
|
|
if (const MDString *MDS = dyn_cast<MDString>(V)) {
|
|
|
|
Out << "!\"";
|
2009-07-25 23:55:21 +00:00
|
|
|
PrintEscapedString(MDS->getString(), Out);
|
2009-07-22 17:43:22 +00:00
|
|
|
Out << '"';
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-08-19 05:06:27 +00:00
|
|
|
char Prefix = '%';
|
|
|
|
int Slot;
|
|
|
|
if (Machine) {
|
|
|
|
if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
|
|
|
|
Slot = Machine->getGlobalSlot(GV);
|
|
|
|
Prefix = '@';
|
|
|
|
} else {
|
|
|
|
Slot = Machine->getLocalSlot(V);
|
|
|
|
}
|
2008-08-17 04:40:13 +00:00
|
|
|
} else {
|
2008-08-19 05:06:27 +00:00
|
|
|
Machine = createSlotTracker(V);
|
2008-08-17 04:40:13 +00:00
|
|
|
if (Machine) {
|
|
|
|
if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
|
|
|
|
Slot = Machine->getGlobalSlot(GV);
|
|
|
|
Prefix = '@';
|
|
|
|
} else {
|
|
|
|
Slot = Machine->getLocalSlot(V);
|
|
|
|
}
|
2006-01-25 22:26:05 +00:00
|
|
|
} else {
|
2008-08-19 05:06:27 +00:00
|
|
|
Slot = -1;
|
2002-04-16 21:36:08 +00:00
|
|
|
}
|
2008-08-19 05:06:27 +00:00
|
|
|
delete Machine;
|
2002-04-16 21:36:08 +00:00
|
|
|
}
|
2008-08-19 05:06:27 +00:00
|
|
|
|
|
|
|
if (Slot != -1)
|
|
|
|
Out << Prefix << Slot;
|
|
|
|
else
|
|
|
|
Out << "<badref>";
|
2002-04-16 21:36:08 +00:00
|
|
|
}
|
|
|
|
|
2004-03-01 19:48:13 +00:00
|
|
|
/// 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.
|
|
|
|
///
|
2008-08-19 04:47:09 +00:00
|
|
|
void llvm::WriteAsOperand(std::ostream &Out, const Value *V, bool PrintType,
|
|
|
|
const Module *Context) {
|
2008-08-23 22:23:09 +00:00
|
|
|
raw_os_ostream OS(Out);
|
|
|
|
WriteAsOperand(OS, V, PrintType, Context);
|
|
|
|
}
|
|
|
|
|
|
|
|
void llvm::WriteAsOperand(raw_ostream &Out, const Value *V, bool PrintType,
|
|
|
|
const Module *Context) {
|
2002-07-10 16:48:17 +00:00
|
|
|
if (Context == 0) Context = getModuleFromVal(V);
|
2002-04-16 21:36:08 +00:00
|
|
|
|
2009-02-28 23:20:19 +00:00
|
|
|
TypePrinting TypePrinter;
|
2009-03-01 00:03:38 +00:00
|
|
|
std::vector<const Type*> NumberedTypes;
|
|
|
|
AddModuleTypesToPrinter(TypePrinter, NumberedTypes, Context);
|
2008-09-14 17:21:12 +00:00
|
|
|
if (PrintType) {
|
2009-02-28 21:26:53 +00:00
|
|
|
TypePrinter.print(V->getType(), Out);
|
2008-09-14 17:21:12 +00:00
|
|
|
Out << ' ';
|
|
|
|
}
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2009-02-28 20:25:14 +00:00
|
|
|
WriteAsOperandInternal(Out, V, TypePrinter, 0);
|
2001-07-20 19:15:21 +00:00
|
|
|
}
|
|
|
|
|
2004-07-04 11:50:43 +00:00
|
|
|
|
2008-08-19 05:06:27 +00:00
|
|
|
namespace {
|
2001-07-12 23:35:26 +00:00
|
|
|
|
2001-09-07 16:36:04 +00:00
|
|
|
class AssemblyWriter {
|
2008-08-23 22:23:09 +00:00
|
|
|
raw_ostream &Out;
|
2008-08-19 04:26:57 +00:00
|
|
|
SlotTracker &Machine;
|
2001-10-29 16:05:51 +00:00
|
|
|
const Module *TheModule;
|
2009-02-28 20:25:14 +00:00
|
|
|
TypePrinting TypePrinter;
|
2003-10-30 23:41:03 +00:00
|
|
|
AssemblyAnnotationWriter *AnnotationWriter;
|
2009-03-01 00:03:38 +00:00
|
|
|
std::vector<const Type*> NumberedTypes;
|
2009-07-01 19:21:12 +00:00
|
|
|
|
|
|
|
// Each MDNode is assigned unique MetadataIDNo.
|
|
|
|
std::map<const MDNode *, unsigned> MDNodes;
|
|
|
|
unsigned MetadataIDNo;
|
2001-06-06 20:29:01 +00:00
|
|
|
public:
|
2008-08-23 22:23:09 +00:00
|
|
|
inline AssemblyWriter(raw_ostream &o, SlotTracker &Mac, const Module *M,
|
2003-10-30 23:41:03 +00:00
|
|
|
AssemblyAnnotationWriter *AAW)
|
2009-07-01 19:21:12 +00:00
|
|
|
: Out(o), Machine(Mac), TheModule(M), AnnotationWriter(AAW), MetadataIDNo(0) {
|
2009-03-01 00:03:38 +00:00
|
|
|
AddModuleTypesToPrinter(TypePrinter, NumberedTypes, M);
|
2001-06-06 20:29:01 +00:00
|
|
|
}
|
|
|
|
|
2009-03-01 00:03:38 +00:00
|
|
|
void write(const Module *M) { printModule(M); }
|
2008-08-23 22:23:09 +00:00
|
|
|
|
|
|
|
void write(const GlobalValue *G) {
|
|
|
|
if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(G))
|
|
|
|
printGlobal(GV);
|
|
|
|
else if (const GlobalAlias *GA = dyn_cast<GlobalAlias>(G))
|
|
|
|
printAlias(GA);
|
|
|
|
else if (const Function *F = dyn_cast<Function>(G))
|
|
|
|
printFunction(F);
|
|
|
|
else
|
2009-07-14 16:55:14 +00:00
|
|
|
llvm_unreachable("Unknown global");
|
2008-08-23 22:23:09 +00:00
|
|
|
}
|
|
|
|
|
2008-08-19 05:06:27 +00:00
|
|
|
void write(const BasicBlock *BB) { printBasicBlock(BB); }
|
|
|
|
void write(const Instruction *I) { printInstruction(*I); }
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2006-12-06 06:24:27 +00:00
|
|
|
void writeOperand(const Value *Op, bool PrintType);
|
2008-09-23 23:03:40 +00:00
|
|
|
void writeParamOperand(const Value *Operand, Attributes Attrs);
|
2002-04-18 18:53:13 +00:00
|
|
|
|
2004-04-28 15:31:21 +00:00
|
|
|
const Module* getModule() { return TheModule; }
|
|
|
|
|
2004-11-15 19:30:05 +00:00
|
|
|
private:
|
2001-10-29 16:05:51 +00:00
|
|
|
void printModule(const Module *M);
|
2007-01-06 07:24:44 +00:00
|
|
|
void printTypeSymbolTable(const TypeSymbolTable &ST);
|
2001-10-29 16:05:51 +00:00
|
|
|
void printGlobal(const GlobalVariable *GV);
|
2007-04-25 14:27:10 +00:00
|
|
|
void printAlias(const GlobalAlias *GV);
|
2002-03-26 18:01:55 +00:00
|
|
|
void printFunction(const Function *F);
|
2008-09-23 23:03:40 +00:00
|
|
|
void printArgument(const Argument *FA, Attributes Attrs);
|
2001-10-29 16:05:51 +00:00
|
|
|
void printBasicBlock(const BasicBlock *BB);
|
2002-06-25 16:13:24 +00:00
|
|
|
void printInstruction(const Instruction &I);
|
2002-04-13 20:53:41 +00:00
|
|
|
|
2001-10-13 06:42:36 +00:00
|
|
|
// printInfoComment - Print a little comment after the instruction indicating
|
|
|
|
// which slot it occupies.
|
2002-06-25 16:13:24 +00:00
|
|
|
void printInfoComment(const Value &V);
|
2001-06-06 20:29:01 +00:00
|
|
|
};
|
2009-03-01 00:03:38 +00:00
|
|
|
} // end of anonymous namespace
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2002-04-13 20:53:41 +00:00
|
|
|
|
2006-12-06 06:24:27 +00:00
|
|
|
void AssemblyWriter::writeOperand(const Value *Operand, bool PrintType) {
|
|
|
|
if (Operand == 0) {
|
2005-02-24 16:58:29 +00:00
|
|
|
Out << "<null operand!>";
|
2006-12-06 06:24:27 +00:00
|
|
|
} else {
|
2008-08-19 05:06:27 +00:00
|
|
|
if (PrintType) {
|
2009-02-28 21:26:53 +00:00
|
|
|
TypePrinter.print(Operand->getType(), Out);
|
2008-09-14 17:21:12 +00:00
|
|
|
Out << ' ';
|
2008-08-19 05:06:27 +00:00
|
|
|
}
|
2009-02-28 20:25:14 +00:00
|
|
|
WriteAsOperandInternal(Out, Operand, TypePrinter, &Machine);
|
2005-02-24 16:58:29 +00:00
|
|
|
}
|
2001-09-07 16:36:04 +00:00
|
|
|
}
|
|
|
|
|
2008-02-19 21:38:47 +00:00
|
|
|
void AssemblyWriter::writeParamOperand(const Value *Operand,
|
2008-09-23 23:03:40 +00:00
|
|
|
Attributes Attrs) {
|
2007-11-27 13:23:08 +00:00
|
|
|
if (Operand == 0) {
|
|
|
|
Out << "<null operand!>";
|
|
|
|
} else {
|
|
|
|
// Print the type
|
2009-02-28 21:26:53 +00:00
|
|
|
TypePrinter.print(Operand->getType(), Out);
|
2007-11-27 13:23:08 +00:00
|
|
|
// Print parameter attributes list
|
2008-09-25 21:00:45 +00:00
|
|
|
if (Attrs != Attribute::None)
|
|
|
|
Out << ' ' << Attribute::getAsString(Attrs);
|
2008-09-14 17:21:12 +00:00
|
|
|
Out << ' ';
|
2007-11-27 13:23:08 +00:00
|
|
|
// Print the operand
|
2009-02-28 20:25:14 +00:00
|
|
|
WriteAsOperandInternal(Out, Operand, TypePrinter, &Machine);
|
2007-11-27 13:23:08 +00:00
|
|
|
}
|
|
|
|
}
|
2001-09-07 16:36:04 +00:00
|
|
|
|
2001-10-29 16:05:51 +00:00
|
|
|
void AssemblyWriter::printModule(const Module *M) {
|
2005-03-02 23:12:40 +00:00
|
|
|
if (!M->getModuleIdentifier().empty() &&
|
2005-04-21 23:48:37 +00:00
|
|
|
// Don't print the ID if it will start a new line (which would
|
2005-03-02 23:12:40 +00:00
|
|
|
// require a comment char before it).
|
|
|
|
M->getModuleIdentifier().find('\n') == std::string::npos)
|
|
|
|
Out << "; ModuleID = '" << M->getModuleIdentifier() << "'\n";
|
|
|
|
|
2006-10-18 02:21:12 +00:00
|
|
|
if (!M->getDataLayout().empty())
|
2006-10-22 06:06:56 +00:00
|
|
|
Out << "target datalayout = \"" << M->getDataLayout() << "\"\n";
|
2004-07-25 21:44:54 +00:00
|
|
|
if (!M->getTargetTriple().empty())
|
2004-07-25 21:29:43 +00:00
|
|
|
Out << "target triple = \"" << M->getTargetTriple() << "\"\n";
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2006-01-24 04:13:11 +00:00
|
|
|
if (!M->getModuleInlineAsm().empty()) {
|
2006-01-24 00:45:30 +00:00
|
|
|
// Split the string into lines, to make it easier to read the .ll file.
|
2006-01-24 04:13:11 +00:00
|
|
|
std::string Asm = M->getModuleInlineAsm();
|
2006-01-24 00:45:30 +00:00
|
|
|
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);
|
|
|
|
}
|
2006-01-24 00:40:17 +00:00
|
|
|
Out << "module asm \"";
|
2006-01-24 00:45:30 +00:00
|
|
|
PrintEscapedString(std::string(Asm.begin()+CurPos, Asm.end()), Out);
|
2006-01-23 23:03:36 +00:00
|
|
|
Out << "\"\n";
|
|
|
|
}
|
|
|
|
|
2004-09-14 05:06:58 +00:00
|
|
|
// Loop over the dependent libraries and emit them.
|
2004-09-14 04:51:44 +00:00
|
|
|
Module::lib_iterator LI = M->lib_begin();
|
|
|
|
Module::lib_iterator LE = M->lib_end();
|
2004-07-25 21:44:54 +00:00
|
|
|
if (LI != LE) {
|
2004-09-14 04:51:44 +00:00
|
|
|
Out << "deplibs = [ ";
|
|
|
|
while (LI != LE) {
|
2004-09-14 05:06:58 +00:00
|
|
|
Out << '"' << *LI << '"';
|
2004-07-25 21:29:43 +00:00
|
|
|
++LI;
|
2004-09-14 04:51:44 +00:00
|
|
|
if (LI != LE)
|
|
|
|
Out << ", ";
|
2004-07-25 21:29:43 +00:00
|
|
|
}
|
|
|
|
Out << " ]\n";
|
2004-07-25 18:08:18 +00:00
|
|
|
}
|
2004-09-13 23:44:23 +00:00
|
|
|
|
2009-03-01 00:03:38 +00:00
|
|
|
// Loop over the symbol table, emitting all id'd types.
|
2007-01-06 07:24:44 +00:00
|
|
|
printTypeSymbolTable(M->getTypeSymbolTable());
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2006-12-06 04:41:52 +00:00
|
|
|
for (Module::const_global_iterator I = M->global_begin(), E = M->global_end();
|
|
|
|
I != E; ++I)
|
2002-06-25 16:13:24 +00:00
|
|
|
printGlobal(I);
|
2007-04-26 02:24:10 +00:00
|
|
|
|
|
|
|
// Output all aliases.
|
|
|
|
if (!M->alias_empty()) Out << "\n";
|
|
|
|
for (Module::const_alias_iterator I = M->alias_begin(), E = M->alias_end();
|
|
|
|
I != E; ++I)
|
|
|
|
printAlias(I);
|
2001-09-07 16:36:04 +00:00
|
|
|
|
2004-09-14 05:06:58 +00:00
|
|
|
// Output all of the functions.
|
2002-06-25 16:13:24 +00:00
|
|
|
for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I)
|
|
|
|
printFunction(I);
|
2009-07-08 21:44:25 +00:00
|
|
|
|
2009-07-29 22:04:47 +00:00
|
|
|
// Output named metadata.
|
|
|
|
for (Module::const_named_metadata_iterator I = M->named_metadata_begin(),
|
|
|
|
E = M->named_metadata_end(); I != E; ++I) {
|
|
|
|
const NamedMDNode *NMD = I;
|
|
|
|
Out << "!" << NMD->getName() << " = !{";
|
|
|
|
for (unsigned i = 0, e = NMD->getNumElements(); i != e; ++i) {
|
|
|
|
if (i) Out << ", ";
|
2009-07-30 01:02:04 +00:00
|
|
|
MDNode *MD = dyn_cast_or_null<MDNode>(NMD->getElement(i));
|
2009-07-29 22:04:47 +00:00
|
|
|
Out << '!' << Machine.getMetadataSlot(MD);
|
|
|
|
}
|
|
|
|
Out << "}\n";
|
|
|
|
}
|
|
|
|
|
|
|
|
// Output metadata.
|
2009-07-08 21:44:25 +00:00
|
|
|
WriteMDNodes(Out, TypePrinter, Machine);
|
2001-06-06 20:29:01 +00:00
|
|
|
}
|
|
|
|
|
2008-08-23 22:23:09 +00:00
|
|
|
static void PrintLinkage(GlobalValue::LinkageTypes LT, raw_ostream &Out) {
|
2008-08-19 05:06:27 +00:00
|
|
|
switch (LT) {
|
2009-07-20 01:03:30 +00:00
|
|
|
case GlobalValue::ExternalLinkage: break;
|
|
|
|
case GlobalValue::PrivateLinkage: Out << "private "; break;
|
|
|
|
case GlobalValue::LinkerPrivateLinkage: Out << "linker_private "; break;
|
|
|
|
case GlobalValue::InternalLinkage: Out << "internal "; break;
|
|
|
|
case GlobalValue::LinkOnceAnyLinkage: Out << "linkonce "; break;
|
|
|
|
case GlobalValue::LinkOnceODRLinkage: Out << "linkonce_odr "; break;
|
|
|
|
case GlobalValue::WeakAnyLinkage: Out << "weak "; break;
|
|
|
|
case GlobalValue::WeakODRLinkage: Out << "weak_odr "; break;
|
|
|
|
case GlobalValue::CommonLinkage: Out << "common "; 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;
|
2009-04-13 05:44:34 +00:00
|
|
|
case GlobalValue::AvailableExternallyLinkage:
|
|
|
|
Out << "available_externally ";
|
|
|
|
break;
|
2008-08-19 05:06:27 +00:00
|
|
|
case GlobalValue::GhostLinkage:
|
2009-07-14 16:55:14 +00:00
|
|
|
llvm_unreachable("GhostLinkage not allowed in AsmWriter!");
|
2008-08-19 05:06:27 +00:00
|
|
|
}
|
|
|
|
}
|
Introduce new linkage types linkonce_odr, weak_odr, common_odr
and extern_weak_odr. These are the same as the non-odr versions,
except that they indicate that the global will only be overridden
by an *equivalent* global. In C, a function with weak linkage can
be overridden by a function which behaves completely differently.
This means that IP passes have to skip weak functions, since any
deductions made from the function definition might be wrong, since
the definition could be replaced by something completely different
at link time. This is not allowed in C++, thanks to the ODR
(One-Definition-Rule): if a function is replaced by another at
link-time, then the new function must be the same as the original
function. If a language knows that a function or other global can
only be overridden by an equivalent global, it can give it the
weak_odr linkage type, and the optimizers will understand that it
is alright to make deductions based on the function body. The
code generators on the other hand map weak and weak_odr linkage
to the same thing.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@66339 91177308-0d34-0410-b5e6-96231b3b80d8
2009-03-07 15:45:40 +00:00
|
|
|
|
2008-08-19 05:06:27 +00:00
|
|
|
|
|
|
|
static void PrintVisibility(GlobalValue::VisibilityTypes Vis,
|
2008-08-23 22:23:09 +00:00
|
|
|
raw_ostream &Out) {
|
2008-08-19 05:06:27 +00:00
|
|
|
switch (Vis) {
|
2009-07-14 16:55:14 +00:00
|
|
|
default: llvm_unreachable("Invalid visibility style!");
|
2008-08-19 05:06:27 +00:00
|
|
|
case GlobalValue::DefaultVisibility: break;
|
|
|
|
case GlobalValue::HiddenVisibility: Out << "hidden "; break;
|
|
|
|
case GlobalValue::ProtectedVisibility: Out << "protected "; break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-10-29 16:05:51 +00:00
|
|
|
void AssemblyWriter::printGlobal(const GlobalVariable *GV) {
|
2008-08-17 04:40:13 +00:00
|
|
|
if (GV->hasName()) {
|
|
|
|
PrintLLVMName(Out, GV);
|
|
|
|
Out << " = ";
|
|
|
|
}
|
2001-09-18 04:01:05 +00:00
|
|
|
|
2008-08-19 05:16:28 +00:00
|
|
|
if (!GV->hasInitializer() && GV->hasExternalLinkage())
|
|
|
|
Out << "external ";
|
|
|
|
|
|
|
|
PrintLinkage(GV->getLinkage(), Out);
|
|
|
|
PrintVisibility(GV->getVisibility(), Out);
|
2007-04-12 18:32:50 +00:00
|
|
|
|
|
|
|
if (GV->isThreadLocal()) Out << "thread_local ";
|
2009-01-02 07:01:27 +00:00
|
|
|
if (unsigned AddressSpace = GV->getType()->getAddressSpace())
|
|
|
|
Out << "addrspace(" << AddressSpace << ") ";
|
2004-06-21 21:53:56 +00:00
|
|
|
Out << (GV->isConstant() ? "constant " : "global ");
|
2009-02-28 21:26:53 +00:00
|
|
|
TypePrinter.print(GV->getType()->getElementType(), Out);
|
2001-09-18 04:01:05 +00:00
|
|
|
|
2008-09-14 17:21:12 +00:00
|
|
|
if (GV->hasInitializer()) {
|
|
|
|
Out << ' ';
|
2009-07-08 21:44:25 +00:00
|
|
|
writeOperand(GV->getInitializer(), false);
|
2008-09-14 17:21:12 +00:00
|
|
|
}
|
2007-12-11 08:59:05 +00:00
|
|
|
|
2005-11-12 00:10:19 +00:00
|
|
|
if (GV->hasSection())
|
|
|
|
Out << ", section \"" << GV->getSection() << '"';
|
|
|
|
if (GV->getAlignment())
|
2005-11-06 06:48:53 +00:00
|
|
|
Out << ", align " << GV->getAlignment();
|
2007-04-25 14:27:10 +00:00
|
|
|
|
2002-06-25 16:13:24 +00:00
|
|
|
printInfoComment(*GV);
|
2008-08-19 05:06:27 +00:00
|
|
|
Out << '\n';
|
2001-09-10 07:58:01 +00:00
|
|
|
}
|
|
|
|
|
2007-04-25 14:27:10 +00:00
|
|
|
void AssemblyWriter::printAlias(const GlobalAlias *GA) {
|
2008-06-03 18:14:29 +00:00
|
|
|
// Don't crash when dumping partially built GA
|
|
|
|
if (!GA->hasName())
|
|
|
|
Out << "<<nameless>> = ";
|
2008-08-17 04:40:13 +00:00
|
|
|
else {
|
|
|
|
PrintLLVMName(Out, GA);
|
|
|
|
Out << " = ";
|
|
|
|
}
|
2008-08-19 05:06:27 +00:00
|
|
|
PrintVisibility(GA->getVisibility(), Out);
|
2007-04-25 14:27:10 +00:00
|
|
|
|
|
|
|
Out << "alias ";
|
|
|
|
|
2008-08-19 05:06:27 +00:00
|
|
|
PrintLinkage(GA->getLinkage(), Out);
|
2007-04-25 14:27:10 +00:00
|
|
|
|
2007-04-29 18:02:48 +00:00
|
|
|
const Constant *Aliasee = GA->getAliasee();
|
2007-04-25 14:27:10 +00:00
|
|
|
|
|
|
|
if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(Aliasee)) {
|
2009-02-28 21:26:53 +00:00
|
|
|
TypePrinter.print(GV->getType(), Out);
|
2008-08-17 04:40:13 +00:00
|
|
|
Out << ' ';
|
|
|
|
PrintLLVMName(Out, GV);
|
2007-04-25 14:27:10 +00:00
|
|
|
} else if (const Function *F = dyn_cast<Function>(Aliasee)) {
|
2009-02-28 21:26:53 +00:00
|
|
|
TypePrinter.print(F->getFunctionType(), Out);
|
2007-04-25 14:27:10 +00:00
|
|
|
Out << "* ";
|
|
|
|
|
2009-02-28 20:25:14 +00:00
|
|
|
WriteAsOperandInternal(Out, F, TypePrinter, &Machine);
|
2008-03-22 08:17:17 +00:00
|
|
|
} else if (const GlobalAlias *GA = dyn_cast<GlobalAlias>(Aliasee)) {
|
2009-02-28 21:26:53 +00:00
|
|
|
TypePrinter.print(GA->getType(), Out);
|
|
|
|
Out << ' ';
|
2008-08-17 04:40:13 +00:00
|
|
|
PrintLLVMName(Out, GA);
|
2007-04-28 13:45:00 +00:00
|
|
|
} else {
|
2009-04-25 21:23:19 +00:00
|
|
|
const ConstantExpr *CE = cast<ConstantExpr>(Aliasee);
|
|
|
|
// The only valid GEP is an all zero GEP.
|
|
|
|
assert((CE->getOpcode() == Instruction::BitCast ||
|
|
|
|
CE->getOpcode() == Instruction::GetElementPtr) &&
|
|
|
|
"Unsupported aliasee");
|
|
|
|
writeOperand(CE, false);
|
2007-04-28 13:45:00 +00:00
|
|
|
}
|
|
|
|
|
2007-04-25 14:27:10 +00:00
|
|
|
printInfoComment(*GA);
|
2008-08-19 05:16:28 +00:00
|
|
|
Out << '\n';
|
2007-04-25 14:27:10 +00:00
|
|
|
}
|
|
|
|
|
2007-01-06 07:24:44 +00:00
|
|
|
void AssemblyWriter::printTypeSymbolTable(const TypeSymbolTable &ST) {
|
2009-03-01 00:03:38 +00:00
|
|
|
// Emit all numbered types.
|
|
|
|
for (unsigned i = 0, e = NumberedTypes.size(); i != e; ++i) {
|
|
|
|
Out << "\ttype ";
|
|
|
|
|
|
|
|
// Make sure we print out at least one level of the type structure, so
|
|
|
|
// that we do not get %2 = type %2
|
|
|
|
TypePrinter.printAtLeastOneLevel(NumberedTypes[i], Out);
|
|
|
|
Out << "\t\t; type %" << i << '\n';
|
|
|
|
}
|
|
|
|
|
|
|
|
// Print the named types.
|
2007-01-06 07:24:44 +00:00
|
|
|
for (TypeSymbolTable::const_iterator TI = ST.begin(), TE = ST.end();
|
|
|
|
TI != TE; ++TI) {
|
2008-08-19 05:16:28 +00:00
|
|
|
Out << '\t';
|
2009-07-25 23:55:21 +00:00
|
|
|
PrintLLVMName(Out, TI->first, LocalPrefix);
|
2008-08-19 05:16:28 +00:00
|
|
|
Out << " = type ";
|
2004-05-25 08:53:40 +00:00
|
|
|
|
|
|
|
// Make sure we print out at least one level of the type structure, so
|
|
|
|
// that we do not get %FILE = type %FILE
|
2009-02-28 21:26:53 +00:00
|
|
|
TypePrinter.printAtLeastOneLevel(TI->second, Out);
|
2008-08-19 05:06:27 +00:00
|
|
|
Out << '\n';
|
2004-05-25 08:53:40 +00:00
|
|
|
}
|
2007-01-06 07:24:44 +00:00
|
|
|
}
|
|
|
|
|
2004-03-02 00:22:19 +00:00
|
|
|
/// printFunction - Print all aspects of a function.
|
|
|
|
///
|
2002-06-25 16:13:24 +00:00
|
|
|
void AssemblyWriter::printFunction(const Function *F) {
|
2008-08-19 05:06:27 +00:00
|
|
|
// Print out the return type and name.
|
|
|
|
Out << '\n';
|
2003-04-16 20:28:45 +00:00
|
|
|
|
2004-06-21 21:53:56 +00:00
|
|
|
if (AnnotationWriter) AnnotationWriter->emitFunctionAnnot(F, Out);
|
2003-10-30 23:41:03 +00:00
|
|
|
|
2007-01-30 20:08:39 +00:00
|
|
|
if (F->isDeclaration())
|
2007-08-19 22:15:26 +00:00
|
|
|
Out << "declare ";
|
|
|
|
else
|
2006-12-29 20:29:48 +00:00
|
|
|
Out << "define ";
|
2008-08-19 05:06:27 +00:00
|
|
|
|
|
|
|
PrintLinkage(F->getLinkage(), Out);
|
|
|
|
PrintVisibility(F->getVisibility(), Out);
|
2003-04-16 20:28:45 +00:00
|
|
|
|
2005-05-06 20:26:43 +00:00
|
|
|
// Print the calling convention.
|
|
|
|
switch (F->getCallingConv()) {
|
|
|
|
case CallingConv::C: break; // default
|
2006-09-20 22:03:51 +00:00
|
|
|
case CallingConv::Fast: Out << "fastcc "; break;
|
|
|
|
case CallingConv::Cold: Out << "coldcc "; break;
|
|
|
|
case CallingConv::X86_StdCall: Out << "x86_stdcallcc "; break;
|
2009-06-16 18:50:49 +00:00
|
|
|
case CallingConv::X86_FastCall: Out << "x86_fastcallcc "; break;
|
|
|
|
case CallingConv::ARM_APCS: Out << "arm_apcscc "; break;
|
|
|
|
case CallingConv::ARM_AAPCS: Out << "arm_aapcscc "; break;
|
|
|
|
case CallingConv::ARM_AAPCS_VFP:Out << "arm_aapcs_vfpcc "; break;
|
2005-05-06 20:26:43 +00:00
|
|
|
default: Out << "cc" << F->getCallingConv() << " "; break;
|
|
|
|
}
|
|
|
|
|
2006-12-31 05:24:50 +00:00
|
|
|
const FunctionType *FT = F->getFunctionType();
|
2008-09-25 21:00:45 +00:00
|
|
|
const AttrListPtr &Attrs = F->getAttributes();
|
2008-09-29 20:49:50 +00:00
|
|
|
Attributes RetAttrs = Attrs.getRetAttributes();
|
|
|
|
if (RetAttrs != Attribute::None)
|
|
|
|
Out << Attribute::getAsString(Attrs.getRetAttributes()) << ' ';
|
2009-02-28 21:26:53 +00:00
|
|
|
TypePrinter.print(F->getReturnType(), Out);
|
2008-08-19 05:26:17 +00:00
|
|
|
Out << ' ';
|
2009-02-28 20:25:14 +00:00
|
|
|
WriteAsOperandInternal(Out, F, TypePrinter, &Machine);
|
2004-06-21 21:53:56 +00:00
|
|
|
Out << '(';
|
2004-05-26 07:18:52 +00:00
|
|
|
Machine.incorporateFunction(F);
|
2001-09-07 16:36:04 +00:00
|
|
|
|
2001-10-29 16:05:51 +00:00
|
|
|
// Loop over the arguments, printing them...
|
2001-09-07 16:36:04 +00:00
|
|
|
|
2006-12-31 05:24:50 +00:00
|
|
|
unsigned Idx = 1;
|
2007-04-18 00:57:22 +00:00
|
|
|
if (!F->isDeclaration()) {
|
|
|
|
// If this isn't a declaration, print the argument names as well.
|
|
|
|
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 << ", ";
|
2008-09-26 22:53:05 +00:00
|
|
|
printArgument(I, Attrs.getParamAttributes(Idx));
|
2007-04-18 00:57:22 +00:00
|
|
|
Idx++;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// Otherwise, print the types from the function type.
|
|
|
|
for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) {
|
|
|
|
// Insert commas as we go... the first arg doesn't get a comma
|
|
|
|
if (i) Out << ", ";
|
|
|
|
|
|
|
|
// Output type...
|
2009-02-28 21:26:53 +00:00
|
|
|
TypePrinter.print(FT->getParamType(i), Out);
|
2007-04-18 00:57:22 +00:00
|
|
|
|
2008-09-26 22:53:05 +00:00
|
|
|
Attributes ArgAttrs = Attrs.getParamAttributes(i+1);
|
2008-09-25 21:00:45 +00:00
|
|
|
if (ArgAttrs != Attribute::None)
|
|
|
|
Out << ' ' << Attribute::getAsString(ArgAttrs);
|
2007-04-18 00:57:22 +00:00
|
|
|
}
|
2006-12-31 05:24:50 +00:00
|
|
|
}
|
2001-09-07 16:36:04 +00:00
|
|
|
|
|
|
|
// Finish printing arguments...
|
2002-06-25 16:13:24 +00:00
|
|
|
if (FT->isVarArg()) {
|
2004-06-21 21:53:56 +00:00
|
|
|
if (FT->getNumParams()) Out << ", ";
|
|
|
|
Out << "..."; // Output varargs portion of signature!
|
2001-09-07 16:36:04 +00:00
|
|
|
}
|
2004-06-21 21:53:56 +00:00
|
|
|
Out << ')';
|
2008-09-26 22:53:05 +00:00
|
|
|
Attributes FnAttrs = Attrs.getFnAttributes();
|
|
|
|
if (FnAttrs != Attribute::None)
|
|
|
|
Out << ' ' << Attribute::getAsString(Attrs.getFnAttributes());
|
2005-11-12 00:10:19 +00:00
|
|
|
if (F->hasSection())
|
|
|
|
Out << " section \"" << F->getSection() << '"';
|
2005-11-06 06:48:53 +00:00
|
|
|
if (F->getAlignment())
|
|
|
|
Out << " align " << F->getAlignment();
|
2008-08-17 18:44:35 +00:00
|
|
|
if (F->hasGC())
|
|
|
|
Out << " gc \"" << F->getGC() << '"';
|
2008-09-22 22:32:29 +00:00
|
|
|
if (F->isDeclaration()) {
|
|
|
|
Out << "\n";
|
|
|
|
} else {
|
2008-04-21 06:12:55 +00:00
|
|
|
Out << " {";
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2002-04-07 22:49:37 +00:00
|
|
|
// Output all of its basic blocks... for the function
|
2002-06-25 16:13:24 +00:00
|
|
|
for (Function::const_iterator I = F->begin(), E = F->end(); I != E; ++I)
|
|
|
|
printBasicBlock(I);
|
2001-09-07 16:36:04 +00:00
|
|
|
|
2004-06-21 21:53:56 +00:00
|
|
|
Out << "}\n";
|
2001-09-07 16:36:04 +00:00
|
|
|
}
|
|
|
|
|
2004-05-26 07:18:52 +00:00
|
|
|
Machine.purgeFunction();
|
2001-06-06 20:29:01 +00:00
|
|
|
}
|
|
|
|
|
2004-03-02 00:22:19 +00:00
|
|
|
/// printArgument - This member is called for every argument that is passed into
|
|
|
|
/// the function. Simply print it out
|
|
|
|
///
|
2008-02-19 21:38:47 +00:00
|
|
|
void AssemblyWriter::printArgument(const Argument *Arg,
|
2008-09-23 23:03:40 +00:00
|
|
|
Attributes Attrs) {
|
2001-06-06 20:29:01 +00:00
|
|
|
// Output type...
|
2009-02-28 21:26:53 +00:00
|
|
|
TypePrinter.print(Arg->getType(), Out);
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2007-11-27 13:23:08 +00:00
|
|
|
// Output parameter attributes list
|
2008-09-25 21:00:45 +00:00
|
|
|
if (Attrs != Attribute::None)
|
|
|
|
Out << ' ' << Attribute::getAsString(Attrs);
|
2006-12-31 05:24:50 +00:00
|
|
|
|
2001-06-06 20:29:01 +00:00
|
|
|
// Output name, if available...
|
2008-08-17 04:40:13 +00:00
|
|
|
if (Arg->hasName()) {
|
|
|
|
Out << ' ';
|
|
|
|
PrintLLVMName(Out, Arg);
|
|
|
|
}
|
2001-06-06 20:29:01 +00:00
|
|
|
}
|
|
|
|
|
2004-03-02 00:22:19 +00:00
|
|
|
/// printBasicBlock - This member is called for each basic block in a method.
|
|
|
|
///
|
2001-10-29 16:05:51 +00:00
|
|
|
void AssemblyWriter::printBasicBlock(const BasicBlock *BB) {
|
2008-04-25 16:53:59 +00:00
|
|
|
if (BB->hasName()) { // Print out the label if it exists...
|
2008-08-17 04:40:13 +00:00
|
|
|
Out << "\n";
|
2009-07-25 23:55:21 +00:00
|
|
|
PrintLLVMName(Out, BB->getName(), LabelPrefix);
|
2008-08-17 04:40:13 +00:00
|
|
|
Out << ':';
|
2008-04-25 16:53:59 +00:00
|
|
|
} else if (!BB->use_empty()) { // Don't print block # of no uses...
|
2008-04-21 04:20:33 +00:00
|
|
|
Out << "\n; <label>:";
|
2007-01-11 03:54:27 +00:00
|
|
|
int Slot = Machine.getLocalSlot(BB);
|
2004-06-09 19:41:19 +00:00
|
|
|
if (Slot != -1)
|
2004-06-21 21:53:56 +00:00
|
|
|
Out << Slot;
|
2004-06-09 19:41:19 +00:00
|
|
|
else
|
2004-06-21 21:53:56 +00:00
|
|
|
Out << "<badref>";
|
2002-10-02 19:38:55 +00:00
|
|
|
}
|
2003-11-20 00:09:43 +00:00
|
|
|
|
|
|
|
if (BB->getParent() == 0)
|
2004-06-21 21:53:56 +00:00
|
|
|
Out << "\t\t; Error: Block without parent!";
|
2008-04-22 02:45:44 +00:00
|
|
|
else if (BB != &BB->getParent()->getEntryBlock()) { // Not the entry block?
|
|
|
|
// Output predecessors for the block...
|
|
|
|
Out << "\t\t;";
|
|
|
|
pred_const_iterator PI = pred_begin(BB), PE = pred_end(BB);
|
|
|
|
|
|
|
|
if (PI == PE) {
|
|
|
|
Out << " No predecessors!";
|
|
|
|
} else {
|
2008-09-14 17:21:12 +00:00
|
|
|
Out << " preds = ";
|
2008-04-22 02:45:44 +00:00
|
|
|
writeOperand(*PI, false);
|
|
|
|
for (++PI; PI != PE; ++PI) {
|
2008-09-14 17:21:12 +00:00
|
|
|
Out << ", ";
|
2006-12-06 06:24:27 +00:00
|
|
|
writeOperand(*PI, false);
|
2003-11-16 22:59:57 +00:00
|
|
|
}
|
2002-10-02 19:38:55 +00:00
|
|
|
}
|
2001-06-06 20:29:01 +00:00
|
|
|
}
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2008-04-22 02:45:44 +00:00
|
|
|
Out << "\n";
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2004-06-21 21:53:56 +00:00
|
|
|
if (AnnotationWriter) AnnotationWriter->emitBasicBlockStartAnnot(BB, Out);
|
2003-10-30 23:41:03 +00:00
|
|
|
|
2001-09-07 16:36:04 +00:00
|
|
|
// Output all of the instructions in the basic block...
|
2009-07-13 18:27:59 +00:00
|
|
|
for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I != E; ++I) {
|
2002-06-25 16:13:24 +00:00
|
|
|
printInstruction(*I);
|
2009-07-13 18:27:59 +00:00
|
|
|
Out << '\n';
|
|
|
|
}
|
2004-03-08 18:51:45 +00:00
|
|
|
|
2004-06-21 21:53:56 +00:00
|
|
|
if (AnnotationWriter) AnnotationWriter->emitBasicBlockEndAnnot(BB, Out);
|
2001-06-06 20:29:01 +00:00
|
|
|
}
|
|
|
|
|
2001-10-13 06:42:36 +00:00
|
|
|
|
2004-03-02 00:22:19 +00:00
|
|
|
/// printInfoComment - Print a little comment after the instruction indicating
|
|
|
|
/// which slot it occupies.
|
|
|
|
///
|
2002-06-25 16:13:24 +00:00
|
|
|
void AssemblyWriter::printInfoComment(const Value &V) {
|
|
|
|
if (V.getType() != Type::VoidTy) {
|
2004-06-21 21:53:56 +00:00
|
|
|
Out << "\t\t; <";
|
2009-02-28 21:26:53 +00:00
|
|
|
TypePrinter.print(V.getType(), Out);
|
2008-08-19 05:26:17 +00:00
|
|
|
Out << '>';
|
2001-10-13 06:42:36 +00:00
|
|
|
|
2008-08-29 17:19:30 +00:00
|
|
|
if (!V.hasName() && !isa<Instruction>(V)) {
|
2007-01-11 03:54:27 +00:00
|
|
|
int SlotNum;
|
|
|
|
if (const GlobalValue *GV = dyn_cast<GlobalValue>(&V))
|
|
|
|
SlotNum = Machine.getGlobalSlot(GV);
|
|
|
|
else
|
|
|
|
SlotNum = Machine.getLocalSlot(&V);
|
2004-06-09 19:41:19 +00:00
|
|
|
if (SlotNum == -1)
|
2004-06-21 21:53:56 +00:00
|
|
|
Out << ":<badref>";
|
2004-06-09 15:26:53 +00:00
|
|
|
else
|
2004-06-21 21:53:56 +00:00
|
|
|
Out << ':' << SlotNum; // Print out the def slot taken.
|
2001-10-13 06:42:36 +00:00
|
|
|
}
|
2005-02-01 01:24:01 +00:00
|
|
|
Out << " [#uses=" << V.getNumUses() << ']'; // Output # uses
|
2001-10-13 06:42:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-08-28 01:02:49 +00:00
|
|
|
// This member is called for each Instruction in a function..
|
2002-06-25 16:13:24 +00:00
|
|
|
void AssemblyWriter::printInstruction(const Instruction &I) {
|
2004-06-21 21:53:56 +00:00
|
|
|
if (AnnotationWriter) AnnotationWriter->emitInstructionAnnot(&I, Out);
|
2003-10-30 23:41:03 +00:00
|
|
|
|
2008-08-23 22:52:27 +00:00
|
|
|
Out << '\t';
|
2001-06-06 20:29:01 +00:00
|
|
|
|
|
|
|
// Print out name if it exists...
|
2008-08-17 04:40:13 +00:00
|
|
|
if (I.hasName()) {
|
|
|
|
PrintLLVMName(Out, &I);
|
|
|
|
Out << " = ";
|
2008-08-29 17:19:30 +00:00
|
|
|
} else if (I.getType() != Type::VoidTy) {
|
|
|
|
// Print out the def slot taken.
|
|
|
|
int SlotNum = Machine.getLocalSlot(&I);
|
|
|
|
if (SlotNum == -1)
|
|
|
|
Out << "<badref> = ";
|
|
|
|
else
|
|
|
|
Out << '%' << SlotNum << " = ";
|
2008-08-17 04:40:13 +00:00
|
|
|
}
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2005-05-06 05:51:46 +00:00
|
|
|
// If this is a volatile load or store, print out the volatile marker.
|
2003-09-08 17:45:59 +00:00
|
|
|
if ((isa<LoadInst>(I) && cast<LoadInst>(I).isVolatile()) ||
|
2005-05-06 05:51:46 +00:00
|
|
|
(isa<StoreInst>(I) && cast<StoreInst>(I).isVolatile())) {
|
2004-06-21 21:53:56 +00:00
|
|
|
Out << "volatile ";
|
2005-05-06 05:51:46 +00:00
|
|
|
} else if (isa<CallInst>(I) && cast<CallInst>(I).isTailCall()) {
|
|
|
|
// If this is a call, check if it's a tail call.
|
|
|
|
Out << "tail ";
|
|
|
|
}
|
2003-09-08 17:45:59 +00:00
|
|
|
|
2001-06-06 20:29:01 +00:00
|
|
|
// Print out the opcode...
|
2004-06-21 21:53:56 +00:00
|
|
|
Out << I.getOpcodeName();
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2009-07-27 16:11:46 +00:00
|
|
|
// Print out optimization information.
|
|
|
|
WriteOptimizationInfo(Out, &I);
|
|
|
|
|
2006-12-03 06:27:29 +00:00
|
|
|
// Print out the compare instruction predicates
|
2008-05-12 19:01:56 +00:00
|
|
|
if (const CmpInst *CI = dyn_cast<CmpInst>(&I))
|
2008-08-23 22:52:27 +00:00
|
|
|
Out << ' ' << getPredicateText(CI->getPredicate());
|
2006-12-03 06:27:29 +00:00
|
|
|
|
2001-06-06 20:29:01 +00:00
|
|
|
// Print out the type of the operands...
|
2002-06-25 16:13:24 +00:00
|
|
|
const Value *Operand = I.getNumOperands() ? I.getOperand(0) : 0;
|
2001-06-06 20:29:01 +00:00
|
|
|
|
|
|
|
// Special case conditional branches to swizzle the condition out to the front
|
2009-02-09 15:45:06 +00:00
|
|
|
if (isa<BranchInst>(I) && cast<BranchInst>(I).isConditional()) {
|
|
|
|
BranchInst &BI(cast<BranchInst>(I));
|
2008-09-14 17:21:12 +00:00
|
|
|
Out << ' ';
|
2009-02-09 15:45:06 +00:00
|
|
|
writeOperand(BI.getCondition(), true);
|
2008-09-14 17:21:12 +00:00
|
|
|
Out << ", ";
|
2009-02-09 15:45:06 +00:00
|
|
|
writeOperand(BI.getSuccessor(0), true);
|
2008-09-14 17:21:12 +00:00
|
|
|
Out << ", ";
|
2009-02-09 15:45:06 +00:00
|
|
|
writeOperand(BI.getSuccessor(1), true);
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2002-04-13 18:34:38 +00:00
|
|
|
} else if (isa<SwitchInst>(I)) {
|
2001-06-06 20:29:01 +00:00
|
|
|
// Special case switch statement to get formatting nice and correct...
|
2008-09-14 17:21:12 +00:00
|
|
|
Out << ' ';
|
2008-08-23 22:52:27 +00:00
|
|
|
writeOperand(Operand , true);
|
2008-09-14 17:21:12 +00:00
|
|
|
Out << ", ";
|
2008-08-23 22:52:27 +00:00
|
|
|
writeOperand(I.getOperand(1), true);
|
|
|
|
Out << " [";
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2002-06-25 16:13:24 +00:00
|
|
|
for (unsigned op = 2, Eop = I.getNumOperands(); op < Eop; op += 2) {
|
2004-06-21 21:53:56 +00:00
|
|
|
Out << "\n\t\t";
|
2008-08-23 22:52:27 +00:00
|
|
|
writeOperand(I.getOperand(op ), true);
|
2008-09-14 17:21:12 +00:00
|
|
|
Out << ", ";
|
2002-06-25 16:13:24 +00:00
|
|
|
writeOperand(I.getOperand(op+1), true);
|
2001-06-06 20:29:01 +00:00
|
|
|
}
|
2004-06-21 21:53:56 +00:00
|
|
|
Out << "\n\t]";
|
2001-10-02 03:41:24 +00:00
|
|
|
} else if (isa<PHINode>(I)) {
|
2004-06-21 21:53:56 +00:00
|
|
|
Out << ' ';
|
2009-02-28 21:26:53 +00:00
|
|
|
TypePrinter.print(I.getType(), Out);
|
2004-06-21 21:53:56 +00:00
|
|
|
Out << ' ';
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2002-06-25 16:13:24 +00:00
|
|
|
for (unsigned op = 0, Eop = I.getNumOperands(); op < Eop; op += 2) {
|
2004-06-21 21:53:56 +00:00
|
|
|
if (op) Out << ", ";
|
2008-09-14 17:21:12 +00:00
|
|
|
Out << "[ ";
|
|
|
|
writeOperand(I.getOperand(op ), false); Out << ", ";
|
2004-06-21 21:53:56 +00:00
|
|
|
writeOperand(I.getOperand(op+1), false); Out << " ]";
|
2001-06-11 15:04:20 +00:00
|
|
|
}
|
2008-05-31 19:12:39 +00:00
|
|
|
} else if (const ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(&I)) {
|
2008-09-14 17:21:12 +00:00
|
|
|
Out << ' ';
|
2008-05-31 19:12:39 +00:00
|
|
|
writeOperand(I.getOperand(0), true);
|
|
|
|
for (const unsigned *i = EVI->idx_begin(), *e = EVI->idx_end(); i != e; ++i)
|
|
|
|
Out << ", " << *i;
|
|
|
|
} else if (const InsertValueInst *IVI = dyn_cast<InsertValueInst>(&I)) {
|
2008-09-14 17:21:12 +00:00
|
|
|
Out << ' ';
|
|
|
|
writeOperand(I.getOperand(0), true); Out << ", ";
|
2008-05-31 19:12:39 +00:00
|
|
|
writeOperand(I.getOperand(1), true);
|
|
|
|
for (const unsigned *i = IVI->idx_begin(), *e = IVI->idx_end(); i != e; ++i)
|
|
|
|
Out << ", " << *i;
|
2008-02-23 00:35:18 +00:00
|
|
|
} else if (isa<ReturnInst>(I) && !Operand) {
|
|
|
|
Out << " void";
|
2005-05-06 20:26:43 +00:00
|
|
|
} else if (const CallInst *CI = dyn_cast<CallInst>(&I)) {
|
|
|
|
// Print the calling convention being used.
|
|
|
|
switch (CI->getCallingConv()) {
|
|
|
|
case CallingConv::C: break; // default
|
2006-05-19 21:58:52 +00:00
|
|
|
case CallingConv::Fast: Out << " fastcc"; break;
|
|
|
|
case CallingConv::Cold: Out << " coldcc"; break;
|
2007-11-18 18:32:16 +00:00
|
|
|
case CallingConv::X86_StdCall: Out << " x86_stdcallcc"; break;
|
2009-06-16 18:50:49 +00:00
|
|
|
case CallingConv::X86_FastCall: Out << " x86_fastcallcc"; break;
|
|
|
|
case CallingConv::ARM_APCS: Out << " arm_apcscc "; break;
|
|
|
|
case CallingConv::ARM_AAPCS: Out << " arm_aapcscc "; break;
|
|
|
|
case CallingConv::ARM_AAPCS_VFP:Out << " arm_aapcs_vfpcc "; break;
|
2005-05-06 20:26:43 +00:00
|
|
|
default: Out << " cc" << CI->getCallingConv(); break;
|
|
|
|
}
|
|
|
|
|
2007-04-09 06:10:42 +00:00
|
|
|
const PointerType *PTy = cast<PointerType>(Operand->getType());
|
|
|
|
const FunctionType *FTy = cast<FunctionType>(PTy->getElementType());
|
|
|
|
const Type *RetTy = FTy->getReturnType();
|
2008-09-25 21:00:45 +00:00
|
|
|
const AttrListPtr &PAL = CI->getAttributes();
|
2001-11-06 21:28:12 +00:00
|
|
|
|
2008-09-29 20:49:50 +00:00
|
|
|
if (PAL.getRetAttributes() != Attribute::None)
|
|
|
|
Out << ' ' << Attribute::getAsString(PAL.getRetAttributes());
|
|
|
|
|
2003-08-05 15:34:45 +00:00
|
|
|
// If possible, print out the short form of the call instruction. We can
|
2002-04-07 22:49:37 +00:00
|
|
|
// only do this if the first argument is a pointer to a nonvararg function,
|
2003-08-05 15:34:45 +00:00
|
|
|
// and if the return type is not a pointer to a function.
|
2001-11-06 21:28:12 +00:00
|
|
|
//
|
2008-09-14 17:21:12 +00:00
|
|
|
Out << ' ';
|
2003-08-05 15:34:45 +00:00
|
|
|
if (!FTy->isVarArg() &&
|
2005-04-21 23:48:37 +00:00
|
|
|
(!isa<PointerType>(RetTy) ||
|
2002-07-25 20:58:51 +00:00
|
|
|
!isa<FunctionType>(cast<PointerType>(RetTy)->getElementType()))) {
|
2009-02-28 21:26:53 +00:00
|
|
|
TypePrinter.print(RetTy, Out);
|
2008-09-14 17:21:12 +00:00
|
|
|
Out << ' ';
|
2001-11-06 21:28:12 +00:00
|
|
|
writeOperand(Operand, false);
|
|
|
|
} else {
|
|
|
|
writeOperand(Operand, true);
|
|
|
|
}
|
2004-06-21 21:53:56 +00:00
|
|
|
Out << '(';
|
2006-12-31 05:24:50 +00:00
|
|
|
for (unsigned op = 1, Eop = I.getNumOperands(); op < Eop; ++op) {
|
|
|
|
if (op > 1)
|
2008-09-14 17:21:12 +00:00
|
|
|
Out << ", ";
|
2008-09-26 22:53:05 +00:00
|
|
|
writeParamOperand(I.getOperand(op), PAL.getParamAttributes(op));
|
2001-06-06 20:29:01 +00:00
|
|
|
}
|
2008-09-14 17:21:12 +00:00
|
|
|
Out << ')';
|
2008-09-26 22:53:05 +00:00
|
|
|
if (PAL.getFnAttributes() != Attribute::None)
|
|
|
|
Out << ' ' << Attribute::getAsString(PAL.getFnAttributes());
|
2002-06-25 16:13:24 +00:00
|
|
|
} else if (const InvokeInst *II = dyn_cast<InvokeInst>(&I)) {
|
2007-04-09 06:10:42 +00:00
|
|
|
const PointerType *PTy = cast<PointerType>(Operand->getType());
|
|
|
|
const FunctionType *FTy = cast<FunctionType>(PTy->getElementType());
|
|
|
|
const Type *RetTy = FTy->getReturnType();
|
2008-09-25 21:00:45 +00:00
|
|
|
const AttrListPtr &PAL = II->getAttributes();
|
2003-08-05 15:34:45 +00:00
|
|
|
|
2005-05-06 20:26:43 +00:00
|
|
|
// Print the calling convention being used.
|
|
|
|
switch (II->getCallingConv()) {
|
|
|
|
case CallingConv::C: break; // default
|
2006-05-19 21:58:52 +00:00
|
|
|
case CallingConv::Fast: Out << " fastcc"; break;
|
|
|
|
case CallingConv::Cold: Out << " coldcc"; break;
|
2008-09-14 17:21:12 +00:00
|
|
|
case CallingConv::X86_StdCall: Out << " x86_stdcallcc"; break;
|
|
|
|
case CallingConv::X86_FastCall: Out << " x86_fastcallcc"; break;
|
2009-06-16 18:50:49 +00:00
|
|
|
case CallingConv::ARM_APCS: Out << " arm_apcscc "; break;
|
|
|
|
case CallingConv::ARM_AAPCS: Out << " arm_aapcscc "; break;
|
|
|
|
case CallingConv::ARM_AAPCS_VFP:Out << " arm_aapcs_vfpcc "; break;
|
2005-05-06 20:26:43 +00:00
|
|
|
default: Out << " cc" << II->getCallingConv(); break;
|
|
|
|
}
|
|
|
|
|
2008-09-29 20:49:50 +00:00
|
|
|
if (PAL.getRetAttributes() != Attribute::None)
|
|
|
|
Out << ' ' << Attribute::getAsString(PAL.getRetAttributes());
|
|
|
|
|
2003-08-05 15:34:45 +00:00
|
|
|
// If possible, print out the short form of the invoke instruction. We can
|
|
|
|
// only do this if the first argument is a pointer to a nonvararg function,
|
|
|
|
// and if the return type is not a pointer to a function.
|
|
|
|
//
|
2008-10-15 18:02:08 +00:00
|
|
|
Out << ' ';
|
2003-08-05 15:34:45 +00:00
|
|
|
if (!FTy->isVarArg() &&
|
2005-04-21 23:48:37 +00:00
|
|
|
(!isa<PointerType>(RetTy) ||
|
2003-08-05 15:34:45 +00:00
|
|
|
!isa<FunctionType>(cast<PointerType>(RetTy)->getElementType()))) {
|
2009-02-28 21:26:53 +00:00
|
|
|
TypePrinter.print(RetTy, Out);
|
2008-10-15 18:02:08 +00:00
|
|
|
Out << ' ';
|
2003-08-05 15:34:45 +00:00
|
|
|
writeOperand(Operand, false);
|
|
|
|
} else {
|
|
|
|
writeOperand(Operand, true);
|
|
|
|
}
|
2004-06-21 21:53:56 +00:00
|
|
|
Out << '(';
|
2009-03-13 21:15:59 +00:00
|
|
|
for (unsigned op = 3, Eop = I.getNumOperands(); op < Eop; ++op) {
|
|
|
|
if (op > 3)
|
2008-09-14 17:21:12 +00:00
|
|
|
Out << ", ";
|
2009-03-13 21:15:59 +00:00
|
|
|
writeParamOperand(I.getOperand(op), PAL.getParamAttributes(op-2));
|
2001-10-13 06:42:36 +00:00
|
|
|
}
|
|
|
|
|
2008-09-14 17:21:12 +00:00
|
|
|
Out << ')';
|
2008-09-26 22:53:05 +00:00
|
|
|
if (PAL.getFnAttributes() != Attribute::None)
|
|
|
|
Out << ' ' << Attribute::getAsString(PAL.getFnAttributes());
|
|
|
|
|
2008-09-14 17:21:12 +00:00
|
|
|
Out << "\n\t\t\tto ";
|
2001-10-13 06:42:36 +00:00
|
|
|
writeOperand(II->getNormalDest(), true);
|
2008-09-14 17:21:12 +00:00
|
|
|
Out << " unwind ";
|
2004-02-08 21:44:31 +00:00
|
|
|
writeOperand(II->getUnwindDest(), true);
|
2001-10-13 06:42:36 +00:00
|
|
|
|
2002-06-25 16:13:24 +00:00
|
|
|
} else if (const AllocationInst *AI = dyn_cast<AllocationInst>(&I)) {
|
2004-06-21 21:53:56 +00:00
|
|
|
Out << ' ';
|
2009-02-28 21:26:53 +00:00
|
|
|
TypePrinter.print(AI->getType()->getElementType(), Out);
|
2002-04-13 18:34:38 +00:00
|
|
|
if (AI->isArrayAllocation()) {
|
2008-09-14 17:21:12 +00:00
|
|
|
Out << ", ";
|
2002-04-13 18:34:38 +00:00
|
|
|
writeOperand(AI->getArraySize(), true);
|
2001-06-06 20:29:01 +00:00
|
|
|
}
|
2005-11-05 09:21:28 +00:00
|
|
|
if (AI->getAlignment()) {
|
2005-11-05 21:20:34 +00:00
|
|
|
Out << ", align " << AI->getAlignment();
|
2005-11-05 09:21:28 +00:00
|
|
|
}
|
2001-10-13 06:42:36 +00:00
|
|
|
} else if (isa<CastInst>(I)) {
|
2008-09-14 17:21:12 +00:00
|
|
|
if (Operand) {
|
|
|
|
Out << ' ';
|
|
|
|
writeOperand(Operand, true); // Work with broken code
|
|
|
|
}
|
2004-06-21 21:53:56 +00:00
|
|
|
Out << " to ";
|
2009-02-28 21:26:53 +00:00
|
|
|
TypePrinter.print(I.getType(), Out);
|
2003-10-18 05:57:43 +00:00
|
|
|
} else if (isa<VAArgInst>(I)) {
|
2008-09-14 17:21:12 +00:00
|
|
|
if (Operand) {
|
|
|
|
Out << ' ';
|
|
|
|
writeOperand(Operand, true); // Work with broken code
|
|
|
|
}
|
2004-06-21 21:53:56 +00:00
|
|
|
Out << ", ";
|
2009-02-28 21:26:53 +00:00
|
|
|
TypePrinter.print(I.getType(), Out);
|
|
|
|
} else if (Operand) { // Print the normal way.
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2005-04-21 23:48:37 +00:00
|
|
|
// PrintAllTypes - Instructions who have operands of all the same type
|
2001-06-06 20:29:01 +00:00
|
|
|
// omit the type from all but the first operand. If the instruction has
|
|
|
|
// different type operands (for example br), then they are all printed.
|
|
|
|
bool PrintAllTypes = false;
|
|
|
|
const Type *TheType = Operand->getType();
|
|
|
|
|
2007-02-02 13:54:55 +00:00
|
|
|
// Select, Store and ShuffleVector always print all types.
|
2008-03-04 22:05:14 +00:00
|
|
|
if (isa<SelectInst>(I) || isa<StoreInst>(I) || isa<ShuffleVectorInst>(I)
|
|
|
|
|| isa<ReturnInst>(I)) {
|
2003-04-16 20:20:02 +00:00
|
|
|
PrintAllTypes = true;
|
|
|
|
} else {
|
|
|
|
for (unsigned i = 1, E = I.getNumOperands(); i != E; ++i) {
|
|
|
|
Operand = I.getOperand(i);
|
2009-01-15 18:40:57 +00:00
|
|
|
// note that Operand shouldn't be null, but the test helps make dump()
|
|
|
|
// more tolerant of malformed IR
|
2009-01-14 17:51:41 +00:00
|
|
|
if (Operand && Operand->getType() != TheType) {
|
2003-04-16 20:20:02 +00:00
|
|
|
PrintAllTypes = true; // We have differing types! Print them all!
|
|
|
|
break;
|
|
|
|
}
|
2001-06-06 20:29:01 +00:00
|
|
|
}
|
|
|
|
}
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2001-10-29 16:05:51 +00:00
|
|
|
if (!PrintAllTypes) {
|
2004-06-21 21:53:56 +00:00
|
|
|
Out << ' ';
|
2009-02-28 21:26:53 +00:00
|
|
|
TypePrinter.print(TheType, Out);
|
2001-10-29 16:05:51 +00:00
|
|
|
}
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2008-09-14 17:21:12 +00:00
|
|
|
Out << ' ';
|
2002-06-25 16:13:24 +00:00
|
|
|
for (unsigned i = 0, E = I.getNumOperands(); i != E; ++i) {
|
2008-09-14 17:21:12 +00:00
|
|
|
if (i) Out << ", ";
|
2002-06-25 16:13:24 +00:00
|
|
|
writeOperand(I.getOperand(i), PrintAllTypes);
|
2001-06-06 20:29:01 +00:00
|
|
|
}
|
|
|
|
}
|
2007-04-22 19:24:39 +00:00
|
|
|
|
|
|
|
// Print post operand alignment for load/store
|
|
|
|
if (isa<LoadInst>(I) && cast<LoadInst>(I).getAlignment()) {
|
|
|
|
Out << ", align " << cast<LoadInst>(I).getAlignment();
|
|
|
|
} else if (isa<StoreInst>(I) && cast<StoreInst>(I).getAlignment()) {
|
|
|
|
Out << ", align " << cast<StoreInst>(I).getAlignment();
|
|
|
|
}
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2001-10-13 06:42:36 +00:00
|
|
|
printInfoComment(I);
|
2001-06-06 20:29:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// External Interface declarations
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2003-10-30 23:41:03 +00:00
|
|
|
void Module::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const {
|
2008-08-23 22:23:09 +00:00
|
|
|
raw_os_ostream OS(o);
|
|
|
|
print(OS, AAW);
|
2001-06-06 20:29:01 +00:00
|
|
|
}
|
2008-08-23 22:23:09 +00:00
|
|
|
void Module::print(raw_ostream &OS, AssemblyAnnotationWriter *AAW) const {
|
|
|
|
SlotTracker SlotTable(this);
|
|
|
|
AssemblyWriter W(OS, SlotTable, this, AAW);
|
2002-04-08 22:03:40 +00:00
|
|
|
W.write(this);
|
|
|
|
}
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2008-08-23 22:23:09 +00:00
|
|
|
void Type::print(std::ostream &o) const {
|
|
|
|
raw_os_ostream OS(o);
|
|
|
|
print(OS);
|
2001-06-06 20:29:01 +00:00
|
|
|
}
|
|
|
|
|
2009-02-28 21:11:05 +00:00
|
|
|
void Type::print(raw_ostream &OS) const {
|
|
|
|
if (this == 0) {
|
|
|
|
OS << "<null Type>";
|
|
|
|
return;
|
|
|
|
}
|
2009-02-28 23:20:19 +00:00
|
|
|
TypePrinting().print(this, OS);
|
2001-06-06 20:29:01 +00:00
|
|
|
}
|
|
|
|
|
2008-08-23 22:23:09 +00:00
|
|
|
void Value::print(raw_ostream &OS, AssemblyAnnotationWriter *AAW) const {
|
|
|
|
if (this == 0) {
|
|
|
|
OS << "printing a <null> value\n";
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (const Instruction *I = dyn_cast<Instruction>(this)) {
|
|
|
|
const Function *F = I->getParent() ? I->getParent()->getParent() : 0;
|
|
|
|
SlotTracker SlotTable(F);
|
|
|
|
AssemblyWriter W(OS, SlotTable, F ? F->getParent() : 0, AAW);
|
|
|
|
W.write(I);
|
|
|
|
} else if (const BasicBlock *BB = dyn_cast<BasicBlock>(this)) {
|
|
|
|
SlotTracker SlotTable(BB->getParent());
|
|
|
|
AssemblyWriter W(OS, SlotTable,
|
|
|
|
BB->getParent() ? BB->getParent()->getParent() : 0, AAW);
|
|
|
|
W.write(BB);
|
|
|
|
} else if (const GlobalValue *GV = dyn_cast<GlobalValue>(this)) {
|
|
|
|
SlotTracker SlotTable(GV->getParent());
|
2009-04-20 16:10:33 +00:00
|
|
|
AssemblyWriter W(OS, SlotTable, GV->getParent(), AAW);
|
2008-08-23 22:23:09 +00:00
|
|
|
W.write(GV);
|
2009-07-22 17:43:22 +00:00
|
|
|
} else if (const MDString *MDS = dyn_cast<MDString>(this)) {
|
|
|
|
TypePrinting TypePrinter;
|
|
|
|
TypePrinter.print(MDS->getType(), OS);
|
|
|
|
OS << ' ';
|
|
|
|
OS << "!\"";
|
2009-07-25 23:55:21 +00:00
|
|
|
PrintEscapedString(MDS->getString(), OS);
|
2009-07-22 17:43:22 +00:00
|
|
|
OS << '"';
|
2009-07-01 20:59:15 +00:00
|
|
|
} else if (const MDNode *N = dyn_cast<MDNode>(this)) {
|
2009-07-08 21:44:25 +00:00
|
|
|
SlotTracker SlotTable(N);
|
2009-07-01 20:59:15 +00:00
|
|
|
TypePrinting TypePrinter;
|
2009-07-08 21:44:25 +00:00
|
|
|
SlotTable.initialize();
|
|
|
|
WriteMDNodes(OS, TypePrinter, SlotTable);
|
2009-07-30 00:02:57 +00:00
|
|
|
} else if (const NamedMDNode *N = dyn_cast<NamedMDNode>(this)) {
|
|
|
|
SlotTracker SlotTable(N);
|
|
|
|
TypePrinting TypePrinter;
|
|
|
|
SlotTable.initialize();
|
|
|
|
OS << "!" << N->getName() << " = !{";
|
|
|
|
for (unsigned i = 0, e = N->getNumElements(); i != e; ++i) {
|
|
|
|
if (i) OS << ", ";
|
2009-07-30 01:02:04 +00:00
|
|
|
MDNode *MD = dyn_cast_or_null<MDNode>(N->getElement(i));
|
|
|
|
if (MD)
|
|
|
|
OS << '!' << SlotTable.getMetadataSlot(MD);
|
|
|
|
else
|
|
|
|
OS << "null";
|
2009-07-30 00:02:57 +00:00
|
|
|
}
|
|
|
|
OS << "}\n";
|
|
|
|
WriteMDNodes(OS, TypePrinter, SlotTable);
|
2008-08-23 22:23:09 +00:00
|
|
|
} else if (const Constant *C = dyn_cast<Constant>(this)) {
|
2009-02-28 23:20:19 +00:00
|
|
|
TypePrinting TypePrinter;
|
2009-02-28 21:26:53 +00:00
|
|
|
TypePrinter.print(C->getType(), OS);
|
2009-02-28 21:11:05 +00:00
|
|
|
OS << ' ';
|
2009-02-28 20:25:14 +00:00
|
|
|
WriteConstantInt(OS, C, TypePrinter, 0);
|
2008-08-23 22:23:09 +00:00
|
|
|
} else if (const Argument *A = dyn_cast<Argument>(this)) {
|
|
|
|
WriteAsOperand(OS, this, true,
|
|
|
|
A->getParent() ? A->getParent()->getParent() : 0);
|
|
|
|
} else if (isa<InlineAsm>(this)) {
|
|
|
|
WriteAsOperand(OS, this, true, 0);
|
|
|
|
} else {
|
2009-07-14 16:55:14 +00:00
|
|
|
llvm_unreachable("Unknown value to print out!");
|
2008-08-23 22:23:09 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Value::print(std::ostream &O, AssemblyAnnotationWriter *AAW) const {
|
|
|
|
raw_os_ostream OS(O);
|
|
|
|
print(OS, AAW);
|
2002-04-08 22:03:40 +00:00
|
|
|
}
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2008-08-25 17:03:15 +00:00
|
|
|
// Value::dump - allow easy printing of Values from the debugger.
|
2009-03-23 15:57:19 +00:00
|
|
|
void Value::dump() const { print(errs()); errs() << '\n'; }
|
2004-05-25 18:14:38 +00:00
|
|
|
|
2008-10-01 20:16:19 +00:00
|
|
|
// Type::dump - allow easy printing of Types from the debugger.
|
|
|
|
// This one uses type names from the given context module
|
|
|
|
void Type::dump(const Module *Context) const {
|
|
|
|
WriteTypeSymbolic(errs(), this, Context);
|
|
|
|
errs() << '\n';
|
|
|
|
}
|
|
|
|
|
2009-02-28 21:05:51 +00:00
|
|
|
// Type::dump - allow easy printing of Types from the debugger.
|
|
|
|
void Type::dump() const { dump(0); }
|
|
|
|
|
2008-08-25 17:03:15 +00:00
|
|
|
// Module::dump() - Allow printing of Modules from the debugger.
|
2009-03-23 15:57:19 +00:00
|
|
|
void Module::dump() const { print(errs(), 0); }
|