LLVM  16.0.0git
AArch64MCInstLower.cpp
Go to the documentation of this file.
1 //==-- AArch64MCInstLower.cpp - Convert AArch64 MachineInstr to an MCInst --==//
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 contains code to lower AArch64 MachineInstrs to their corresponding
10 // MCInst records.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "AArch64MCInstLower.h"
15 #include "MCTargetDesc/AArch64MCExpr.h"
16 #include "Utils/AArch64BaseInfo.h"
17 #include "llvm/CodeGen/AsmPrinter.h"
18 #include "llvm/CodeGen/MachineBasicBlock.h"
19 #include "llvm/CodeGen/MachineInstr.h"
20 #include "llvm/CodeGen/MachineModuleInfoImpls.h"
21 #include "llvm/IR/Mangler.h"
22 #include "llvm/MC/MCContext.h"
23 #include "llvm/MC/MCExpr.h"
24 #include "llvm/MC/MCInst.h"
25 #include "llvm/MC/MCStreamer.h"
26 #include "llvm/Support/CodeGen.h"
27 #include "llvm/Support/CommandLine.h"
28 #include "llvm/Target/TargetLoweringObjectFile.h"
29 #include "llvm/Target/TargetMachine.h"
30 using namespace llvm;
31 
32 extern cl::opt<bool> EnableAArch64ELFLocalDynamicTLSGeneration;
33 
34 AArch64MCInstLower::AArch64MCInstLower(MCContext &ctx, AsmPrinter &printer)
35  : Ctx(ctx), Printer(printer) {}
36 
37 MCSymbol *
38 AArch64MCInstLower::GetGlobalAddressSymbol(const MachineOperand &MO) const {
39  const GlobalValue *GV = MO.getGlobal();
40  unsigned TargetFlags = MO.getTargetFlags();
41  const Triple &TheTriple = Printer.TM.getTargetTriple();
42  if (!TheTriple.isOSBinFormatCOFF())
43  return Printer.getSymbolPreferLocal(*GV);
44 
45  assert(TheTriple.isOSWindows() &&
46  "Windows is the only supported COFF target");
47 
48  bool IsIndirect =
49  (TargetFlags & (AArch64II::MO_DLLIMPORT | AArch64II::MO_DLLIMPORTAUX |
50  AArch64II::MO_COFFSTUB));
51  if (!IsIndirect)
52  return Printer.getSymbol(GV);
53 
54  SmallString<128> Name;
55 
56  if (TargetFlags & AArch64II::MO_DLLIMPORTAUX) {
57  // __imp_aux is specific to arm64EC; it represents the actual address of
58  // an imported function without any thunks.
59  //
60  // If we see a reference to an "aux" symbol, also emit a reference to the
61  // corresponding non-aux symbol. Otherwise, the Microsoft linker behaves
62  // strangely when linking against x64 import libararies.
63  //
64  // emitSymbolAttribute() doesn't have any real effect here; it just
65  // ensures the symbol name appears in the assembly without any
66  // side-effects. It might make sense to design a cleaner way to express
67  // this.
68  Name = "__imp_";
69  Printer.TM.getNameWithPrefix(Name, GV,
70  Printer.getObjFileLowering().getMangler());
71  MCSymbol *ExtraSym = Ctx.getOrCreateSymbol(Name);
72  Printer.OutStreamer->emitSymbolAttribute(ExtraSym, MCSA_Global);
73 
74  Name = "__imp_aux_";
75  } else if (TargetFlags & AArch64II::MO_DLLIMPORT) {
76  Name = "__imp_";
77  } else if (TargetFlags & AArch64II::MO_COFFSTUB) {
78  Name = ".refptr.";
79  }
80  Printer.TM.getNameWithPrefix(Name, GV,
81  Printer.getObjFileLowering().getMangler());
82 
83  MCSymbol *MCSym = Ctx.getOrCreateSymbol(Name);
84 
85  if (TargetFlags & AArch64II::MO_COFFSTUB) {
86  MachineModuleInfoCOFF &MMICOFF =
87  Printer.MMI->getObjFileInfo<MachineModuleInfoCOFF>();
88  MachineModuleInfoImpl::StubValueTy &StubSym =
89  MMICOFF.getGVStubEntry(MCSym);
90 
91  if (!StubSym.getPointer())
92  StubSym = MachineModuleInfoImpl::StubValueTy(Printer.getSymbol(GV), true);
93  }
94 
95  return MCSym;
96 }
97 
98 MCSymbol *
99 AArch64MCInstLower::GetExternalSymbolSymbol(const MachineOperand &MO) const {
100  return Printer.GetExternalSymbolSymbol(MO.getSymbolName());
101 }
102 
103 MCOperand AArch64MCInstLower::lowerSymbolOperandDarwin(const MachineOperand &MO,
104  MCSymbol *Sym) const {
105  // FIXME: We would like an efficient form for this, so we don't have to do a
106  // lot of extra uniquing.
107  MCSymbolRefExpr::VariantKind RefKind = MCSymbolRefExpr::VK_None;
108  if ((MO.getTargetFlags() & AArch64II::MO_GOT) != 0) {
109  if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) == AArch64II::MO_PAGE)
110  RefKind = MCSymbolRefExpr::VK_GOTPAGE;
111  else if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) ==
112  AArch64II::MO_PAGEOFF)
113  RefKind = MCSymbolRefExpr::VK_GOTPAGEOFF;
114  else
115  llvm_unreachable("Unexpected target flags with MO_GOT on GV operand");
116  } else if ((MO.getTargetFlags() & AArch64II::MO_TLS) != 0) {
117  if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) == AArch64II::MO_PAGE)
118  RefKind = MCSymbolRefExpr::VK_TLVPPAGE;
119  else if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) ==
120  AArch64II::MO_PAGEOFF)
121  RefKind = MCSymbolRefExpr::VK_TLVPPAGEOFF;
122  else
123  llvm_unreachable("Unexpected target flags with MO_TLS on GV operand");
124  } else {
125  if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) == AArch64II::MO_PAGE)
126  RefKind = MCSymbolRefExpr::VK_PAGE;
127  else if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) ==
128  AArch64II::MO_PAGEOFF)
129  RefKind = MCSymbolRefExpr::VK_PAGEOFF;
130  }
131  const MCExpr *Expr = MCSymbolRefExpr::create(Sym, RefKind, Ctx);
132  if (!MO.isJTI() && MO.getOffset())
133  Expr = MCBinaryExpr::createAdd(
134  Expr, MCConstantExpr::create(MO.getOffset(), Ctx), Ctx);
135  return MCOperand::createExpr(Expr);
136 }
137 
138 MCOperand AArch64MCInstLower::lowerSymbolOperandELF(const MachineOperand &MO,
139  MCSymbol *Sym) const {
140  uint32_t RefFlags = 0;
141 
142  if (MO.getTargetFlags() & AArch64II::MO_GOT)
143  RefFlags |= AArch64MCExpr::VK_GOT;
144  else if (MO.getTargetFlags() & AArch64II::MO_TLS) {
145  TLSModel::Model Model;
146  if (MO.isGlobal()) {
147  const GlobalValue *GV = MO.getGlobal();
148  Model = Printer.TM.getTLSModel(GV);
149  if (!EnableAArch64ELFLocalDynamicTLSGeneration &&
150  Model == TLSModel::LocalDynamic)
151  Model = TLSModel::GeneralDynamic;
152 
153  } else {
154  assert(MO.isSymbol() &&
155  StringRef(MO.getSymbolName()) == "_TLS_MODULE_BASE_" &&
156  "unexpected external TLS symbol");
157  // The general dynamic access sequence is used to get the
158  // address of _TLS_MODULE_BASE_.
159  Model = TLSModel::GeneralDynamic;
160  }
161  switch (Model) {
162  case TLSModel::InitialExec:
163  RefFlags |= AArch64MCExpr::VK_GOTTPREL;
164  break;
165  case TLSModel::LocalExec:
166  RefFlags |= AArch64MCExpr::VK_TPREL;
167  break;
168  case TLSModel::LocalDynamic:
169  RefFlags |= AArch64MCExpr::VK_DTPREL;
170  break;
171  case TLSModel::GeneralDynamic:
172  RefFlags |= AArch64MCExpr::VK_TLSDESC;
173  break;
174  }
175  } else if (MO.getTargetFlags() & AArch64II::MO_PREL) {
176  RefFlags |= AArch64MCExpr::VK_PREL;
177  } else {
178  // No modifier means this is a generic reference, classified as absolute for
179  // the cases where it matters (:abs_g0: etc).
180  RefFlags |= AArch64MCExpr::VK_ABS;
181  }
182 
183  if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) == AArch64II::MO_PAGE)
184  RefFlags |= AArch64MCExpr::VK_PAGE;
185  else if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) ==
186  AArch64II::MO_PAGEOFF)
187  RefFlags |= AArch64MCExpr::VK_PAGEOFF;
188  else if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) == AArch64II::MO_G3)
189  RefFlags |= AArch64MCExpr::VK_G3;
190  else if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) == AArch64II::MO_G2)
191  RefFlags |= AArch64MCExpr::VK_G2;
192  else if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) == AArch64II::MO_G1)
193  RefFlags |= AArch64MCExpr::VK_G1;
194  else if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) == AArch64II::MO_G0)
195  RefFlags |= AArch64MCExpr::VK_G0;
196  else if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) == AArch64II::MO_HI12)
197  RefFlags |= AArch64MCExpr::VK_HI12;
198 
199  if (MO.getTargetFlags() & AArch64II::MO_NC)
200  RefFlags |= AArch64MCExpr::VK_NC;
201 
202  const MCExpr *Expr =
203  MCSymbolRefExpr::create(Sym, MCSymbolRefExpr::VK_None, Ctx);
204  if (!MO.isJTI() && MO.getOffset())
205  Expr = MCBinaryExpr::createAdd(
206  Expr, MCConstantExpr::create(MO.getOffset(), Ctx), Ctx);
207 
208  AArch64MCExpr::VariantKind RefKind;
209  RefKind = static_cast<AArch64MCExpr::VariantKind>(RefFlags);
210  Expr = AArch64MCExpr::create(Expr, RefKind, Ctx);
211 
212  return MCOperand::createExpr(Expr);
213 }
214 
215 MCOperand AArch64MCInstLower::lowerSymbolOperandCOFF(const MachineOperand &MO,
216  MCSymbol *Sym) const {
217  uint32_t RefFlags = 0;
218 
219  if (MO.getTargetFlags() & AArch64II::MO_TLS) {
220  if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) == AArch64II::MO_PAGEOFF)
221  RefFlags |= AArch64MCExpr::VK_SECREL_LO12;
222  else if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) ==
223  AArch64II::MO_HI12)
224  RefFlags |= AArch64MCExpr::VK_SECREL_HI12;
225 
226  } else if (MO.getTargetFlags() & AArch64II::MO_S) {
227  RefFlags |= AArch64MCExpr::VK_SABS;
228  } else {
229  RefFlags |= AArch64MCExpr::VK_ABS;
230 
231  if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) == AArch64II::MO_PAGE)
232  RefFlags |= AArch64MCExpr::VK_PAGE;
233  else if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) ==
234  AArch64II::MO_PAGEOFF)
235  RefFlags |= AArch64MCExpr::VK_PAGEOFF | AArch64MCExpr::VK_NC;
236  }
237 
238  if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) == AArch64II::MO_G3)
239  RefFlags |= AArch64MCExpr::VK_G3;
240  else if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) == AArch64II::MO_G2)
241  RefFlags |= AArch64MCExpr::VK_G2;
242  else if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) == AArch64II::MO_G1)
243  RefFlags |= AArch64MCExpr::VK_G1;
244  else if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) == AArch64II::MO_G0)
245  RefFlags |= AArch64MCExpr::VK_G0;
246 
247  // FIXME: Currently we only set VK_NC for MO_G3/MO_G2/MO_G1/MO_G0. This is
248  // because setting VK_NC for others would mean setting their respective
249  // RefFlags correctly. We should do this in a separate patch.
250  if (MO.getTargetFlags() & AArch64II::MO_NC) {
251  auto MOFrag = (MO.getTargetFlags() & AArch64II::MO_FRAGMENT);
252  if (MOFrag == AArch64II::MO_G3 || MOFrag == AArch64II::MO_G2 ||
253  MOFrag == AArch64II::MO_G1 || MOFrag == AArch64II::MO_G0)
254  RefFlags |= AArch64MCExpr::VK_NC;
255  }
256 
257  const MCExpr *Expr =
258  MCSymbolRefExpr::create(Sym, MCSymbolRefExpr::VK_None, Ctx);
259  if (!MO.isJTI() && MO.getOffset())
260  Expr = MCBinaryExpr::createAdd(
261  Expr, MCConstantExpr::create(MO.getOffset(), Ctx), Ctx);
262 
263  auto RefKind = static_cast<AArch64MCExpr::VariantKind>(RefFlags);
264  assert(RefKind != AArch64MCExpr::VK_INVALID &&
265  "Invalid relocation requested");
266  Expr = AArch64MCExpr::create(Expr, RefKind, Ctx);
267 
268  return MCOperand::createExpr(Expr);
269 }
270 
271 MCOperand AArch64MCInstLower::LowerSymbolOperand(const MachineOperand &MO,
272  MCSymbol *Sym) const {
273  if (Printer.TM.getTargetTriple().isOSDarwin())
274  return lowerSymbolOperandDarwin(MO, Sym);
275  if (Printer.TM.getTargetTriple().isOSBinFormatCOFF())
276  return lowerSymbolOperandCOFF(MO, Sym);
277 
278  assert(Printer.TM.getTargetTriple().isOSBinFormatELF() && "Invalid target");
279  return lowerSymbolOperandELF(MO, Sym);
280 }
281 
282 bool AArch64MCInstLower::lowerOperand(const MachineOperand &MO,
283  MCOperand &MCOp) const {
284  switch (MO.getType()) {
285  default:
286  llvm_unreachable("unknown operand type");
287  case MachineOperand::MO_Register:
288  // Ignore all implicit register operands.
289  if (MO.isImplicit())
290  return false;
291  MCOp = MCOperand::createReg(MO.getReg());
292  break;
293  case MachineOperand::MO_RegisterMask:
294  // Regmasks are like implicit defs.
295  return false;
296  case MachineOperand::MO_Immediate:
297  MCOp = MCOperand::createImm(MO.getImm());
298  break;
299  case MachineOperand::MO_MachineBasicBlock:
300  MCOp = MCOperand::createExpr(
301  MCSymbolRefExpr::create(MO.getMBB()->getSymbol(), Ctx));
302  break;
303  case MachineOperand::MO_GlobalAddress:
304  MCOp = LowerSymbolOperand(MO, GetGlobalAddressSymbol(MO));
305  break;
306  case MachineOperand::MO_ExternalSymbol:
307  MCOp = LowerSymbolOperand(MO, GetExternalSymbolSymbol(MO));
308  break;
309  case MachineOperand::MO_MCSymbol:
310  MCOp = LowerSymbolOperand(MO, MO.getMCSymbol());
311  break;
312  case MachineOperand::MO_JumpTableIndex:
313  MCOp = LowerSymbolOperand(MO, Printer.GetJTISymbol(MO.getIndex()));
314  break;
315  case MachineOperand::MO_ConstantPoolIndex:
316  MCOp = LowerSymbolOperand(MO, Printer.GetCPISymbol(MO.getIndex()));
317  break;
318  case MachineOperand::MO_BlockAddress:
319  MCOp = LowerSymbolOperand(
320  MO, Printer.GetBlockAddressSymbol(MO.getBlockAddress()));
321  break;
322  }
323  return true;
324 }
325 
326 void AArch64MCInstLower::Lower(const MachineInstr *MI, MCInst &OutMI) const {
327  OutMI.setOpcode(MI->getOpcode());
328 
329  for (const MachineOperand &MO : MI->operands()) {
330  MCOperand MCOp;
331  if (lowerOperand(MO, MCOp))
332  OutMI.addOperand(MCOp);
333  }
334 
335  switch (OutMI.getOpcode()) {
336  case AArch64::CATCHRET:
337  OutMI = MCInst();
338  OutMI.setOpcode(AArch64::RET);
339  OutMI.addOperand(MCOperand::createReg(AArch64::LR));
340  break;
341  case AArch64::CLEANUPRET:
342  OutMI = MCInst();
343  OutMI.setOpcode(AArch64::RET);
344  OutMI.addOperand(MCOperand::createReg(AArch64::LR));
345  break;
346  }
347 }
AsmPrinter.h
llvm::AArch64II::MO_G3
@ MO_G3
MO_G3 - A symbol operand with this flag (granule 3) represents the high 16-bits of a 64-bit address,...
Definition: AArch64BaseInfo.h:743
llvm::AArch64MCExpr::create
static const AArch64MCExpr * create(const MCExpr *Expr, VariantKind Kind, MCContext &Ctx)
Definition: AArch64MCExpr.cpp:27
llvm::MachineOperand::MO_BlockAddress
@ MO_BlockAddress
Address of a basic block.
Definition: MachineOperand.h:62
MachineModuleInfoImpls.h
llvm::AArch64MCInstLower::lowerOperand
bool lowerOperand(const MachineOperand &MO, MCOperand &MCOp) const
Definition: AArch64MCInstLower.cpp:282
MI
IRTranslator LLVM IR MI
Definition: IRTranslator.cpp:108
MachineInstr.h
llvm::MachineOperand::MO_Immediate
@ MO_Immediate
Immediate operand.
Definition: MachineOperand.h:52
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
llvm::MCSymbol
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
llvm::MCSymbolRefExpr::VK_PAGEOFF
@ VK_PAGEOFF
Definition: MCExpr.h:220
llvm::AArch64MCExpr::VK_ABS
@ VK_ABS
Definition: AArch64MCExpr.h:28
llvm::AArch64II::MO_HI12
@ MO_HI12
MO_HI12 - This flag indicates that a symbol operand represents the bits 13-24 of a 64-bit address,...
Definition: AArch64BaseInfo.h:760
llvm::MCOperand::createExpr
static MCOperand createExpr(const MCExpr *Val)
Definition: MCInst.h:162
llvm::AArch64MCInstLower::GetExternalSymbolSymbol
MCSymbol * GetExternalSymbolSymbol(const MachineOperand &MO) const
Definition: AArch64MCInstLower.cpp:99
llvm::AArch64II::MO_G1
@ MO_G1
MO_G1 - A symbol operand with this flag (granule 1) represents the bits 16-31 of a 64-bit address,...
Definition: AArch64BaseInfo.h:751
llvm::Triple::isOSBinFormatCOFF
bool isOSBinFormatCOFF() const
Tests whether the OS uses the COFF binary format.
Definition: Triple.h:678
llvm::MachineOperand::getGlobal
const GlobalValue * getGlobal() const
Definition: MachineOperand.h:572
llvm::MCOperand::createImm
static MCOperand createImm(int64_t Val)
Definition: MCInst.h:141
llvm::MCContext
Context object for machine code objects.
Definition: MCContext.h:76
llvm::MCConstantExpr::create
static const MCConstantExpr * create(int64_t Value, MCContext &Ctx, bool PrintInHex=false, unsigned SizeInBytes=0)
Definition: MCExpr.cpp:194
llvm::TLSModel::GeneralDynamic
@ GeneralDynamic
Definition: CodeGen.h:43
llvm::AArch64MCInstLower::lowerSymbolOperandDarwin
MCOperand lowerSymbolOperandDarwin(const MachineOperand &MO, MCSymbol *Sym) const
Definition: AArch64MCInstLower.cpp:103
llvm::MachineOperand::getBlockAddress
const BlockAddress * getBlockAddress() const
Definition: MachineOperand.h:577
AArch64MCExpr.h
llvm::AArch64MCExpr::VK_NC
@ VK_NC
Definition: AArch64MCExpr.h:57
AArch64BaseInfo.h
llvm::AArch64MCExpr::VK_HI12
@ VK_HI12
Definition: AArch64MCExpr.h:44
llvm::Triple
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
MachineBasicBlock.h
llvm::AArch64II::MO_PREL
@ MO_PREL
MO_PREL - Indicates that the bits of the symbol operand represented by MO_G0 etc are PC relative.
Definition: AArch64BaseInfo.h:794
llvm::MachineOperand::isSymbol
bool isSymbol() const
isSymbol - Tests if this is a MO_ExternalSymbol operand.
Definition: MachineOperand.h:340
llvm::MachineOperand::isJTI
bool isJTI() const
isJTI - Tests if this is a MO_JumpTableIndex operand.
Definition: MachineOperand.h:336
llvm::MCInst
Instances of this class represent a single low-level machine instruction.
Definition: MCInst.h:184
llvm::AArch64MCExpr::VK_TPREL
@ VK_TPREL
Definition: AArch64MCExpr.h:34
llvm::AArch64MCInstLower::AArch64MCInstLower
AArch64MCInstLower(MCContext &ctx, AsmPrinter &printer)
Definition: AArch64MCInstLower.cpp:34
llvm::MachineOperand::getOffset
int64_t getOffset() const
Return the offset from the symbol in this operand.
Definition: MachineOperand.h:609
llvm::AArch64MCExpr::VK_DTPREL
@ VK_DTPREL
Definition: AArch64MCExpr.h:32
llvm::MachineOperand::getMCSymbol
MCSymbol * getMCSymbol() const
Definition: MachineOperand.h:582
llvm::MachineOperand::MO_Register
@ MO_Register
Register operand.
Definition: MachineOperand.h:51
llvm::AArch64II::MO_TLS
@ MO_TLS
MO_TLS - Indicates that the operand being accessed is some kind of thread-local symbol.
Definition: AArch64BaseInfo.h:781
llvm::MCInst::setOpcode
void setOpcode(unsigned Op)
Definition: MCInst.h:197
llvm::Reloc::Model
Model
Definition: CodeGen.h:22
llvm::MachineBasicBlock::getSymbol
MCSymbol * getSymbol() const
Return the MCSymbol for this basic block.
Definition: MachineBasicBlock.cpp:58
CommandLine.h
llvm::MCContext::getOrCreateSymbol
MCSymbol * getOrCreateSymbol(const Twine &Name)
Lookup the symbol inside with the specified Name.
Definition: MCContext.cpp:201
llvm::AArch64II::MO_G0
@ MO_G0
MO_G0 - A symbol operand with this flag (granule 0) represents the bits 0-15 of a 64-bit address,...
Definition: AArch64BaseInfo.h:755
llvm::MachineOperand::isImplicit
bool isImplicit() const
Definition: MachineOperand.h:379
llvm::Triple::isOSBinFormatELF
bool isOSBinFormatELF() const
Tests whether the OS uses the ELF binary format.
Definition: Triple.h:673
TargetMachine.h
llvm::MachineOperand::MO_GlobalAddress
@ MO_GlobalAddress
Address of a global value.
Definition: MachineOperand.h:61
llvm::Triple::isOSDarwin
bool isOSDarwin() const
Is this a "Darwin" OS (macOS, iOS, tvOS, watchOS, or DriverKit).
Definition: Triple.h:517
llvm::MachineOperand::getImm
int64_t getImm() const
Definition: MachineOperand.h:546
llvm::ISD::CATCHRET
@ CATCHRET
CATCHRET - Represents a return from a catch block funclet.
Definition: ISDOpcodes.h:1044
llvm::MCSymbolRefExpr::VK_GOTPAGEOFF
@ VK_GOTPAGEOFF
Definition: MCExpr.h:222
llvm::AsmPrinter::OutStreamer
std::unique_ptr< MCStreamer > OutStreamer
This is the MCStreamer object for the file we are generating.
Definition: AsmPrinter.h:99
MCContext.h
MCInst.h
llvm::MachineOperand
MachineOperand class - Representation of each machine instruction operand.
Definition: MachineOperand.h:48
llvm::AArch64MCExpr::VK_G1
@ VK_G1
Definition: AArch64MCExpr.h:46
llvm::AArch64II::MO_DLLIMPORTAUX
@ MO_DLLIMPORTAUX
MO_DLLIMPORTAUX - Symbol refers to "auxilliary" import stub.
Definition: AArch64BaseInfo.h:809
llvm::AArch64MCInstLower::GetGlobalAddressSymbol
MCSymbol * GetGlobalAddressSymbol(const MachineOperand &MO) const
Definition: AArch64MCInstLower.cpp:38
llvm::AArch64MCExpr::VK_PAGEOFF
@ VK_PAGEOFF
Definition: AArch64MCExpr.h:43
llvm::MCInst::addOperand
void addOperand(const MCOperand Op)
Definition: MCInst.h:210
llvm::SmallString< 128 >
llvm::MachineModuleInfoCOFF
MachineModuleInfoCOFF - This is a MachineModuleInfoImpl implementation for COFF targets.
Definition: MachineModuleInfoImpls.h:85
llvm::AArch64II::MO_S
@ MO_S
MO_S - Indicates that the bits of the symbol operand represented by MO_G0 etc are signed.
Definition: AArch64BaseInfo.h:790
llvm::AArch64MCInstLower::lowerSymbolOperandCOFF
MCOperand lowerSymbolOperandCOFF(const MachineOperand &MO, MCSymbol *Sym) const
Definition: AArch64MCInstLower.cpp:215
llvm::cl::opt< bool >
llvm::GlobalValue
Definition: GlobalValue.h:44
llvm::MCSymbolRefExpr::VariantKind
VariantKind
Definition: MCExpr.h:194
llvm::MachineOperand::getTargetFlags
unsigned getTargetFlags() const
Definition: MachineOperand.h:220
llvm::AsmPrinter::GetCPISymbol
virtual MCSymbol * GetCPISymbol(unsigned CPID) const
Return the symbol for the specified constant pool entry.
Definition: AsmPrinter.cpp:3549
llvm::MachineInstr
Representation of each machine instruction.
Definition: MachineInstr.h:66
llvm::AArch64II::MO_DLLIMPORT
@ MO_DLLIMPORT
MO_DLLIMPORT - On a symbol operand, this represents that the reference to the symbol is for an import...
Definition: AArch64BaseInfo.h:786
llvm::TLSModel::LocalDynamic
@ LocalDynamic
Definition: CodeGen.h:44
llvm::AArch64MCExpr::VK_PAGE
@ VK_PAGE
Definition: AArch64MCExpr.h:42
llvm::AsmPrinter::GetBlockAddressSymbol
MCSymbol * GetBlockAddressSymbol(const BlockAddress *BA) const
Return the MCSymbol used to satisfy BlockAddress uses of the specified basic block.
Definition: AsmPrinter.cpp:3539
llvm::AArch64II::MO_NC
@ MO_NC
MO_NC - Indicates whether the linker is expected to check the symbol reference for overflow.
Definition: AArch64BaseInfo.h:775
llvm::AArch64II::MO_PAGEOFF
@ MO_PAGEOFF
MO_PAGEOFF - A symbol operand with this flag represents the offset of that symbol within a 4K page.
Definition: AArch64BaseInfo.h:739
llvm::AsmPrinter::getSymbolPreferLocal
MCSymbol * getSymbolPreferLocal(const GlobalValue &GV) const
Similar to getSymbol() but preferred for references.
Definition: AsmPrinter.cpp:660
llvm::ISD::CLEANUPRET
@ CLEANUPRET
CLEANUPRET - Represents a return from a cleanup block funclet.
Definition: ISDOpcodes.h:1048
llvm::AArch64MCExpr::VK_SECREL_LO12
@ VK_SECREL_LO12
Definition: AArch64MCExpr.h:109
llvm::MachineOperand::MO_MCSymbol
@ MO_MCSymbol
MCSymbol reference (for debug/eh info)
Definition: MachineOperand.h:66
llvm::MachineOperand::getType
MachineOperandType getType() const
getType - Returns the MachineOperandType for this operand.
Definition: MachineOperand.h:218
EnableAArch64ELFLocalDynamicTLSGeneration
cl::opt< bool > EnableAArch64ELFLocalDynamicTLSGeneration
llvm::TargetMachine::getTLSModel
TLSModel::Model getTLSModel(const GlobalValue *GV) const
Returns the TLS model which should be used for the given global variable.
Definition: TargetMachine.cpp:154
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::AsmPrinter::getSymbol
MCSymbol * getSymbol(const GlobalValue *GV) const
Definition: AsmPrinter.cpp:656
printer
dxil pretty printer
Definition: DXILPrettyPrinter.cpp:53
llvm::MachineOperand::getReg
Register getReg() const
getReg - Returns the register number.
Definition: MachineOperand.h:359
Mangler.h
llvm::MachineOperand::MO_JumpTableIndex
@ MO_JumpTableIndex
Address of indexed Jump Table for switch.
Definition: MachineOperand.h:59
llvm::AArch64II::MO_FRAGMENT
@ MO_FRAGMENT
Definition: AArch64BaseInfo.h:729
llvm::MCBinaryExpr::createAdd
static const MCBinaryExpr * createAdd(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
Definition: MCExpr.h:525
llvm::AsmPrinter::GetExternalSymbolSymbol
MCSymbol * GetExternalSymbolSymbol(StringRef Sym) const
Return the MCSymbol for the specified ExternalSymbol.
Definition: AsmPrinter.cpp:3596
llvm::TargetLoweringObjectFile::getMangler
Mangler & getMangler() const
Definition: TargetLoweringObjectFile.h:77
llvm::MachineOperand::getMBB
MachineBasicBlock * getMBB() const
Definition: MachineOperand.h:561
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
Printer
Memory true print Memory SSA Printer
Definition: MemorySSA.cpp:80
llvm::AsmPrinter::GetJTISymbol
MCSymbol * GetJTISymbol(unsigned JTID, bool isLinkerPrivate=false) const
Return the symbol for the specified jump table entry.
Definition: AsmPrinter.cpp:3577
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:143
llvm::MCOperand::createReg
static MCOperand createReg(unsigned Reg)
Definition: MCInst.h:134
TargetLoweringObjectFile.h
uint32_t
llvm::MachineModuleInfoCOFF::getGVStubEntry
StubValueTy & getGVStubEntry(MCSymbol *Sym)
Definition: MachineModuleInfoImpls.h:95
llvm::MachineOperand::MO_MachineBasicBlock
@ MO_MachineBasicBlock
MachineBasicBlock reference.
Definition: MachineOperand.h:55
llvm::AArch64MCExpr::VK_INVALID
@ VK_INVALID
Definition: AArch64MCExpr.h:112
llvm::AsmPrinter::MMI
MachineModuleInfo * MMI
This is a pointer to the current MachineModuleInfo.
Definition: AsmPrinter.h:105
llvm::Triple::isOSWindows
bool isOSWindows() const
Tests whether the OS is Windows.
Definition: Triple.h:582
llvm::TargetMachine::getNameWithPrefix
void getNameWithPrefix(SmallVectorImpl< char > &Name, const GlobalValue *GV, Mangler &Mang, bool MayAlwaysUsePrivate=false) const
Definition: TargetMachine.cpp:191
llvm::MCSymbolRefExpr::VK_TLVPPAGE
@ VK_TLVPPAGE
Definition: MCExpr.h:217
llvm::ARCISD::RET
@ RET
Definition: ARCISelLowering.h:52
llvm::MachineOperand::MO_ExternalSymbol
@ MO_ExternalSymbol
Name of external global symbol.
Definition: MachineOperand.h:60
llvm::MachineOperand::getIndex
int getIndex() const
Definition: MachineOperand.h:566
llvm::AArch64MCExpr::VK_G3
@ VK_G3
Definition: AArch64MCExpr.h:48
llvm::MCInst::getOpcode
unsigned getOpcode() const
Definition: MCInst.h:198
llvm::AsmPrinter
This class is intended to be used as a driving class for all asm writers.
Definition: AsmPrinter.h:84
llvm::TLSModel::Model
Model
Definition: CodeGen.h:42
llvm::MCSymbolRefExpr::create
static const MCSymbolRefExpr * create(const MCSymbol *Symbol, MCContext &Ctx)
Definition: MCExpr.h:386
llvm::AArch64MCInstLower::LowerSymbolOperand
MCOperand LowerSymbolOperand(const MachineOperand &MO, MCSymbol *Sym) const
Definition: AArch64MCInstLower.cpp:271
llvm::MCSA_Global
@ MCSA_Global
.type _foo, @gnu_unique_object
Definition: MCDirectives.h:30
CodeGen.h
llvm::TLSModel::InitialExec
@ InitialExec
Definition: CodeGen.h:45
llvm::AArch64MCInstLower::lowerSymbolOperandELF
MCOperand lowerSymbolOperandELF(const MachineOperand &MO, MCSymbol *Sym) const
Definition: AArch64MCInstLower.cpp:138
llvm::PointerIntPair
PointerIntPair - This class implements a pair of a pointer and small integer.
Definition: PointerIntPair.h:46
llvm::AsmPrinter::TM
TargetMachine & TM
Target machine description.
Definition: AsmPrinter.h:87
llvm::AArch64MCExpr::VariantKind
VariantKind
Definition: AArch64MCExpr.h:24
llvm::MachineOperand::getSymbolName
const char * getSymbolName() const
Definition: MachineOperand.h:617
llvm::AsmPrinter::getObjFileLowering
const TargetLoweringObjectFile & getObjFileLowering() const
Return information about object file lowering.
Definition: AsmPrinter.cpp:384
MCStreamer.h
llvm::AArch64MCExpr::VK_TLSDESC
@ VK_TLSDESC
Definition: AArch64MCExpr.h:35
llvm::TargetMachine::getTargetTriple
const Triple & getTargetTriple() const
Definition: TargetMachine.h:125
llvm::MCOperand
Instances of this class represent operands of the MCInst class.
Definition: MCInst.h:36
llvm::AArch64II::MO_G2
@ MO_G2
MO_G2 - A symbol operand with this flag (granule 2) represents the bits 32-47 of a 64-bit address,...
Definition: AArch64BaseInfo.h:747
llvm::AArch64II::MO_COFFSTUB
@ MO_COFFSTUB
MO_COFFSTUB - On a symbol operand "FOO", this indicates that the reference is actually to the "....
Definition: AArch64BaseInfo.h:765
llvm::MCSymbolRefExpr::VK_None
@ VK_None
Definition: MCExpr.h:195
llvm::MCSymbolRefExpr::VK_GOTPAGE
@ VK_GOTPAGE
Definition: MCExpr.h:221
llvm::MachineOperand::MO_RegisterMask
@ MO_RegisterMask
Mask of preserved registers.
Definition: MachineOperand.h:63
llvm::AArch64MCExpr::VK_GOTTPREL
@ VK_GOTTPREL
Definition: AArch64MCExpr.h:33
llvm::MCSymbolRefExpr::VK_PAGE
@ VK_PAGE
Definition: MCExpr.h:219
MCExpr.h
llvm::AArch64MCExpr::VK_G2
@ VK_G2
Definition: AArch64MCExpr.h:47
llvm::AArch64II::MO_GOT
@ MO_GOT
MO_GOT - This flag indicates that a symbol operand represents the address of the GOT entry for the sy...
Definition: AArch64BaseInfo.h:770
llvm::MCSymbolRefExpr::VK_TLVPPAGEOFF
@ VK_TLVPPAGEOFF
Definition: MCExpr.h:218
llvm::AArch64MCExpr::VK_SECREL_HI12
@ VK_SECREL_HI12
Definition: AArch64MCExpr.h:110
llvm::MCExpr
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:35
llvm::AArch64MCExpr::VK_G0
@ VK_G0
Definition: AArch64MCExpr.h:45
llvm::AArch64MCExpr::VK_SABS
@ VK_SABS
Definition: AArch64MCExpr.h:29
llvm::MachineModuleInfo::getObjFileInfo
Ty & getObjFileInfo()
Keep track of various per-module pieces of information for backends that would like to do so.
Definition: MachineModuleInfo.h:170
llvm::AArch64MCExpr::VK_PREL
@ VK_PREL
Definition: AArch64MCExpr.h:30
llvm::AArch64MCInstLower::Lower
void Lower(const MachineInstr *MI, MCInst &OutMI) const
Definition: AArch64MCInstLower.cpp:326
llvm::AArch64II::MO_PAGE
@ MO_PAGE
MO_PAGE - A symbol operand with this flag represents the pc-relative offset of the 4K page containing...
Definition: AArch64BaseInfo.h:734
llvm::MachineOperand::isGlobal
bool isGlobal() const
isGlobal - Tests if this is a MO_GlobalAddress operand.
Definition: MachineOperand.h:338
llvm::TLSModel::LocalExec
@ LocalExec
Definition: CodeGen.h:46
llvm::MachineOperand::MO_ConstantPoolIndex
@ MO_ConstantPoolIndex
Address of indexed Constant in Constant Pool.
Definition: MachineOperand.h:57
AArch64MCInstLower.h
llvm::AArch64MCExpr::VK_GOT
@ VK_GOT
Definition: AArch64MCExpr.h:31
Generated on Fri Dec 2 2022 19:47:16 for LLVM by   doxygen 1.8.17