llvm/llvm/lib/Target/ARM/MCTargetDesc/ARMWinCOFFStreamer.cpp

//===-- ARMWinCOFFStreamer.cpp - ARM Target WinCOFF Streamer ----*- C++ -*-===//
//
// 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 "ARMMCTargetDesc.h"
#include "llvm/MC/MCAsmBackend.h"
#include "llvm/MC/MCAssembler.h"
#include "llvm/MC/MCCodeEmitter.h"
#include "llvm/MC/MCContext.h"
#include "llvm/MC/MCObjectWriter.h"
#include "llvm/MC/MCWin64EH.h"
#include "llvm/MC/MCWinCOFFStreamer.h"

usingnamespacellvm;

namespace {
class ARMWinCOFFStreamer : public MCWinCOFFStreamer { … };

void ARMWinCOFFStreamer::emitWinEHHandlerData(SMLoc Loc) { … }

void ARMWinCOFFStreamer::emitWindowsUnwindTables(WinEH::FrameInfo *Frame) { … }

void ARMWinCOFFStreamer::emitWindowsUnwindTables() { … }

void ARMWinCOFFStreamer::emitThumbFunc(MCSymbol *Symbol) { … }

void ARMWinCOFFStreamer::finishImpl() { … }
}

MCStreamer *
llvm::createARMWinCOFFStreamer(MCContext &Context,
                               std::unique_ptr<MCAsmBackend> &&MAB,
                               std::unique_ptr<MCObjectWriter> &&OW,
                               std::unique_ptr<MCCodeEmitter> &&Emitter) { … }

namespace {
class ARMTargetWinCOFFStreamer : public llvm::ARMTargetStreamer { … };

// Helper function to common out unwind code setup for those codes that can
// belong to both prolog and epilog.
void ARMTargetWinCOFFStreamer::emitARMWinUnwindCode(unsigned UnwindCode,
                                                    int Reg, int Offset) { … }

void ARMTargetWinCOFFStreamer::emitARMWinCFIAllocStack(unsigned Size,
                                                       bool Wide) { … }

void ARMTargetWinCOFFStreamer::emitARMWinCFISaveRegMask(unsigned Mask,
                                                        bool Wide) { … }

void ARMTargetWinCOFFStreamer::emitARMWinCFISaveSP(unsigned Reg) { … }

void ARMTargetWinCOFFStreamer::emitARMWinCFISaveFRegs(unsigned First,
                                                      unsigned Last) { … }

void ARMTargetWinCOFFStreamer::emitARMWinCFISaveLR(unsigned Offset) { … }

void ARMTargetWinCOFFStreamer::emitARMWinCFINop(bool Wide) { … }

void ARMTargetWinCOFFStreamer::emitARMWinCFIPrologEnd(bool Fragment) { … }

void ARMTargetWinCOFFStreamer::emitARMWinCFIEpilogStart(unsigned Condition) { … }

void ARMTargetWinCOFFStreamer::emitARMWinCFIEpilogEnd() { … }

void ARMTargetWinCOFFStreamer::emitARMWinCFICustom(unsigned Opcode) { … }

} // end anonymous namespace

MCTargetStreamer *llvm::createARMObjectTargetWinCOFFStreamer(MCStreamer &S) { … }