llvm/llvm/lib/Target/AArch64/MCTargetDesc/AArch64WinCOFFStreamer.cpp

//===-- AArch64WinCOFFStreamer.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 "AArch64WinCOFFStreamer.h"
#include "llvm/MC/MCAsmBackend.h"
#include "llvm/MC/MCAssembler.h"
#include "llvm/MC/MCCodeEmitter.h"
#include "llvm/MC/MCObjectWriter.h"
#include "llvm/MC/MCWin64EH.h"
#include "llvm/MC/MCWinCOFFStreamer.h"

usingnamespacellvm;

namespace {

class AArch64WinCOFFStreamer : public MCWinCOFFStreamer { … };

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

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

void AArch64WinCOFFStreamer::emitWindowsUnwindTables() { … }

void AArch64WinCOFFStreamer::finishImpl() { … }
} // end anonymous namespace

// Helper function to common out unwind code setup for those codes that can
// belong to both prolog and epilog.
// There are three types of Windows ARM64 SEH codes.  They can
// 1) take no operands: SEH_Nop, SEH_PrologEnd, SEH_EpilogStart, SEH_EpilogEnd
// 2) take an offset: SEH_StackAlloc, SEH_SaveFPLR, SEH_SaveFPLR_X
// 3) take a register and an offset/size: all others
void AArch64TargetWinCOFFStreamer::emitARM64WinUnwindCode(unsigned UnwindCode,
                                                          int Reg, int Offset) { … }

void AArch64TargetWinCOFFStreamer::emitARM64WinCFIAllocStack(unsigned Size) { … }

void AArch64TargetWinCOFFStreamer::emitARM64WinCFISaveR19R20X(int Offset) { … }

void AArch64TargetWinCOFFStreamer::emitARM64WinCFISaveFPLR(int Offset) { … }

void AArch64TargetWinCOFFStreamer::emitARM64WinCFISaveFPLRX(int Offset) { … }

void AArch64TargetWinCOFFStreamer::emitARM64WinCFISaveReg(unsigned Reg,
                                                          int Offset) { … }

void AArch64TargetWinCOFFStreamer::emitARM64WinCFISaveRegX(unsigned Reg,
                                                           int Offset) { … }

void AArch64TargetWinCOFFStreamer::emitARM64WinCFISaveRegP(unsigned Reg,
                                                           int Offset) { … }

void AArch64TargetWinCOFFStreamer::emitARM64WinCFISaveRegPX(unsigned Reg,
                                                            int Offset) { … }

void AArch64TargetWinCOFFStreamer::emitARM64WinCFISaveLRPair(unsigned Reg,
                                                             int Offset) { … }

void AArch64TargetWinCOFFStreamer::emitARM64WinCFISaveFReg(unsigned Reg,
                                                           int Offset) { … }

void AArch64TargetWinCOFFStreamer::emitARM64WinCFISaveFRegX(unsigned Reg,
                                                            int Offset) { … }

void AArch64TargetWinCOFFStreamer::emitARM64WinCFISaveFRegP(unsigned Reg,
                                                            int Offset) { … }

void AArch64TargetWinCOFFStreamer::emitARM64WinCFISaveFRegPX(unsigned Reg,
                                                             int Offset) { … }

void AArch64TargetWinCOFFStreamer::emitARM64WinCFISetFP() { … }

void AArch64TargetWinCOFFStreamer::emitARM64WinCFIAddFP(unsigned Offset) { … }

void AArch64TargetWinCOFFStreamer::emitARM64WinCFINop() { … }

void AArch64TargetWinCOFFStreamer::emitARM64WinCFISaveNext() { … }

// The functions below handle opcodes that can end up in either a prolog or
// an epilog, but not both.
void AArch64TargetWinCOFFStreamer::emitARM64WinCFIPrologEnd() { … }

void AArch64TargetWinCOFFStreamer::emitARM64WinCFIEpilogStart() { … }

void AArch64TargetWinCOFFStreamer::emitARM64WinCFIEpilogEnd() { … }

void AArch64TargetWinCOFFStreamer::emitARM64WinCFITrapFrame() { … }

void AArch64TargetWinCOFFStreamer::emitARM64WinCFIMachineFrame() { … }

void AArch64TargetWinCOFFStreamer::emitARM64WinCFIContext() { … }

void AArch64TargetWinCOFFStreamer::emitARM64WinCFIECContext() { … }

void AArch64TargetWinCOFFStreamer::emitARM64WinCFIClearUnwoundToCall() { … }

void AArch64TargetWinCOFFStreamer::emitARM64WinCFIPACSignLR() { … }

void AArch64TargetWinCOFFStreamer::emitARM64WinCFISaveAnyRegI(unsigned Reg,
                                                              int Offset) { … }

void AArch64TargetWinCOFFStreamer::emitARM64WinCFISaveAnyRegIP(unsigned Reg,
                                                               int Offset) { … }

void AArch64TargetWinCOFFStreamer::emitARM64WinCFISaveAnyRegD(unsigned Reg,
                                                              int Offset) { … }

void AArch64TargetWinCOFFStreamer::emitARM64WinCFISaveAnyRegDP(unsigned Reg,
                                                               int Offset) { … }

void AArch64TargetWinCOFFStreamer::emitARM64WinCFISaveAnyRegQ(unsigned Reg,
                                                              int Offset) { … }

void AArch64TargetWinCOFFStreamer::emitARM64WinCFISaveAnyRegQP(unsigned Reg,
                                                               int Offset) { … }

void AArch64TargetWinCOFFStreamer::emitARM64WinCFISaveAnyRegIX(unsigned Reg,
                                                               int Offset) { … }

void AArch64TargetWinCOFFStreamer::emitARM64WinCFISaveAnyRegIPX(unsigned Reg,
                                                                int Offset) { … }

void AArch64TargetWinCOFFStreamer::emitARM64WinCFISaveAnyRegDX(unsigned Reg,
                                                               int Offset) { … }

void AArch64TargetWinCOFFStreamer::emitARM64WinCFISaveAnyRegDPX(unsigned Reg,
                                                                int Offset) { … }

void AArch64TargetWinCOFFStreamer::emitARM64WinCFISaveAnyRegQX(unsigned Reg,
                                                               int Offset) { … }

void AArch64TargetWinCOFFStreamer::emitARM64WinCFISaveAnyRegQPX(unsigned Reg,
                                                                int Offset) { … }

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