-//===-- X86/Printer.cpp - Convert X86 code to human readable rep. ---------===//
+//===-- X86/Printer.cpp - Convert X86 LLVM code to Intel assembly ---------===//
//
-// This file contains a printer that converts from our internal representation
-// of LLVM code to a nice human readable form that is suitable for debugging.
+// This file contains a printer that converts from our internal
+// representation of machine-dependent LLVM code to Intel-format
+// assembly language. This printer is the output mechanism used
+// by `llc' and `lli -print-machineinstrs' on X86.
//
//===----------------------------------------------------------------------===//
#include "X86.h"
#include "X86InstrInfo.h"
-#include "llvm/Function.h"
-#include "llvm/Constant.h"
-#include "llvm/Target/TargetMachine.h"
+#include "llvm/Constants.h"
+#include "llvm/DerivedTypes.h"
+#include "llvm/Module.h"
+#include "llvm/Assembly/Writer.h"
#include "llvm/CodeGen/MachineFunctionPass.h"
#include "llvm/CodeGen/MachineConstantPool.h"
#include "llvm/CodeGen/MachineInstr.h"
+#include "llvm/Target/TargetMachine.h"
+#include "llvm/Support/Mangler.h"
#include "Support/Statistic.h"
-#include "Support/hash_map"
-#include "llvm/Type.h"
-#include "llvm/Constants.h"
-#include "llvm/Assembly/Writer.h"
-#include "llvm/DerivedTypes.h"
-#include "llvm/SlotCalculator.h"
#include "Support/StringExtras.h"
-#include "llvm/Module.h"
+#include "Support/CommandLine.h"
namespace {
- std::set<const Value *> MangledGlobals;
+ Statistic<> EmittedInsts("asm-printer", "Number of machine instrs printed");
+
+ // FIXME: This should be automatically picked up by autoconf from the C
+ // frontend
+ cl::opt<bool> EmitCygwin("enable-cygwin-compatible-output", cl::Hidden,
+ cl::desc("Emit X86 assembly code suitable for consumption by cygwin"));
+
struct Printer : public MachineFunctionPass {
+ /// Output stream on which we're printing assembly code.
+ ///
std::ostream &O;
+
+ /// Target machine description which we query for reg. names, data
+ /// layout, etc.
+ ///
+ TargetMachine &TM;
+
+ /// Name-mangler for global names.
+ ///
+ Mangler *Mang;
+
+ Printer(std::ostream &o, TargetMachine &tm) : O(o), TM(tm) { }
+
+ /// We name each basic block in a Function with a unique number, so
+ /// that we can consistently refer to them later. This is cleared
+ /// at the beginning of each call to runOnMachineFunction().
+ ///
typedef std::map<const Value *, unsigned> ValueMapTy;
ValueMapTy NumberForBB;
- Printer(std::ostream &o) : O(o) {}
- const TargetData *TD;
+
+ /// Cache of mangled name for current function. This is
+ /// recalculated at the beginning of each call to
+ /// runOnMachineFunction().
+ ///
std::string CurrentFnName;
+
virtual const char *getPassName() const {
return "X86 Assembly Printer";
}
- void printMachineInstruction(const MachineInstr *MI, std::ostream &O,
- const TargetMachine &TM) const;
- void printOp(std::ostream &O, const MachineOperand &MO,
- const MRegisterInfo &RI, bool elideOffsetKeyword = false) const;
- void printMemReference(std::ostream &O, const MachineInstr *MI,
- unsigned Op,
- const MRegisterInfo &RI) const;
+ void checkImplUses (const TargetInstrDescriptor &Desc);
+ void printMachineInstruction(const MachineInstr *MI);
+ void printOp(const MachineOperand &MO,
+ bool elideOffsetKeyword = false);
+ void printMemReference(const MachineInstr *MI, unsigned Op);
void printConstantPool(MachineConstantPool *MCP);
bool runOnMachineFunction(MachineFunction &F);
std::string ConstantExprToString(const ConstantExpr* CE);
std::string valToExprString(const Value* V);
bool doInitialization(Module &M);
bool doFinalization(Module &M);
- void PrintZeroBytesToPad(int numBytes);
- void printConstantValueOnly(const Constant* CV, int numPadBytesAfter = 0);
+ void printConstantValueOnly(const Constant* CV);
void printSingleConstantValue(const Constant* CV);
};
} // end of anonymous namespace
-/// createX86CodePrinterPass - Print out the specified machine code function to
-/// the specified stream. This function should work regardless of whether or
-/// not the function is in SSA form or not.
+/// createX86CodePrinterPass - Returns a pass that prints the X86
+/// assembly code for a MachineFunction to the given output stream,
+/// using the given target machine description. This should work
+/// regardless of whether the function is in SSA form.
///
-Pass *createX86CodePrinterPass(std::ostream &O) {
- return new Printer(O);
-}
-
-// We don't want identifier names with ., space, or - in them,
-// so we replace them with underscores.
-static std::string makeNameProper(std::string x) {
- std::string tmp;
- for (std::string::iterator sI = x.begin(), sEnd = x.end(); sI != sEnd; sI++)
- switch (*sI) {
- case '.': tmp += "d_"; break;
- case ' ': tmp += "s_"; break;
- case '-': tmp += "D_"; break;
- default: tmp += *sI;
- }
- return tmp;
+FunctionPass *createX86CodePrinterPass(std::ostream &o,TargetMachine &tm){
+ return new Printer(o, tm);
}
-static std::string getValueName(const Value *V) {
- if (V->hasName()) { // Print out the label if it exists...
- // Name mangling occurs as follows:
- // - If V is not a global, mangling always occurs.
- // - Otherwise, mangling occurs when any of the following are true:
- // 1) V has internal linkage
- // 2) V's name would collide if it is not mangled.
- //
- if(const GlobalValue* gv = dyn_cast<GlobalValue>(V)) {
- if(!gv->hasInternalLinkage() && !MangledGlobals.count(gv)) {
- // No internal linkage, name will not collide -> no mangling.
- return makeNameProper(gv->getName());
- }
- }
- // Non-global, or global with internal linkage / colliding name -> mangle.
- return "l" + utostr(V->getType()->getUniqueID()) + "_" +
- makeNameProper(V->getName());
- }
- static int Count = 0;
- Count++;
- return "ltmp_" + itostr(Count) + "_" + utostr(V->getType()->getUniqueID());
-}
-
-// valToExprString - Helper function for ConstantExprToString().
-// Appends result to argument string S.
-//
+/// valToExprString - Helper function for ConstantExprToString().
+/// Appends result to argument string S.
+///
std::string Printer::valToExprString(const Value* V) {
std::string S;
bool failed = false;
else
failed = true;
} else if (const GlobalValue* GV = dyn_cast<GlobalValue>(V)) {
- S += getValueName(GV);
+ S += Mang->getValueName(GV);
}
else
failed = true;
return S;
}
-// ConstantExprToString() - Convert a ConstantExpr to an asm expression
-// and return this as a string.
+/// ConstantExprToString - Convert a ConstantExpr to an asm expression
+/// and return this as a string.
+///
std::string Printer::ConstantExprToString(const ConstantExpr* CE) {
- std::string S;
+ const TargetData &TD = TM.getTargetData();
switch(CE->getOpcode()) {
case Instruction::GetElementPtr:
{ // generate a symbolic expression for the byte address
const Value* ptrVal = CE->getOperand(0);
std::vector<Value*> idxVec(CE->op_begin()+1, CE->op_end());
- S += "(" + valToExprString(ptrVal) + ") + ("
- + utostr(TD->getIndexedOffset(ptrVal->getType(),idxVec)) + ")";
- break;
+ if (unsigned Offset = TD.getIndexedOffset(ptrVal->getType(), idxVec))
+ return "(" + valToExprString(ptrVal) + ") + " + utostr(Offset);
+ else
+ return valToExprString(ptrVal);
}
case Instruction::Cast:
- // Support only non-converting casts for now, i.e., a no-op.
- // This assertion is not a complete check.
- assert(TD->getTypeSize(CE->getType()) ==
- TD->getTypeSize(CE->getOperand(0)->getType()));
- S += "(" + valToExprString(CE->getOperand(0)) + ")";
- break;
+ // Support only non-converting or widening casts for now, that is,
+ // ones that do not involve a change in value. This assertion is
+ // not a complete check.
+ {
+ Constant *Op = CE->getOperand(0);
+ const Type *OpTy = Op->getType(), *Ty = CE->getType();
+ assert(((isa<PointerType>(OpTy)
+ && (Ty == Type::LongTy || Ty == Type::ULongTy))
+ || (isa<PointerType>(Ty)
+ && (OpTy == Type::LongTy || OpTy == Type::ULongTy)))
+ || (((TD.getTypeSize(Ty) >= TD.getTypeSize(OpTy))
+ && (OpTy->isLosslesslyConvertibleTo(Ty))))
+ && "FIXME: Don't yet support this kind of constant cast expr");
+ return "(" + valToExprString(Op) + ")";
+ }
case Instruction::Add:
- S += "(" + valToExprString(CE->getOperand(0)) + ") + ("
- + valToExprString(CE->getOperand(1)) + ")";
- break;
+ return "(" + valToExprString(CE->getOperand(0)) + ") + ("
+ + valToExprString(CE->getOperand(1)) + ")";
default:
assert(0 && "Unsupported operator in ConstantExprToString()");
- break;
+ return "";
}
-
- return S;
}
-// Print a single constant value.
+/// printSingleConstantValue - Print a single constant value.
+///
void
Printer::printSingleConstantValue(const Constant* CV)
{
}
O << "\t";
- if (type->isPrimitiveType())
+ if (const ConstantExpr* CE = dyn_cast<ConstantExpr>(CV))
+ {
+ // Constant expression built from operators, constants, and
+ // symbolic addrs
+ O << ConstantExprToString(CE) << "\n";
+ }
+ else if (type->isPrimitiveType())
{
if (type->isFloatingPoint()) {
// FP Constants are printed as integer constants to avoid losing
{
// This is a constant address for a global variable or method.
// Use the name of the variable or method as the address value.
- O << getValueName(CPR->getValue()) << "\n";
+ O << Mang->getValueName(CPR->getValue()) << "\n";
}
else if (isa<ConstantPointerNull>(CV))
{
// Null pointer value
O << "0\n";
}
- else if (const ConstantExpr* CE = dyn_cast<ConstantExpr>(CV))
- {
- // Constant expression built from operators, constants, and
- // symbolic addrs
- O << ConstantExprToString(CE) << "\n";
- }
else
{
assert(0 && "Unknown elementary type for constant");
}
}
-// Can we treat the specified array as a string? Only if it is an array of
-// ubytes or non-negative sbytes.
-//
+/// isStringCompatible - Can we treat the specified array as a string?
+/// Only if it is an array of ubytes or non-negative sbytes.
+///
static bool isStringCompatible(const ConstantArray *CVA) {
const Type *ETy = cast<ArrayType>(CVA->getType())->getElementType();
if (ETy == Type::UByteTy) return true;
return true;
}
-// toOctal - Convert the low order bits of X into an octal letter
+/// toOctal - Convert the low order bits of X into an octal digit.
+///
static inline char toOctal(int X) {
return (X&7)+'0';
}
-// getAsCString - Return the specified array as a C compatible string, only if
-// the predicate isStringCompatible is true.
-//
+/// getAsCString - Return the specified array as a C compatible
+/// string, only if the predicate isStringCompatible is true.
+///
static std::string getAsCString(const ConstantArray *CVA) {
assert(isStringCompatible(CVA) && "Array is not string compatible!");
Result += C;
} else {
switch(C) {
- case '\a': Result += "\\a"; break;
case '\b': Result += "\\b"; break;
case '\f': Result += "\\f"; break;
case '\n': Result += "\\n"; break;
case '\r': Result += "\\r"; break;
case '\t': Result += "\\t"; break;
- case '\v': Result += "\\v"; break;
default:
Result += '\\';
Result += toOctal(C >> 6);
// Print a constant value or values (it may be an aggregate).
// Uses printSingleConstantValue() to print each individual value.
-void
-Printer::printConstantValueOnly(const Constant* CV,
- int numPadBytesAfter /* = 0 */)
-{
- const ConstantArray *CVA = dyn_cast<ConstantArray>(CV);
-
- if (CVA && isStringCompatible(CVA))
- { // print the string alone and return
- O << "\t" << ".string" << "\t" << getAsCString(CVA) << "\n";
- }
- else if (CVA)
- { // Not a string. Print the values in successive locations
+void Printer::printConstantValueOnly(const Constant *CV) {
+ const TargetData &TD = TM.getTargetData();
+
+ if (CV->isNullValue()) {
+ O << "\t.zero\t " << TD.getTypeSize(CV->getType()) << "\n";
+ } else if (const ConstantArray *CVA = dyn_cast<ConstantArray>(CV)) {
+ if (isStringCompatible(CVA)) {
+ // print the string alone and return
+ O << "\t.ascii\t" << getAsCString(CVA) << "\n";
+ } else { // Not a string. Print the values in successive locations
const std::vector<Use> &constValues = CVA->getValues();
for (unsigned i=0; i < constValues.size(); i++)
printConstantValueOnly(cast<Constant>(constValues[i].get()));
}
- else if (const ConstantStruct *CVS = dyn_cast<ConstantStruct>(CV))
- { // Print the fields in successive locations. Pad to align if needed!
- const StructLayout *cvsLayout =
- TD->getStructLayout(CVS->getType());
- const std::vector<Use>& constValues = CVS->getValues();
- unsigned sizeSoFar = 0;
- for (unsigned i=0, N = constValues.size(); i < N; i++)
- {
- const Constant* field = cast<Constant>(constValues[i].get());
-
- // Check if padding is needed and insert one or more 0s.
- unsigned fieldSize = TD->getTypeSize(field->getType());
- int padSize = ((i == N-1? cvsLayout->StructSize
- : cvsLayout->MemberOffsets[i+1])
- - cvsLayout->MemberOffsets[i]) - fieldSize;
- sizeSoFar += (fieldSize + padSize);
-
- // Now print the actual field value
- printConstantValueOnly(field, padSize);
- }
- assert(sizeSoFar == cvsLayout->StructSize &&
- "Layout of constant struct may be incorrect!");
+ } else if (const ConstantStruct *CVS = dyn_cast<ConstantStruct>(CV)) {
+ // Print the fields in successive locations. Pad to align if needed!
+ const StructLayout *cvsLayout = TD.getStructLayout(CVS->getType());
+ const std::vector<Use>& constValues = CVS->getValues();
+ unsigned sizeSoFar = 0;
+ for (unsigned i=0, N = constValues.size(); i < N; i++) {
+ const Constant* field = cast<Constant>(constValues[i].get());
+
+ // Check if padding is needed and insert one or more 0s.
+ unsigned fieldSize = TD.getTypeSize(field->getType());
+ unsigned padSize = ((i == N-1? cvsLayout->StructSize
+ : cvsLayout->MemberOffsets[i+1])
+ - cvsLayout->MemberOffsets[i]) - fieldSize;
+ sizeSoFar += fieldSize + padSize;
+
+ // Now print the actual field value
+ printConstantValueOnly(field);
+
+ // Insert the field padding unless it's zero bytes...
+ if (padSize)
+ O << "\t.zero\t " << padSize << "\n";
}
- else
+ assert(sizeSoFar == cvsLayout->StructSize &&
+ "Layout of constant struct may be incorrect!");
+ } else
printSingleConstantValue(CV);
-
- if (numPadBytesAfter) {
- unsigned numBytes = numPadBytesAfter;
- for ( ; numBytes >= 8; numBytes -= 8)
- printSingleConstantValue(Constant::getNullValue(Type::ULongTy));
- if (numBytes >= 4)
- {
- printSingleConstantValue(Constant::getNullValue(Type::UIntTy));
- numBytes -= 4;
- }
- while (numBytes--)
- printSingleConstantValue(Constant::getNullValue(Type::UByteTy));
- }
}
-// printConstantPool - Print out any constants which have been spilled to
-// memory...
-void Printer::printConstantPool(MachineConstantPool *MCP){
+/// printConstantPool - Print to the current output stream assembly
+/// representations of the constants in the constant pool MCP. This is
+/// used to print out constants which have been "spilled to memory" by
+/// the code generator.
+///
+void Printer::printConstantPool(MachineConstantPool *MCP) {
const std::vector<Constant*> &CP = MCP->getConstants();
+ const TargetData &TD = TM.getTargetData();
+
if (CP.empty()) return;
for (unsigned i = 0, e = CP.size(); i != e; ++i) {
O << "\t.section .rodata\n";
- O << "\t.align " << (unsigned)TD->getTypeAlignment(CP[i]->getType())
+ O << "\t.align " << (unsigned)TD.getTypeAlignment(CP[i]->getType())
<< "\n";
O << ".CPI" << CurrentFnName << "_" << i << ":\t\t\t\t\t#"
<< *CP[i] << "\n";
}
}
-/// runOnMachineFunction - This uses the X86InstructionInfo::print method
-/// to print assembly for each instruction.
+/// runOnMachineFunction - This uses the printMachineInstruction()
+/// method to print assembly for each instruction.
+///
bool Printer::runOnMachineFunction(MachineFunction &MF) {
+ // BBNumber is used here so that a given Printer will never give two
+ // BBs the same name. (If you have a better way, please let me know!)
static unsigned BBNumber = 0;
- const TargetMachine &TM = MF.getTarget();
- const TargetInstrInfo &TII = TM.getInstrInfo();
- TD = &TM.getTargetData();
+ O << "\n\n";
// What's my mangled name?
- CurrentFnName = getValueName(MF.getFunction());
+ CurrentFnName = Mang->getValueName(MF.getFunction());
// Print out constants referenced by the function
printConstantPool(MF.getConstantPool());
O << "\t.text\n";
O << "\t.align 16\n";
O << "\t.globl\t" << CurrentFnName << "\n";
- O << "\t.type\t" << CurrentFnName << ", @function\n";
+ if (!EmitCygwin)
+ O << "\t.type\t" << CurrentFnName << ", @function\n";
O << CurrentFnName << ":\n";
// Number each basic block so that we can consistently refer to them
for (MachineFunction::const_iterator I = MF.begin(), E = MF.end();
I != E; ++I) {
// Print a label for the basic block.
- O << ".BB" << NumberForBB[I->getBasicBlock()] << ":\t# "
+ O << ".LBB" << NumberForBB[I->getBasicBlock()] << ":\t# "
<< I->getBasicBlock()->getName() << "\n";
for (MachineBasicBlock::const_iterator II = I->begin(), E = I->end();
II != E; ++II) {
// Print the assembly for the instruction.
O << "\t";
- printMachineInstruction(*II, O, TM);
+ printMachineInstruction(*II);
}
}
MI->getOperand(Op+2).isRegister() &&MI->getOperand(Op+3).isImmediate();
}
-void Printer::printOp(std::ostream &O, const MachineOperand &MO,
- const MRegisterInfo &RI,
- bool elideOffsetKeyword /* = false */) const {
+
+
+void Printer::printOp(const MachineOperand &MO,
+ bool elideOffsetKeyword /* = false */) {
+ const MRegisterInfo &RI = *TM.getRegisterInfo();
switch (MO.getType()) {
case MachineOperand::MO_VirtualRegister:
if (Value *V = MO.getVRegValueOrNull()) {
// FALLTHROUGH
case MachineOperand::MO_MachineRegister:
if (MO.getReg() < MRegisterInfo::FirstVirtualRegister)
- O << RI.get(MO.getReg()).Name;
+ // Bug Workaround: See note in Printer::doInitialization about %.
+ O << "%" << RI.get(MO.getReg()).Name;
else
O << "%reg" << MO.getReg();
return;
case MachineOperand::MO_UnextendedImmed:
O << (int)MO.getImmedValue();
return;
- case MachineOperand::MO_PCRelativeDisp:
- {
- ValueMapTy::const_iterator i = NumberForBB.find(MO.getVRegValue());
- assert (i != NumberForBB.end()
- && "Could not find a BB I previously put in the NumberForBB map!");
- O << ".BB" << i->second << " # PC rel: " << MO.getVRegValue()->getName();
- }
+ case MachineOperand::MO_PCRelativeDisp: {
+ ValueMapTy::const_iterator i = NumberForBB.find(MO.getVRegValue());
+ assert (i != NumberForBB.end()
+ && "Could not find a BB in the NumberForBB map!");
+ O << ".LBB" << i->second << " # PC rel: " << MO.getVRegValue()->getName();
return;
+ }
case MachineOperand::MO_GlobalAddress:
- if (!elideOffsetKeyword) O << "OFFSET "; O << getValueName(MO.getGlobal());
+ if (!elideOffsetKeyword)
+ O << "OFFSET ";
+ O << Mang->getValueName(MO.getGlobal());
return;
case MachineOperand::MO_ExternalSymbol:
O << MO.getSymbolName();
}
}
-void Printer::printMemReference(std::ostream &O, const MachineInstr *MI,
- unsigned Op,
- const MRegisterInfo &RI) const {
+void Printer::printMemReference(const MachineInstr *MI, unsigned Op) {
assert(isMem(MI, Op) && "Invalid memory reference!");
if (MI->getOperand(Op).isFrameIndex()) {
O << "[";
bool NeedPlus = false;
if (BaseReg.getReg()) {
- printOp(O, BaseReg, RI);
+ printOp(BaseReg);
NeedPlus = true;
}
if (NeedPlus) O << " + ";
if (ScaleVal != 1)
O << ScaleVal << "*";
- printOp(O, IndexReg, RI);
+ printOp(IndexReg);
NeedPlus = true;
}
O << "]";
}
-/// printMachineInstruction -- Print out an x86 instruction in intel syntax
+/// checkImplUses - Emit the implicit-use registers for the
+/// instruction described by DESC, if its PrintImplUses flag is set.
///
-void Printer::printMachineInstruction(const MachineInstr *MI, std::ostream &O,
- const TargetMachine &TM) const {
+void Printer::checkImplUses (const TargetInstrDescriptor &Desc) {
+ const MRegisterInfo &RI = *TM.getRegisterInfo();
+ if (Desc.TSFlags & X86II::PrintImplUses) {
+ for (const unsigned *p = Desc.ImplicitUses; *p; ++p) {
+ // Bug Workaround: See note in Printer::doInitialization about %.
+ O << ", %" << RI.get(*p).Name;
+ }
+ }
+}
+
+/// printMachineInstruction -- Print out a single X86 LLVM instruction
+/// MI in Intel syntax to the current output stream.
+///
+void Printer::printMachineInstruction(const MachineInstr *MI) {
unsigned Opcode = MI->getOpcode();
const TargetInstrInfo &TII = TM.getInstrInfo();
const TargetInstrDescriptor &Desc = TII.get(Opcode);
- const MRegisterInfo &RI = *TM.getRegisterInfo();
+ ++EmittedInsts;
switch (Desc.TSFlags & X86II::FormMask) {
case X86II::Pseudo:
// Print pseudo-instructions as comments; either they should have been
// seen by the assembler (e.g., IMPLICIT_USEs.)
O << "# ";
if (Opcode == X86::PHI) {
- printOp(O, MI->getOperand(0), RI);
+ printOp(MI->getOperand(0));
O << " = phi ";
for (unsigned i = 1, e = MI->getNumOperands(); i != e; i+=2) {
if (i != 1) O << ", ";
O << "[";
- printOp(O, MI->getOperand(i), RI);
+ printOp(MI->getOperand(i));
O << ", ";
- printOp(O, MI->getOperand(i+1), RI);
+ printOp(MI->getOperand(i+1));
O << "]";
}
} else {
unsigned i = 0;
if (MI->getNumOperands() && (MI->getOperand(0).opIsDefOnly() ||
MI->getOperand(0).opIsDefAndUse())) {
- printOp(O, MI->getOperand(0), RI);
+ printOp(MI->getOperand(0));
O << " = ";
++i;
}
O << " ";
if (MI->getOperand(i).opIsDefOnly() ||
MI->getOperand(i).opIsDefAndUse()) O << "*";
- printOp(O, MI->getOperand(i), RI);
+ printOp(MI->getOperand(i));
if (MI->getOperand(i).opIsDefOnly() ||
MI->getOperand(i).opIsDefAndUse()) O << "*";
}
O << TII.getName(MI->getOpcode()) << " ";
if (MI->getNumOperands() == 1) {
- printOp(O, MI->getOperand(0), RI, true); // Don't print "OFFSET"...
+ printOp(MI->getOperand(0), true); // Don't print "OFFSET"...
}
O << "\n";
return;
unsigned Reg = MI->getOperand(0).getReg();
O << TII.getName(MI->getOpCode()) << " ";
- printOp(O, MI->getOperand(0), RI);
+ printOp(MI->getOperand(0));
if (MI->getNumOperands() == 2 &&
(!MI->getOperand(1).isRegister() ||
MI->getOperand(1).getVRegValueOrNull() ||
MI->getOperand(1).isGlobalAddress() ||
MI->getOperand(1).isExternalSymbol())) {
O << ", ";
- printOp(O, MI->getOperand(1), RI);
- }
- if (Desc.TSFlags & X86II::PrintImplUses) {
- for (const unsigned *p = Desc.ImplicitUses; *p; ++p) {
- O << ", " << RI.get(*p).Name;
- }
+ printOp(MI->getOperand(1));
}
+ checkImplUses(Desc);
O << "\n";
return;
}
&& "Bad format for MRMDestReg!");
O << TII.getName(MI->getOpCode()) << " ";
- printOp(O, MI->getOperand(0), RI);
+ printOp(MI->getOperand(0));
O << ", ";
- printOp(O, MI->getOperand(1+isTwoAddr), RI);
+ printOp(MI->getOperand(1+isTwoAddr));
if (MI->getNumOperands() == 4) {
O << ", ";
- printOp(O, MI->getOperand(3), RI);
+ printOp(MI->getOperand(3));
}
O << "\n";
return;
MI->getOperand(4).isRegister() && "Bad format for MRMDestMem!");
O << TII.getName(MI->getOpCode()) << " " << sizePtr(Desc) << " ";
- printMemReference(O, MI, 0, RI);
+ printMemReference(MI, 0);
O << ", ";
- printOp(O, MI->getOperand(4), RI);
+ printOp(MI->getOperand(4));
O << "\n";
return;
}
case X86II::MRMSrcReg: {
- // There is a two forms that are acceptable for MRMSrcReg instructions,
+ // There is are three forms that are acceptable for MRMSrcReg instructions,
// those with 3 and 2 operands:
//
// 3 Operands: in this form, the last register (the second input) is the
// ModR/M input. The first two operands should be the same, post register
// allocation. This is for things like: add r32, r/m32
//
+ // 3 Operands: in this form, we can have 'INST R, R, imm', which is used for
+ // instructions like the IMULri instructions.
+ //
// 2 Operands: this is for things like mov that do not read a second input
//
assert(MI->getOperand(0).isRegister() &&
MI->getOperand(1).isRegister() &&
(MI->getNumOperands() == 2 ||
- (MI->getNumOperands() == 3 && MI->getOperand(2).isRegister()))
+ (MI->getNumOperands() == 3 &&
+ (MI->getOperand(2).isRegister() ||
+ MI->getOperand(2).isImmediate())))
&& "Bad format for MRMSrcReg!");
if (MI->getNumOperands() == 3 &&
MI->getOperand(0).getReg() != MI->getOperand(1).getReg())
O << "**";
O << TII.getName(MI->getOpCode()) << " ";
- printOp(O, MI->getOperand(0), RI);
+ printOp(MI->getOperand(0));
+
+ // If this is IMULri* instructions, print the non-two-address operand.
+ if (MI->getNumOperands() == 3 && MI->getOperand(2).isImmediate()) {
+ O << ", ";
+ printOp(MI->getOperand(1));
+ }
+
O << ", ";
- printOp(O, MI->getOperand(MI->getNumOperands()-1), RI);
+ printOp(MI->getOperand(MI->getNumOperands()-1));
O << "\n";
return;
}
O << "**";
O << TII.getName(MI->getOpCode()) << " ";
- printOp(O, MI->getOperand(0), RI);
+ printOp(MI->getOperand(0));
O << ", " << sizePtr(Desc) << " ";
- printMemReference(O, MI, MI->getNumOperands()-4, RI);
+ printMemReference(MI, MI->getNumOperands()-4);
O << "\n";
return;
}
O << "**";
O << TII.getName(MI->getOpCode()) << " ";
- printOp(O, MI->getOperand(0), RI);
+ printOp(MI->getOperand(0));
if (MI->getOperand(MI->getNumOperands()-1).isImmediate()) {
O << ", ";
- printOp(O, MI->getOperand(MI->getNumOperands()-1), RI);
- }
- if (Desc.TSFlags & X86II::PrintImplUses) {
- for (const unsigned *p = Desc.ImplicitUses; *p; ++p) {
- O << ", " << RI.get(*p).Name;
- }
+ printOp(MI->getOperand(MI->getNumOperands()-1));
}
+ checkImplUses(Desc);
O << "\n";
return;
// expecting to see.
if (MI->getOpCode() == X86::FISTPr64) {
O << "fistpll DWORD PTR ";
- printMemReference(O, MI, 0, RI);
+ printMemReference(MI, 0);
if (MI->getNumOperands() == 5) {
O << ", ";
- printOp(O, MI->getOperand(4), RI);
+ printOp(MI->getOperand(4));
}
O << "\t# ";
}
O << TII.getName(MI->getOpCode()) << " ";
O << sizePtr(Desc) << " ";
- printMemReference(O, MI, 0, RI);
+ printMemReference(MI, 0);
if (MI->getNumOperands() == 5) {
O << ", ";
- printOp(O, MI->getOperand(4), RI);
+ printOp(MI->getOperand(4));
}
O << "\n";
return;
}
}
-bool Printer::doInitialization(Module &M)
-{
- // Tell gas we are outputting Intel syntax (not AT&T syntax) assembly,
- // with no % decorations on register names.
- O << "\t.intel_syntax noprefix\n";
-
- // Ripped from CWriter:
- // Calculate which global values have names that will collide when we throw
- // away type information.
- { // Scope to delete the FoundNames set when we are done with it...
- std::set<std::string> FoundNames;
- for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I)
- if (I->hasName()) // If the global has a name...
- if (FoundNames.count(I->getName())) // And the name is already used
- MangledGlobals.insert(I); // Mangle the name
- else
- FoundNames.insert(I->getName()); // Otherwise, keep track of name
-
- for (Module::giterator I = M.gbegin(), E = M.gend(); I != E; ++I)
- if (I->hasName()) // If the global has a name...
- if (FoundNames.count(I->getName())) // And the name is already used
- MangledGlobals.insert(I); // Mangle the name
- else
- FoundNames.insert(I->getName()); // Otherwise, keep track of name
- }
-
+bool Printer::doInitialization(Module &M) {
+ // Tell gas we are outputting Intel syntax (not AT&T syntax) assembly.
+ //
+ // Bug: gas in `intel_syntax noprefix' mode interprets the symbol `Sp' in an
+ // instruction as a reference to the register named sp, and if you try to
+ // reference a symbol `Sp' (e.g. `mov ECX, OFFSET Sp') then it gets lowercased
+ // before being looked up in the symbol table. This creates spurious
+ // `undefined symbol' errors when linking. Workaround: Do not use `noprefix'
+ // mode, and decorate all register names with percent signs.
+ O << "\t.intel_syntax\n";
+ Mang = new Mangler(M, EmitCygwin);
return false; // success
}
-static const Function *isConstantFunctionPointerRef(const Constant *C) {
- if (const ConstantPointerRef *R = dyn_cast<ConstantPointerRef>(C))
- if (const Function *F = dyn_cast<Function>(R->getValue()))
- return F;
- return 0;
+// SwitchSection - Switch to the specified section of the executable if we are
+// not already in it!
+//
+static void SwitchSection(std::ostream &OS, std::string &CurSection,
+ const char *NewSection) {
+ if (CurSection != NewSection) {
+ CurSection = NewSection;
+ if (!CurSection.empty())
+ OS << "\t" << NewSection << "\n";
+ }
}
bool Printer::doFinalization(Module &M) {
+ const TargetData &TD = TM.getTargetData();
+ std::string CurSection;
+
// Print out module-level global variables here.
- for (Module::const_giterator I = M.gbegin(), E = M.gend(); I != E; ++I) {
- std::string name(getValueName(I));
- if (I->hasInitializer()) {
+ for (Module::const_giterator I = M.gbegin(), E = M.gend(); I != E; ++I)
+ if (I->hasInitializer()) { // External global require no code
+ O << "\n\n";
+ std::string name = Mang->getValueName(I);
Constant *C = I->getInitializer();
- O << "\t.data\n";
- O << "\t.globl " << name << "\n";
- O << "\t.type " << name << ",@object\n";
- O << "\t.size " << name << ","
- << (unsigned)TD->getTypeSize(I->getType()) << "\n";
- O << "\t.align " << (unsigned)TD->getTypeAlignment(C->getType()) << "\n";
- O << name << ":\t\t\t\t\t#";
- // If this is a constant function pointer, we only print out the
- // name of the function in the comment (because printing the
- // function means calling AsmWriter to print the whole LLVM
- // assembly, which would corrupt the X86 assembly output.)
- // Otherwise we print out the whole llvm value as a comment.
- if (const Function *F = isConstantFunctionPointerRef (C)) {
- O << " %" << F->getName() << "()\n";
+ unsigned Size = TD.getTypeSize(C->getType());
+ unsigned Align = TD.getTypeAlignment(C->getType());
+
+ if (C->isNullValue() &&
+ (I->hasLinkOnceLinkage() || I->hasInternalLinkage() ||
+ I->hasWeakLinkage() /* FIXME: Verify correct */)) {
+ SwitchSection(O, CurSection, ".data");
+ if (I->hasInternalLinkage())
+ O << "\t.local " << name << "\n";
+
+ O << "\t.comm " << name << "," << TD.getTypeSize(C->getType())
+ << "," << (unsigned)TD.getTypeAlignment(C->getType());
+ O << "\t\t# ";
+ WriteAsOperand(O, I, true, true, &M);
+ O << "\n";
} else {
- O << *C << "\n";
+ switch (I->getLinkage()) {
+ case GlobalValue::LinkOnceLinkage:
+ case GlobalValue::WeakLinkage: // FIXME: Verify correct for weak.
+ // Nonnull linkonce -> weak
+ O << "\t.weak " << name << "\n";
+ SwitchSection(O, CurSection, "");
+ O << "\t.section\t.llvm.linkonce.d." << name << ",\"aw\",@progbits\n";
+ break;
+
+ case GlobalValue::AppendingLinkage:
+ // FIXME: appending linkage variables should go into a section of
+ // their name or something. For now, just emit them as external.
+ case GlobalValue::ExternalLinkage:
+ // If external or appending, declare as a global symbol
+ O << "\t.globl " << name << "\n";
+ // FALL THROUGH
+ case GlobalValue::InternalLinkage:
+ if (C->isNullValue())
+ SwitchSection(O, CurSection, ".bss");
+ else
+ SwitchSection(O, CurSection, ".data");
+ break;
+ }
+
+ O << "\t.align " << Align << "\n";
+ O << "\t.type " << name << ",@object\n";
+ O << "\t.size " << name << "," << Size << "\n";
+ O << name << ":\t\t\t\t# ";
+ WriteAsOperand(O, I, true, true, &M);
+ O << " = ";
+ WriteAsOperand(O, C, false, false, &M);
+ O << "\n";
+ printConstantValueOnly(C);
}
- printConstantValueOnly (C);
- } else {
- O << "\t.globl " << name << "\n";
- O << "\t.comm " << name << ", "
- << (unsigned)TD->getTypeSize(I->getType()) << ", "
- << (unsigned)TD->getTypeAlignment(I->getType()) << "\n";
}
- }
- MangledGlobals.clear();
+
+ delete Mang;
return false; // success
}