1 //=== HexagonMCELFStreamer.cpp - Hexagon subclass of MCELFStreamer -------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file is a stub that parses a MCInst bundle and passes the 10 // instructions on to the real streamer. 11 // 12 //===----------------------------------------------------------------------===// 13 #define DEBUG_TYPE "hexagonmcelfstreamer" 14 15 #include "MCTargetDesc/HexagonMCELFStreamer.h" 16 #include "MCTargetDesc/HexagonMCInstrInfo.h" 17 #include "MCTargetDesc/HexagonMCShuffler.h" 18 #include "llvm/ADT/StringRef.h" 19 #include "llvm/BinaryFormat/ELF.h" 20 #include "llvm/MC/MCAsmBackend.h" 21 #include "llvm/MC/MCAssembler.h" 22 #include "llvm/MC/MCCodeEmitter.h" 23 #include "llvm/MC/MCContext.h" 24 #include "llvm/MC/MCExpr.h" 25 #include "llvm/MC/MCInst.h" 26 #include "llvm/MC/MCObjectStreamer.h" 27 #include "llvm/MC/MCObjectWriter.h" 28 #include "llvm/MC/MCSection.h" 29 #include "llvm/MC/MCSectionELF.h" 30 #include "llvm/MC/MCStreamer.h" 31 #include "llvm/MC/MCSymbol.h" 32 #include "llvm/MC/MCSymbolELF.h" 33 #include "llvm/Support/Casting.h" 34 #include "llvm/Support/CommandLine.h" 35 #include "llvm/Support/ErrorHandling.h" 36 #include "llvm/Support/MathExtras.h" 37 #include <cassert> 38 #include <cstdint> 39 40 using namespace llvm; 41 42 static cl::opt<unsigned> GPSize 43 ("gpsize", cl::NotHidden, 44 cl::desc("Global Pointer Addressing Size. The default size is 8."), 45 cl::Prefix, 46 cl::init(8)); 47 48 HexagonMCELFStreamer::HexagonMCELFStreamer( 49 MCContext &Context, std::unique_ptr<MCAsmBackend> TAB, 50 std::unique_ptr<MCObjectWriter> OW, std::unique_ptr<MCCodeEmitter> Emitter) 51 : MCELFStreamer(Context, std::move(TAB), std::move(OW), std::move(Emitter)), 52 MCII(createHexagonMCInstrInfo()) {} 53 54 HexagonMCELFStreamer::HexagonMCELFStreamer( 55 MCContext &Context, std::unique_ptr<MCAsmBackend> TAB, 56 std::unique_ptr<MCObjectWriter> OW, std::unique_ptr<MCCodeEmitter> Emitter, 57 MCAssembler *Assembler) 58 : MCELFStreamer(Context, std::move(TAB), std::move(OW), std::move(Emitter)), 59 MCII(createHexagonMCInstrInfo()) {} 60 61 void HexagonMCELFStreamer::EmitInstruction(const MCInst &MCB, 62 const MCSubtargetInfo &STI) { 63 assert(MCB.getOpcode() == Hexagon::BUNDLE); 64 assert(HexagonMCInstrInfo::bundleSize(MCB) <= HEXAGON_PACKET_SIZE); 65 assert(HexagonMCInstrInfo::bundleSize(MCB) > 0); 66 67 // At this point, MCB is a bundle 68 // Iterate through the bundle and assign addends for the instructions 69 for (auto const &I : HexagonMCInstrInfo::bundleInstructions(MCB)) { 70 MCInst *MCI = const_cast<MCInst *>(I.getInst()); 71 EmitSymbol(*MCI); 72 } 73 74 MCObjectStreamer::EmitInstruction(MCB, STI); 75 } 76 77 void HexagonMCELFStreamer::EmitSymbol(const MCInst &Inst) { 78 // Scan for values. 79 for (unsigned i = Inst.getNumOperands(); i--;) 80 if (Inst.getOperand(i).isExpr()) 81 visitUsedExpr(*Inst.getOperand(i).getExpr()); 82 } 83 84 // EmitCommonSymbol and EmitLocalCommonSymbol are extended versions of the 85 // functions found in MCELFStreamer.cpp taking AccessSize as an additional 86 // parameter. 87 void HexagonMCELFStreamer::HexagonMCEmitCommonSymbol(MCSymbol *Symbol, 88 uint64_t Size, 89 unsigned ByteAlignment, 90 unsigned AccessSize) { 91 getAssembler().registerSymbol(*Symbol); 92 StringRef sbss[4] = {".sbss.1", ".sbss.2", ".sbss.4", ".sbss.8"}; 93 94 auto ELFSymbol = cast<MCSymbolELF>(Symbol); 95 if (!ELFSymbol->isBindingSet()) { 96 ELFSymbol->setBinding(ELF::STB_GLOBAL); 97 ELFSymbol->setExternal(true); 98 } 99 100 ELFSymbol->setType(ELF::STT_OBJECT); 101 102 if (ELFSymbol->getBinding() == ELF::STB_LOCAL) { 103 StringRef SectionName = 104 ((AccessSize == 0) || (Size == 0) || (Size > GPSize)) 105 ? ".bss" 106 : sbss[(Log2_64(AccessSize))]; 107 MCSection &Section = *getAssembler().getContext().getELFSection( 108 SectionName, ELF::SHT_NOBITS, ELF::SHF_WRITE | ELF::SHF_ALLOC); 109 MCSectionSubPair P = getCurrentSection(); 110 SwitchSection(&Section); 111 112 if (ELFSymbol->isUndefined()) { 113 EmitValueToAlignment(ByteAlignment, 0, 1, 0); 114 EmitLabel(Symbol); 115 EmitZeros(Size); 116 } 117 118 // Update the maximum alignment of the section if necessary. 119 if (Align(ByteAlignment) > Section.getAlignment()) 120 Section.setAlignment(Align(ByteAlignment)); 121 122 SwitchSection(P.first, P.second); 123 } else { 124 if (ELFSymbol->declareCommon(Size, ByteAlignment)) 125 report_fatal_error("Symbol: " + Symbol->getName() + 126 " redeclared as different type"); 127 if ((AccessSize) && (Size <= GPSize)) { 128 uint64_t SectionIndex = 129 (AccessSize <= GPSize) 130 ? ELF::SHN_HEXAGON_SCOMMON + (Log2_64(AccessSize) + 1) 131 : (unsigned)ELF::SHN_HEXAGON_SCOMMON; 132 ELFSymbol->setIndex(SectionIndex); 133 } 134 } 135 136 ELFSymbol->setSize(MCConstantExpr::create(Size, getContext())); 137 } 138 139 void HexagonMCELFStreamer::HexagonMCEmitLocalCommonSymbol(MCSymbol *Symbol, 140 uint64_t Size, 141 unsigned ByteAlignment, 142 unsigned AccessSize) { 143 getAssembler().registerSymbol(*Symbol); 144 auto ELFSymbol = cast<MCSymbolELF>(Symbol); 145 ELFSymbol->setBinding(ELF::STB_LOCAL); 146 ELFSymbol->setExternal(false); 147 HexagonMCEmitCommonSymbol(Symbol, Size, ByteAlignment, AccessSize); 148 } 149 150 151 namespace llvm { 152 MCStreamer *createHexagonELFStreamer(Triple const &TT, MCContext &Context, 153 std::unique_ptr<MCAsmBackend> MAB, 154 std::unique_ptr<MCObjectWriter> OW, 155 std::unique_ptr<MCCodeEmitter> CE) { 156 return new HexagonMCELFStreamer(Context, std::move(MAB), std::move(OW), 157 std::move(CE)); 158 } 159 160 } // end namespace llvm 161