89b57061f7
This moves the registry higher in the LLVM library dependency stack. Every client of the target registry needs to link against MC anyway to actually use the target, so we might as well move this out of Support. This allows us to ensure that Support doesn't have includes from MC/*. Differential Revision: https://reviews.llvm.org/D111454
245 lines
8.1 KiB
C++
245 lines
8.1 KiB
C++
//===-- AVRAsmPrinter.cpp - AVR LLVM assembly writer ----------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file contains a printer that converts from our internal representation
|
|
// of machine-dependent LLVM code to GAS-format AVR assembly language.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "AVR.h"
|
|
#include "AVRMCInstLower.h"
|
|
#include "AVRSubtarget.h"
|
|
#include "MCTargetDesc/AVRInstPrinter.h"
|
|
#include "MCTargetDesc/AVRMCExpr.h"
|
|
#include "TargetInfo/AVRTargetInfo.h"
|
|
|
|
#include "llvm/CodeGen/AsmPrinter.h"
|
|
#include "llvm/CodeGen/MachineFunction.h"
|
|
#include "llvm/CodeGen/MachineInstr.h"
|
|
#include "llvm/CodeGen/TargetRegisterInfo.h"
|
|
#include "llvm/CodeGen/TargetSubtargetInfo.h"
|
|
#include "llvm/IR/Mangler.h"
|
|
#include "llvm/MC/MCContext.h"
|
|
#include "llvm/MC/MCInst.h"
|
|
#include "llvm/MC/MCStreamer.h"
|
|
#include "llvm/MC/MCSymbol.h"
|
|
#include "llvm/MC/TargetRegistry.h"
|
|
#include "llvm/Support/ErrorHandling.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
|
|
#define DEBUG_TYPE "avr-asm-printer"
|
|
|
|
namespace llvm {
|
|
|
|
/// An AVR assembly code printer.
|
|
class AVRAsmPrinter : public AsmPrinter {
|
|
public:
|
|
AVRAsmPrinter(TargetMachine &TM, std::unique_ptr<MCStreamer> Streamer)
|
|
: AsmPrinter(TM, std::move(Streamer)), MRI(*TM.getMCRegisterInfo()) {}
|
|
|
|
StringRef getPassName() const override { return "AVR Assembly Printer"; }
|
|
|
|
void printOperand(const MachineInstr *MI, unsigned OpNo, raw_ostream &O);
|
|
|
|
bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNum,
|
|
const char *ExtraCode, raw_ostream &O) override;
|
|
|
|
bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNum,
|
|
const char *ExtraCode, raw_ostream &O) override;
|
|
|
|
void emitInstruction(const MachineInstr *MI) override;
|
|
|
|
const MCExpr *lowerConstant(const Constant *CV) override;
|
|
|
|
void emitXXStructor(const DataLayout &DL, const Constant *CV) override;
|
|
|
|
bool doFinalization(Module &M) override;
|
|
|
|
private:
|
|
const MCRegisterInfo &MRI;
|
|
bool EmittedStructorSymbolAttrs = false;
|
|
};
|
|
|
|
void AVRAsmPrinter::printOperand(const MachineInstr *MI, unsigned OpNo,
|
|
raw_ostream &O) {
|
|
const MachineOperand &MO = MI->getOperand(OpNo);
|
|
|
|
switch (MO.getType()) {
|
|
case MachineOperand::MO_Register:
|
|
O << AVRInstPrinter::getPrettyRegisterName(MO.getReg(), MRI);
|
|
break;
|
|
case MachineOperand::MO_Immediate:
|
|
O << MO.getImm();
|
|
break;
|
|
case MachineOperand::MO_GlobalAddress:
|
|
O << getSymbol(MO.getGlobal());
|
|
break;
|
|
case MachineOperand::MO_ExternalSymbol:
|
|
O << *GetExternalSymbolSymbol(MO.getSymbolName());
|
|
break;
|
|
case MachineOperand::MO_MachineBasicBlock:
|
|
O << *MO.getMBB()->getSymbol();
|
|
break;
|
|
default:
|
|
llvm_unreachable("Not implemented yet!");
|
|
}
|
|
}
|
|
|
|
bool AVRAsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNum,
|
|
const char *ExtraCode, raw_ostream &O) {
|
|
// Default asm printer can only deal with some extra codes,
|
|
// so try it first.
|
|
bool Error = AsmPrinter::PrintAsmOperand(MI, OpNum, ExtraCode, O);
|
|
|
|
if (Error && ExtraCode && ExtraCode[0]) {
|
|
if (ExtraCode[1] != 0)
|
|
return true; // Unknown modifier.
|
|
|
|
if (ExtraCode[0] >= 'A' && ExtraCode[0] <= 'Z') {
|
|
const MachineOperand &RegOp = MI->getOperand(OpNum);
|
|
|
|
assert(RegOp.isReg() && "Operand must be a register when you're"
|
|
"using 'A'..'Z' operand extracodes.");
|
|
Register Reg = RegOp.getReg();
|
|
|
|
unsigned ByteNumber = ExtraCode[0] - 'A';
|
|
|
|
unsigned OpFlags = MI->getOperand(OpNum - 1).getImm();
|
|
unsigned NumOpRegs = InlineAsm::getNumOperandRegisters(OpFlags);
|
|
(void)NumOpRegs;
|
|
|
|
const AVRSubtarget &STI = MF->getSubtarget<AVRSubtarget>();
|
|
const TargetRegisterInfo &TRI = *STI.getRegisterInfo();
|
|
|
|
const TargetRegisterClass *RC = TRI.getMinimalPhysRegClass(Reg);
|
|
unsigned BytesPerReg = TRI.getRegSizeInBits(*RC) / 8;
|
|
assert(BytesPerReg <= 2 && "Only 8 and 16 bit regs are supported.");
|
|
|
|
unsigned RegIdx = ByteNumber / BytesPerReg;
|
|
assert(RegIdx < NumOpRegs && "Multibyte index out of range.");
|
|
|
|
Reg = MI->getOperand(OpNum + RegIdx).getReg();
|
|
|
|
if (BytesPerReg == 2) {
|
|
Reg = TRI.getSubReg(Reg, ByteNumber % BytesPerReg ? AVR::sub_hi
|
|
: AVR::sub_lo);
|
|
}
|
|
|
|
O << AVRInstPrinter::getPrettyRegisterName(Reg, MRI);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (Error)
|
|
printOperand(MI, OpNum, O);
|
|
|
|
return false;
|
|
}
|
|
|
|
bool AVRAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI,
|
|
unsigned OpNum, const char *ExtraCode,
|
|
raw_ostream &O) {
|
|
if (ExtraCode && ExtraCode[0]) {
|
|
llvm_unreachable("This branch is not implemented yet");
|
|
}
|
|
|
|
const MachineOperand &MO = MI->getOperand(OpNum);
|
|
(void)MO;
|
|
assert(MO.isReg() && "Unexpected inline asm memory operand");
|
|
|
|
// TODO: We should be able to look up the alternative name for
|
|
// the register if it's given.
|
|
// TableGen doesn't expose a way of getting retrieving names
|
|
// for registers.
|
|
if (MI->getOperand(OpNum).getReg() == AVR::R31R30) {
|
|
O << "Z";
|
|
} else {
|
|
assert(MI->getOperand(OpNum).getReg() == AVR::R29R28 &&
|
|
"Wrong register class for memory operand.");
|
|
O << "Y";
|
|
}
|
|
|
|
// If NumOpRegs == 2, then we assume it is product of a FrameIndex expansion
|
|
// and the second operand is an Imm.
|
|
unsigned OpFlags = MI->getOperand(OpNum - 1).getImm();
|
|
unsigned NumOpRegs = InlineAsm::getNumOperandRegisters(OpFlags);
|
|
|
|
if (NumOpRegs == 2) {
|
|
O << '+' << MI->getOperand(OpNum + 1).getImm();
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void AVRAsmPrinter::emitInstruction(const MachineInstr *MI) {
|
|
AVRMCInstLower MCInstLowering(OutContext, *this);
|
|
|
|
MCInst I;
|
|
MCInstLowering.lowerInstruction(*MI, I);
|
|
EmitToStreamer(*OutStreamer, I);
|
|
}
|
|
|
|
const MCExpr *AVRAsmPrinter::lowerConstant(const Constant *CV) {
|
|
MCContext &Ctx = OutContext;
|
|
|
|
if (const GlobalValue *GV = dyn_cast<GlobalValue>(CV)) {
|
|
bool IsProgMem = GV->getAddressSpace() == AVR::ProgramMemory;
|
|
if (IsProgMem) {
|
|
const MCExpr *Expr = MCSymbolRefExpr::create(getSymbol(GV), Ctx);
|
|
return AVRMCExpr::create(AVRMCExpr::VK_AVR_PM, Expr, false, Ctx);
|
|
}
|
|
}
|
|
|
|
return AsmPrinter::lowerConstant(CV);
|
|
}
|
|
|
|
void AVRAsmPrinter::emitXXStructor(const DataLayout &DL, const Constant *CV) {
|
|
if (!EmittedStructorSymbolAttrs) {
|
|
OutStreamer->emitRawComment(
|
|
" Emitting these undefined symbol references causes us to link the"
|
|
" libgcc code that runs our constructors/destructors");
|
|
OutStreamer->emitRawComment(" This matches GCC's behavior");
|
|
|
|
MCSymbol *CtorsSym = OutContext.getOrCreateSymbol("__do_global_ctors");
|
|
OutStreamer->emitSymbolAttribute(CtorsSym, MCSA_Global);
|
|
|
|
MCSymbol *DtorsSym = OutContext.getOrCreateSymbol("__do_global_dtors");
|
|
OutStreamer->emitSymbolAttribute(DtorsSym, MCSA_Global);
|
|
|
|
EmittedStructorSymbolAttrs = true;
|
|
}
|
|
|
|
AsmPrinter::emitXXStructor(DL, CV);
|
|
}
|
|
|
|
bool AVRAsmPrinter::doFinalization(Module &M) {
|
|
MCSymbol *DoCopyData = OutContext.getOrCreateSymbol("__do_copy_data");
|
|
MCSymbol *DoClearBss = OutContext.getOrCreateSymbol("__do_clear_bss");
|
|
|
|
// FIXME: We can disable __do_copy_data if there are no static RAM variables.
|
|
|
|
OutStreamer->emitRawComment(
|
|
" Declaring this symbol tells the CRT that it should");
|
|
OutStreamer->emitRawComment(
|
|
"copy all variables from program memory to RAM on startup");
|
|
OutStreamer->emitSymbolAttribute(DoCopyData, MCSA_Global);
|
|
|
|
OutStreamer->emitRawComment(
|
|
" Declaring this symbol tells the CRT that it should");
|
|
OutStreamer->emitRawComment("clear the zeroed data section on startup");
|
|
OutStreamer->emitSymbolAttribute(DoClearBss, MCSA_Global);
|
|
|
|
return AsmPrinter::doFinalization(M);
|
|
}
|
|
|
|
} // end of namespace llvm
|
|
|
|
extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeAVRAsmPrinter() {
|
|
llvm::RegisterAsmPrinter<llvm::AVRAsmPrinter> X(llvm::getTheAVRTarget());
|
|
}
|