MipsELFStreamer.cpp

Go to the documentation of this file.

//===-------- MipsELFStreamer.cpp - ELF Object Output ---------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
 
#include "MipsELFStreamer.h"
#include "MipsOptionRecord.h"
#include "MipsTargetStreamer.h"
#include "llvm/BinaryFormat/ELF.h"
#include "llvm/MC/MCAsmBackend.h"
#include "llvm/MC/MCAssembler.h"
#include "llvm/MC/MCCodeEmitter.h"
#include "llvm/MC/MCContext.h"
#include "llvm/MC/MCDwarf.h"
#include "llvm/MC/MCInst.h"
#include "llvm/MC/MCObjectWriter.h"
#include "llvm/MC/MCSymbolELF.h"
 
using namespace llvm;
 
MipsELFStreamer::MipsELFStreamer(MCContext &Context,
                                 std::unique_ptr<MCAsmBackend> MAB,
                                 std::unique_ptr<MCObjectWriter> OW,
                                 std::unique_ptr<MCCodeEmitter> Emitter)
    : MCELFStreamer(Context, std::move(MAB), std::move(OW),
                    std::move(Emitter)) {
  RegInfoRecord = new MipsRegInfoRecord(this, Context);
  MipsOptionRecords.push_back(
      std::unique_ptr<MipsRegInfoRecord>(RegInfoRecord));
}
 
void MipsELFStreamer::emitInstruction(const MCInst &Inst,
                                      const MCSubtargetInfo &STI) {
  MCELFStreamer::emitInstruction(Inst, STI);
 
  MCContext &Context = getContext();
  const MCRegisterInfo *MCRegInfo = Context.getRegisterInfo();
 
  for (unsigned OpIndex = 0; OpIndex < Inst.getNumOperands(); ++OpIndex) {
    const MCOperand &Op = Inst.getOperand(OpIndex);
 
    if (!Op.isReg())
      continue;
 
    MCRegister Reg = Op.getReg();
    RegInfoRecord->SetPhysRegUsed(Reg, MCRegInfo);
  }
 
  createPendingLabelRelocs();
}
 
void MipsELFStreamer::emitCFIStartProcImpl(MCDwarfFrameInfo &Frame) {
  Frame.Begin = getContext().createTempSymbol();
  MCELFStreamer::emitLabel(Frame.Begin);
}
 
MCSymbol *MipsELFStreamer::emitCFILabel() {
  MCSymbol *Label = getContext().createTempSymbol("cfi", true);
  MCELFStreamer::emitLabel(Label);
  return Label;
}
 
void MipsELFStreamer::emitCFIEndProcImpl(MCDwarfFrameInfo &Frame) {
  Frame.End = getContext().createTempSymbol();
  MCELFStreamer::emitLabel(Frame.End);
}
 
void MipsELFStreamer::createPendingLabelRelocs() {
  MipsTargetELFStreamer *ELFTargetStreamer =
      static_cast<MipsTargetELFStreamer *>(getTargetStreamer());
 
  if (ELFTargetStreamer->isMicroMipsEnabled() ||
      ELFTargetStreamer->isMips16Enabled()) {
    for (auto *L : Labels) {
      auto *Label = static_cast<MCSymbolELF *>(L);
      getAssembler().registerSymbol(*Label);
      Label->setOther(ELFTargetStreamer->isMips16Enabled()
                          ? ELF::STO_MIPS_MIPS16
                          : ELF::STO_MIPS_MICROMIPS);
    }
  }
 
  Labels.clear();
}
 
void MipsELFStreamer::emitLabel(MCSymbol *Symbol, SMLoc Loc) {
  MCELFStreamer::emitLabel(Symbol);
  Labels.push_back(Symbol);
}
 
void MipsELFStreamer::switchSection(MCSection *Section, uint32_t Subsection) {
  MCELFStreamer::switchSection(Section, Subsection);
  Labels.clear();
}
 
void MipsELFStreamer::emitValueImpl(const MCExpr *Value, unsigned Size,
                                    SMLoc Loc) {
  MCELFStreamer::emitValueImpl(Value, Size, Loc);
  Labels.clear();
}
 
void MipsELFStreamer::emitIntValue(uint64_t Value, unsigned Size) {
  MCELFStreamer::emitIntValue(Value, Size);
  Labels.clear();
}
 
void MipsELFStreamer::emitBytes(StringRef Data) {
  MCELFStreamer::emitBytes(Data);
  Labels.clear();
}
 
void MipsELFStreamer::emitFill(const MCExpr &NumBytes, uint64_t FillValue,
                               SMLoc Loc) {
  MCELFStreamer::emitFill(NumBytes, FillValue, Loc);
  Labels.clear();
}
 
void MipsELFStreamer::emitFill(const MCExpr &NumValues, int64_t Size,
                               int64_t Expr, SMLoc Loc) {
  MCELFStreamer::emitFill(NumValues, Size, Expr, Loc);
  Labels.clear();
}
 
void MipsELFStreamer::EmitMipsOptionRecords() {
  for (const auto &I : MipsOptionRecords)
    I->EmitMipsOptionRecord();
}
 
MCELFStreamer *
llvm::createMipsELFStreamer(MCContext &Context,
                            std::unique_ptr<MCAsmBackend> MAB,
                            std::unique_ptr<MCObjectWriter> OW,
                            std::unique_ptr<MCCodeEmitter> Emitter) {
  return new MipsELFStreamer(Context, std::move(MAB), std::move(OW),
                             std::move(Emitter));
}