mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-09-08 23:55:03 +00:00
verbose-asm mode, print comments instead. This eliminates a non-comment difference between verbose-asm mode and non-verbose-asm mode. Also, factor out the relevant code out of all the targets and into target-independent code. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@83392 91177308-0d34-0410-b5e6-96231b3b80d8
243 lines
7.7 KiB
C++
243 lines
7.7 KiB
C++
//===-- BlackfinAsmPrinter.cpp - Blackfin LLVM assembly writer ------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file contains a printer that converts from our internal representation
|
|
// of machine-dependent LLVM code to GAS-format BLACKFIN assembly language.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#define DEBUG_TYPE "asm-printer"
|
|
#include "Blackfin.h"
|
|
#include "BlackfinInstrInfo.h"
|
|
#include "llvm/Constants.h"
|
|
#include "llvm/DerivedTypes.h"
|
|
#include "llvm/Module.h"
|
|
#include "llvm/CodeGen/AsmPrinter.h"
|
|
#include "llvm/CodeGen/DwarfWriter.h"
|
|
#include "llvm/CodeGen/MachineFunctionPass.h"
|
|
#include "llvm/CodeGen/MachineConstantPool.h"
|
|
#include "llvm/CodeGen/MachineInstr.h"
|
|
#include "llvm/MC/MCStreamer.h"
|
|
#include "llvm/MC/MCAsmInfo.h"
|
|
#include "llvm/MC/MCSymbol.h"
|
|
#include "llvm/Target/TargetData.h"
|
|
#include "llvm/Target/TargetLoweringObjectFile.h"
|
|
#include "llvm/Target/TargetRegistry.h"
|
|
#include "llvm/Support/Mangler.h"
|
|
#include "llvm/ADT/Statistic.h"
|
|
#include "llvm/Support/FormattedStream.h"
|
|
|
|
using namespace llvm;
|
|
|
|
STATISTIC(EmittedInsts, "Number of machine instrs printed");
|
|
|
|
namespace {
|
|
class VISIBILITY_HIDDEN BlackfinAsmPrinter : public AsmPrinter {
|
|
public:
|
|
BlackfinAsmPrinter(formatted_raw_ostream &O, TargetMachine &TM,
|
|
const MCAsmInfo *MAI, bool V)
|
|
: AsmPrinter(O, TM, MAI, V) {}
|
|
|
|
virtual const char *getPassName() const {
|
|
return "Blackfin Assembly Printer";
|
|
}
|
|
|
|
void printOperand(const MachineInstr *MI, int opNum);
|
|
void printMemoryOperand(const MachineInstr *MI, int opNum);
|
|
void printInstruction(const MachineInstr *MI); // autogenerated.
|
|
static const char *getRegisterName(unsigned RegNo);
|
|
|
|
void emitLinkage(const std::string &n, GlobalValue::LinkageTypes l);
|
|
bool runOnMachineFunction(MachineFunction &F);
|
|
bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
|
|
unsigned AsmVariant, const char *ExtraCode);
|
|
bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo,
|
|
unsigned AsmVariant, const char *ExtraCode);
|
|
void PrintGlobalVariable(const GlobalVariable* GVar);
|
|
};
|
|
} // end of anonymous namespace
|
|
|
|
#include "BlackfinGenAsmWriter.inc"
|
|
|
|
extern "C" void LLVMInitializeBlackfinAsmPrinter() {
|
|
RegisterAsmPrinter<BlackfinAsmPrinter> X(TheBlackfinTarget);
|
|
}
|
|
|
|
void BlackfinAsmPrinter::emitLinkage(const std::string &name,
|
|
GlobalValue::LinkageTypes l) {
|
|
switch (l) {
|
|
default: llvm_unreachable("Unknown linkage type!");
|
|
case GlobalValue::InternalLinkage: // Symbols default to internal.
|
|
case GlobalValue::PrivateLinkage:
|
|
case GlobalValue::LinkerPrivateLinkage:
|
|
break;
|
|
case GlobalValue::ExternalLinkage:
|
|
O << MAI->getGlobalDirective() << name << "\n";
|
|
break;
|
|
case GlobalValue::LinkOnceAnyLinkage:
|
|
case GlobalValue::LinkOnceODRLinkage:
|
|
case GlobalValue::WeakAnyLinkage:
|
|
case GlobalValue::WeakODRLinkage:
|
|
O << MAI->getGlobalDirective() << name << "\n";
|
|
O << MAI->getWeakDefDirective() << name << "\n";
|
|
break;
|
|
}
|
|
}
|
|
|
|
void BlackfinAsmPrinter::PrintGlobalVariable(const GlobalVariable* GV) {
|
|
const TargetData *TD = TM.getTargetData();
|
|
|
|
if (!GV->hasInitializer() || EmitSpecialLLVMGlobal(GV))
|
|
return;
|
|
|
|
std::string name = Mang->getMangledName(GV);
|
|
Constant *C = GV->getInitializer();
|
|
|
|
OutStreamer.SwitchSection(getObjFileLowering().SectionForGlobal(GV, Mang,
|
|
TM));
|
|
emitLinkage(name, GV->getLinkage());
|
|
EmitAlignment(TD->getPreferredAlignmentLog(GV), GV);
|
|
printVisibility(name, GV->getVisibility());
|
|
|
|
O << "\t.type " << name << ", STT_OBJECT\n";
|
|
O << "\t.size " << name << ',' << TD->getTypeAllocSize(C->getType()) << '\n';
|
|
O << name << ":\n";
|
|
EmitGlobalConstant(C);
|
|
}
|
|
|
|
/// runOnMachineFunction - This uses the printInstruction()
|
|
/// method to print assembly for each instruction.
|
|
///
|
|
bool BlackfinAsmPrinter::runOnMachineFunction(MachineFunction &MF) {
|
|
SetupMachineFunction(MF);
|
|
EmitConstantPool(MF.getConstantPool());
|
|
EmitJumpTableInfo(MF.getJumpTableInfo(), MF);
|
|
|
|
const Function *F = MF.getFunction();
|
|
OutStreamer.SwitchSection(getObjFileLowering().SectionForGlobal(F, Mang, TM));
|
|
EmitAlignment(2, F);
|
|
emitLinkage(CurrentFnName, F->getLinkage());
|
|
printVisibility(CurrentFnName, F->getVisibility());
|
|
|
|
O << "\t.type\t" << CurrentFnName << ", STT_FUNC\n"
|
|
<< CurrentFnName << ":\n";
|
|
|
|
if (DW)
|
|
DW->BeginFunction(&MF);
|
|
|
|
// Print out code for the function.
|
|
for (MachineFunction::const_iterator I = MF.begin(), E = MF.end();
|
|
I != E; ++I) {
|
|
// Print a label for the basic block.
|
|
EmitBasicBlockStart(I);
|
|
|
|
for (MachineBasicBlock::const_iterator II = I->begin(), E = I->end();
|
|
II != E; ++II) {
|
|
// Print the assembly for the instruction.
|
|
processDebugLoc(II, true);
|
|
|
|
printInstruction(II);
|
|
if (VerboseAsm && !II->getDebugLoc().isUnknown())
|
|
EmitComments(*II);
|
|
O << '\n';
|
|
|
|
processDebugLoc(II, false);
|
|
++EmittedInsts;
|
|
}
|
|
}
|
|
|
|
O << "\t.size " << CurrentFnName << ", .-" << CurrentFnName << "\n";
|
|
|
|
if (DW)
|
|
DW->EndFunction(&MF);
|
|
|
|
return false;
|
|
}
|
|
|
|
void BlackfinAsmPrinter::printOperand(const MachineInstr *MI, int opNum) {
|
|
const MachineOperand &MO = MI->getOperand (opNum);
|
|
switch (MO.getType()) {
|
|
case MachineOperand::MO_Register:
|
|
assert(TargetRegisterInfo::isPhysicalRegister(MO.getReg()) &&
|
|
"Virtual registers should be already mapped!");
|
|
O << getRegisterName(MO.getReg());
|
|
break;
|
|
|
|
case MachineOperand::MO_Immediate:
|
|
O << MO.getImm();
|
|
break;
|
|
case MachineOperand::MO_MachineBasicBlock:
|
|
GetMBBSymbol(MO.getMBB()->getNumber())->print(O, MAI);
|
|
return;
|
|
case MachineOperand::MO_GlobalAddress:
|
|
O << Mang->getMangledName(MO.getGlobal());
|
|
printOffset(MO.getOffset());
|
|
break;
|
|
case MachineOperand::MO_ExternalSymbol:
|
|
O << Mang->makeNameProper(MO.getSymbolName());
|
|
break;
|
|
case MachineOperand::MO_ConstantPoolIndex:
|
|
O << MAI->getPrivateGlobalPrefix() << "CPI" << getFunctionNumber() << "_"
|
|
<< MO.getIndex();
|
|
break;
|
|
case MachineOperand::MO_JumpTableIndex:
|
|
O << MAI->getPrivateGlobalPrefix() << "JTI" << getFunctionNumber()
|
|
<< '_' << MO.getIndex();
|
|
break;
|
|
default:
|
|
llvm_unreachable("<unknown operand type>");
|
|
break;
|
|
}
|
|
}
|
|
|
|
void BlackfinAsmPrinter::printMemoryOperand(const MachineInstr *MI, int opNum) {
|
|
printOperand(MI, opNum);
|
|
|
|
if (MI->getOperand(opNum+1).isImm() && MI->getOperand(opNum+1).getImm() == 0)
|
|
return;
|
|
|
|
O << " + ";
|
|
printOperand(MI, opNum+1);
|
|
}
|
|
|
|
/// PrintAsmOperand - Print out an operand for an inline asm expression.
|
|
///
|
|
bool BlackfinAsmPrinter::PrintAsmOperand(const MachineInstr *MI,
|
|
unsigned OpNo,
|
|
unsigned AsmVariant,
|
|
const char *ExtraCode) {
|
|
if (ExtraCode && ExtraCode[0]) {
|
|
if (ExtraCode[1] != 0) return true; // Unknown modifier.
|
|
|
|
switch (ExtraCode[0]) {
|
|
default: return true; // Unknown modifier.
|
|
case 'r':
|
|
break;
|
|
}
|
|
}
|
|
|
|
printOperand(MI, OpNo);
|
|
|
|
return false;
|
|
}
|
|
|
|
bool BlackfinAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI,
|
|
unsigned OpNo,
|
|
unsigned AsmVariant,
|
|
const char *ExtraCode) {
|
|
if (ExtraCode && ExtraCode[0])
|
|
return true; // Unknown modifier
|
|
|
|
O << '[';
|
|
printOperand(MI, OpNo);
|
|
O << ']';
|
|
|
|
return false;
|
|
}
|