| //===-- 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 "AVRTargetMachine.h" |
| #include "MCTargetDesc/AVRInstPrinter.h" |
| #include "MCTargetDesc/AVRMCExpr.h" |
| #include "TargetInfo/AVRTargetInfo.h" |
| |
| #include "llvm/BinaryFormat/ELF.h" |
| #include "llvm/CodeGen/AsmPrinter.h" |
| #include "llvm/CodeGen/MachineFunction.h" |
| #include "llvm/CodeGen/MachineInstr.h" |
| #include "llvm/CodeGen/MachineModuleInfo.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/MCSectionELF.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" |
| #include "llvm/Target/TargetLoweringObjectFile.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; |
| |
| void emitStartOfAsmFile(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. |
| if (!AsmPrinter::PrintAsmOperand(MI, OpNum, ExtraCode, O)) |
| return false; |
| |
| const MachineOperand &MO = MI->getOperand(OpNum); |
| |
| if (ExtraCode && ExtraCode[0]) { |
| // Unknown extra code. |
| if (ExtraCode[1] != 0 || ExtraCode[0] < 'A' || ExtraCode[0] > 'Z') |
| return true; |
| |
| // Operand must be a register when using 'A' ~ 'Z' extra code. |
| if (!MO.isReg()) |
| return true; |
| |
| Register Reg = MO.getReg(); |
| |
| unsigned ByteNumber = ExtraCode[0] - 'A'; |
| const InlineAsm::Flag OpFlags(MI->getOperand(OpNum - 1).getImm()); |
| const unsigned NumOpRegs = OpFlags.getNumOperandRegisters(); |
| |
| 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; |
| if (RegIdx >= NumOpRegs) |
| return true; |
| 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 (MO.getType() == MachineOperand::MO_GlobalAddress) |
| PrintSymbolOperand(MO, O); // Print global symbols. |
| else |
| printOperand(MI, OpNum, O); // Fallback to ordinary cases. |
| |
| return false; |
| } |
| |
| bool AVRAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI, |
| unsigned OpNum, const char *ExtraCode, |
| raw_ostream &O) { |
| if (ExtraCode && ExtraCode[0]) |
| return true; // Unknown modifier |
| |
| 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 if (MI->getOperand(OpNum).getReg() == AVR::R29R28) { |
| O << "Y"; |
| } else if (MI->getOperand(OpNum).getReg() == AVR::R27R26) { |
| O << "X"; |
| } else { |
| assert(false && "Wrong register class for memory operand."); |
| } |
| |
| // If NumOpRegs == 2, then we assume it is product of a FrameIndex expansion |
| // and the second operand is an Imm. |
| const InlineAsm::Flag OpFlags(MI->getOperand(OpNum - 1).getImm()); |
| const unsigned NumOpRegs = OpFlags.getNumOperandRegisters(); |
| |
| if (NumOpRegs == 2) { |
| assert(MI->getOperand(OpNum).getReg() != AVR::R27R26 && |
| "Base register X can not have offset/displacement."); |
| O << '+' << MI->getOperand(OpNum + 1).getImm(); |
| } |
| |
| return false; |
| } |
| |
| void AVRAsmPrinter::emitInstruction(const MachineInstr *MI) { |
| AVR_MC::verifyInstructionPredicates(MI->getOpcode(), |
| getSubtargetInfo().getFeatureBits()); |
| |
| 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) { |
| const TargetLoweringObjectFile &TLOF = getObjFileLowering(); |
| const AVRTargetMachine &TM = (const AVRTargetMachine &)MMI->getTarget(); |
| const AVRSubtarget *SubTM = (const AVRSubtarget *)TM.getSubtargetImpl(); |
| |
| bool NeedsCopyData = false; |
| bool NeedsClearBSS = false; |
| for (const auto &GO : M.globals()) { |
| if (!GO.hasInitializer() || GO.hasAvailableExternallyLinkage()) |
| // These globals aren't defined in the current object file. |
| continue; |
| |
| if (GO.hasCommonLinkage()) { |
| // COMMON symbols are put in .bss. |
| NeedsClearBSS = true; |
| continue; |
| } |
| |
| auto *Section = cast<MCSectionELF>(TLOF.SectionForGlobal(&GO, TM)); |
| if (Section->getName().starts_with(".data")) |
| NeedsCopyData = true; |
| else if (Section->getName().starts_with(".rodata") && SubTM->hasLPM()) |
| // AVRs that have a separate program memory (that's most AVRs) store |
| // .rodata sections in RAM. |
| NeedsCopyData = true; |
| else if (Section->getName().starts_with(".bss")) |
| NeedsClearBSS = true; |
| } |
| |
| MCSymbol *DoCopyData = OutContext.getOrCreateSymbol("__do_copy_data"); |
| MCSymbol *DoClearBss = OutContext.getOrCreateSymbol("__do_clear_bss"); |
| |
| if (NeedsCopyData) { |
| 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); |
| } |
| |
| if (NeedsClearBSS) { |
| 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); |
| } |
| |
| void AVRAsmPrinter::emitStartOfAsmFile(Module &M) { |
| const AVRTargetMachine &TM = (const AVRTargetMachine &)MMI->getTarget(); |
| const AVRSubtarget *SubTM = (const AVRSubtarget *)TM.getSubtargetImpl(); |
| if (!SubTM) |
| return; |
| |
| // Emit __tmp_reg__. |
| OutStreamer->emitAssignment( |
| MMI->getContext().getOrCreateSymbol(StringRef("__tmp_reg__")), |
| MCConstantExpr::create(SubTM->getRegTmpIndex(), MMI->getContext())); |
| // Emit __zero_reg__. |
| OutStreamer->emitAssignment( |
| MMI->getContext().getOrCreateSymbol(StringRef("__zero_reg__")), |
| MCConstantExpr::create(SubTM->getRegZeroIndex(), MMI->getContext())); |
| // Emit __SREG__. |
| OutStreamer->emitAssignment( |
| MMI->getContext().getOrCreateSymbol(StringRef("__SREG__")), |
| MCConstantExpr::create(SubTM->getIORegSREG(), MMI->getContext())); |
| // Emit __SP_H__ if available. |
| if (!SubTM->hasSmallStack()) |
| OutStreamer->emitAssignment( |
| MMI->getContext().getOrCreateSymbol(StringRef("__SP_H__")), |
| MCConstantExpr::create(SubTM->getIORegSPH(), MMI->getContext())); |
| // Emit __SP_L__. |
| OutStreamer->emitAssignment( |
| MMI->getContext().getOrCreateSymbol(StringRef("__SP_L__")), |
| MCConstantExpr::create(SubTM->getIORegSPL(), MMI->getContext())); |
| // Emit __EIND__ if available. |
| if (SubTM->hasEIJMPCALL()) |
| OutStreamer->emitAssignment( |
| MMI->getContext().getOrCreateSymbol(StringRef("__EIND__")), |
| MCConstantExpr::create(SubTM->getIORegEIND(), MMI->getContext())); |
| // Emit __RAMPZ__ if available. |
| if (SubTM->hasELPM()) |
| OutStreamer->emitAssignment( |
| MMI->getContext().getOrCreateSymbol(StringRef("__RAMPZ__")), |
| MCConstantExpr::create(SubTM->getIORegRAMPZ(), MMI->getContext())); |
| } |
| |
| } // end of namespace llvm |
| |
| extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeAVRAsmPrinter() { |
| llvm::RegisterAsmPrinter<llvm::AVRAsmPrinter> X(llvm::getTheAVRTarget()); |
| } |