TargetRegistry.h Source File (original) (raw)

18#ifndef LLVM_MC_TARGETREGISTRY_H

19#define LLVM_MC_TARGETREGISTRY_H

30#include

31#include

32#include

33#include

34#include

35#include

37namespace llvm {

39class AsmPrinter;

40class MCAsmBackend;

41class MCAsmInfo;

42class MCAsmParser;

43class MCCodeEmitter;

44class MCContext;

45class MCDisassembler;

46class MCInstPrinter;

47class MCInstrAnalysis;

48class MCInstrInfo;

49class MCObjectWriter;

50class MCRegisterInfo;

51class MCRelocationInfo;

52class MCStreamer;

53class MCSubtargetInfo;

54class MCSymbolizer;

55class MCTargetAsmParser;

56class MCTargetOptions;

57class MCTargetStreamer;

58class raw_ostream;

59class TargetMachine;

60class TargetOptions;

61namespace mca {

66}

89 MCInstPrinter *InstPrint, std::unique_ptr &&CE,

90 std::unique_ptr &&TAB);

93 std::unique_ptr &&TAB,

94 std::unique_ptr &&OW,

95 std::unique_ptr &&CE);

97 std::unique_ptr &&TAB,

98 std::unique_ptr &&OW,

99 std::unique_ptr &&CE);

101 std::unique_ptr &&TAB,

102 std::unique_ptr &&OW,

103 std::unique_ptr &&CE,

104 bool DWARFMustBeAtTheEnd,

105 bool LabelSections = false);

107 std::unique_ptr &&TAB,

108 std::unique_ptr &&OW,

109 std::unique_ptr &&CE);

111 std::unique_ptr &&TAB,

112 std::unique_ptr &&OW,

113 std::unique_ptr &&CE);

115 std::unique_ptr &&TAB,

116 std::unique_ptr &&OW,

117 std::unique_ptr &&CE);

118

120

124 std::unique_ptr &&RelInfo);

125

129

132

135

136

137

138

139

140

141

142

143

145public:

147

149

154 bool PIC,

155 bool LargeCodeModel);

165 std::optionalCodeModel::Model CM, CodeGenOptLevel OL, bool JIT);

166

167

168

170 TargetMachine &TM, std::unique_ptr &&Streamer);

182 unsigned SyntaxVariant,

190 std::unique_ptr &&TAB,

191 std::unique_ptr &&OW,

192 std::unique_ptr &&Emitter);

195 std::unique_ptr &&OW,

196 std::unique_ptr &&Emitter);

199 std::unique_ptr &&OW,

200 std::unique_ptr &&Emitter);

203 std::unique_ptr &&TAB,

204 std::unique_ptr &&OW,

205 std::unique_ptr &&Emitter);

206

218 std::unique_ptr &&RelInfo);

219

224

228

232

233private:

234

235

237

238

240

241

242 const char *Name;

243

244

245 const char *ShortDesc;

246

247

248

249 const char *BackendName;

250

251

252 bool HasJIT;

253

254

255

257

258

260

261

262

264

265

266

268

269

270

272

273

274

276

277

278

280

281

282

284

285

286

288

289

290

292

293

294

296

297

298

300

301

302

304

305

310

311

312

314

315

316

318

319

320

322

323

324

326

327

328

330

331

332

334

335

336

338

339

340

342

343public:

345

346

347

348

349

351

352

354

355

357

358

360

361

362

363

364

365

366 bool hasJIT() const { return HasJIT; }

367

368

370

371

372 bool hasMCAsmBackend() const { return MCAsmBackendCtorFn != nullptr; }

373

374

375 bool hasMCAsmParser() const { return MCAsmParserCtorFn != nullptr; }

376

377

378

379

380

381

382

383

384

385

386

387

390 if (!MCAsmInfoCtorFn)

391 return nullptr;

393 }

394

395

396

397

399 bool LargeCodeModel = false) const {

400 if (!MCObjectFileInfoCtorFn) {

403 return MOFI;

404 }

405 return MCObjectFileInfoCtorFn(Ctx, PIC, LargeCodeModel);

406 }

407

408

409

411 if (!MCInstrInfoCtorFn)

412 return nullptr;

413 return MCInstrInfoCtorFn();

414 }

415

416

417

419 if (!MCInstrAnalysisCtorFn)

420 return nullptr;

421 return MCInstrAnalysisCtorFn(Info);

422 }

423

424

425

427 if (!MCRegInfoCtorFn)

428 return nullptr;

429 return MCRegInfoCtorFn(Triple(TT));

430 }

431

432

433

434

435

436

437

438

439

440

443 if (!MCSubtargetInfoCtorFn)

444 return nullptr;

445 return MCSubtargetInfoCtorFn(Triple(TheTriple), CPU, Features);

446 }

447

448

449

450

451

452

453

454

458 std::optionalCodeModel::Model CM = std::nullopt,

460 if (!TargetMachineCtorFn)

461 return nullptr;

462 return TargetMachineCtorFn(*this, Triple(TT), CPU, Features, Options, RM,

463 CM, OL, JIT);

464 }

465

466

470 if (!MCAsmBackendCtorFn)

471 return nullptr;

472 return MCAsmBackendCtorFn(*this, STI, MRI, Options);

473 }

474

475

476

477

478

483 if (!MCAsmParserCtorFn)

484 return nullptr;

485 return MCAsmParserCtorFn(STI, Parser, MII, Options);

486 }

487

488

489

491 std::unique_ptr &&Streamer) const {

492 if (!AsmPrinterCtorFn)

493 return nullptr;

494 return AsmPrinterCtorFn(TM, std::move(Streamer));

495 }

496

499 if (!MCDisassemblerCtorFn)

500 return nullptr;

501 return MCDisassemblerCtorFn(*this, STI, Ctx);

502 }

503

508 if (!MCInstPrinterCtorFn)

509 return nullptr;

510 return MCInstPrinterCtorFn(T, SyntaxVariant, MAI, MII, MRI);

511 }

512

513

516 if (!MCCodeEmitterCtorFn)

517 return nullptr;

518 return MCCodeEmitterCtorFn(II, Ctx);

519 }

520

521

522

523

524

525

526

527

529 std::unique_ptr TAB,

530 std::unique_ptr OW,

531 std::unique_ptr Emitter,

533 LLVM_DEPRECATED("Use the overload without the 3 trailing bool", "")

540

549 bool IsVerboseAsm, bool UseDwarfDirectory,

552

556 if (AsmTargetStreamerCtorFn)

557 return AsmTargetStreamerCtorFn(S, OS, InstPrint);

558 return nullptr;

559 }

560

564 return S;

565 }

566

568 if (NullTargetStreamerCtorFn)

569 return NullTargetStreamerCtorFn(S);

570 return nullptr;

571 }

572

573

574

575

576

579 ? MCRelocationInfoCtorFn

581 return Fn(Triple(TT), Ctx);

582 }

583

584

585

586

587

588

589

590

591

592

593

594

595

600 std::unique_ptr &&RelInfo) const {

603 return Fn(Triple(TT), GetOpInfo, SymbolLookUp, DisInfo, Ctx,

604 std::move(RelInfo));

605 }

606

607

608

612 if (CustomBehaviourCtorFn)

613 return CustomBehaviourCtorFn(STI, SrcMgr, MCII);

614 return nullptr;

615 }

616

617

618

621 if (InstrPostProcessCtorFn)

622 return InstrPostProcessCtorFn(STI, MCII);

623 return nullptr;

624 }

625

626

627

628

632 if (InstrumentManagerCtorFn)

633 return InstrumentManagerCtorFn(STI, MCII);

634 return nullptr;

635 }

636

637

638};

639

640

642

643

644

645

647

650

651 const Target *Current = nullptr;

652

654

655 public:

661

663

666

667

669 assert(Current && "Cannot increment end iterator!");

670 Current = Current->getNext();

671 return *this;

672 }

675 ++*this;

676 return tmp;

677 }

678

680 assert(Current && "Cannot dereference end iterator!");

681 return *Current;

682 }

683

685 };

686

687

688

690

691

692

693

695

696

697

698

699

700

702

703

704

705

706

707

708

709

710

711

712

713

715 std::string &Error);

716

717

718

719

720

721

722

723

724

725

726

727

728

729

730

731

732

733

734

735

736

737

738

740 const char *BackendName,

742 bool HasJIT = false);

743

744

745

746

747

748

749

750

751

752

754 T.MCAsmInfoCtorFn = Fn;

755 }

756

757

758

759

760

761

762

763

764

767 T.MCObjectFileInfoCtorFn = Fn;

768 }

769

770

771

772

773

774

775

776

777

778

780 T.MCInstrInfoCtorFn = Fn;

781 }

782

783

784

787 T.MCInstrAnalysisCtorFn = Fn;

788 }

789

790

791

792

793

794

795

796

797

798

800 T.MCRegInfoCtorFn = Fn;

801 }

802

803

804

805

806

807

808

809

810

811

814 T.MCSubtargetInfoCtorFn = Fn;

815 }

816

817

818

819

820

821

822

823

824

825

827 T.TargetMachineCtorFn = Fn;

828 }

829

830

831

832

833

834

835

836

837

838

840 T.MCAsmBackendCtorFn = Fn;

841 }

842

843

844

845

846

847

848

849

850

851

853 T.MCAsmParserCtorFn = Fn;

854 }

855

856

857

858

859

860

861

862

863

864

866 T.AsmPrinterCtorFn = Fn;

867 }

868

869

870

871

872

873

874

875

876

877

880 T.MCDisassemblerCtorFn = Fn;

881 }

882

883

884

885

886

887

888

889

890

891

893 T.MCInstPrinterCtorFn = Fn;

894 }

895

896

897

898

899

900

901

902

903

904

906 T.MCCodeEmitterCtorFn = Fn;

907 }

908

910 T.COFFStreamerCtorFn = Fn;

911 }

912

914 T.MachOStreamerCtorFn = Fn;

915 }

916

918 T.ELFStreamerCtorFn = Fn;

919 }

920

922 T.XCOFFStreamerCtorFn = Fn;

923 }

924

927 T.NullTargetStreamerCtorFn = Fn;

928 }

929

932 T.AsmTargetStreamerCtorFn = Fn;

933 }

934

935 static void

938 T.ObjectTargetStreamerCtorFn = Fn;

939 }

940

941

942

943

944

945

946

947

948

949

952 T.MCRelocationInfoCtorFn = Fn;

953 }

954

955

956

957

958

959

960

961

962

963

965 T.MCSymbolizerCtorFn = Fn;

966 }

967

968

969

970

971

972

973

974

975

976

979 T.CustomBehaviourCtorFn = Fn;

980 }

981

982

983

984

985

986

987

988

989

990

993 T.InstrPostProcessCtorFn = Fn;

994 }

995

996

997

998

999

1000

1001

1002

1003

1004

1005

1008 T.InstrumentManagerCtorFn = Fn;

1009 }

1010

1011

1012};

1013

1014

1015

1016

1017

1018

1019

1020

1021

1022

1023

1024

1025

1026

1027

1029 bool HasJIT = false>

1032 const char *BackendName) {

1034 HasJIT);

1035 }

1036

1038 return Arch == TargetArchType;

1039 }

1040};

1041

1042

1043

1044

1045

1046

1047

1048

1049

1053 }

1054

1055private:

1058 return new MCAsmInfoImpl(TT, Options);

1059 }

1060};

1061

1062

1063

1064

1065

1066

1067

1068

1069

1073 }

1074};

1075

1076

1077

1078

1079

1080

1081

1082

1083

1087 }

1088

1089private:

1091 bool LargeCodeModel = false) {

1092 return new MCObjectFileInfoImpl(Ctx, PIC, LargeCodeModel);

1093 }

1094};

1095

1096

1097

1098

1099

1100

1101

1102

1106 }

1107};

1108

1109

1110

1111

1112

1113

1114

1115

1116

1120 }

1121

1122private:

1123 static MCInstrInfo *Allocator() { return new MCInstrInfoImpl(); }

1124};

1125

1126

1127

1128

1129

1130

1131

1132

1133

1137 }

1138};

1139

1140

1141

1142

1143

1144

1145

1146

1147

1151 }

1152

1153private:

1155 return new MCInstrAnalysisImpl(Info);

1156 }

1157};

1158

1159

1160

1161

1162

1163

1164

1165

1166

1170 }

1171};

1172

1173

1174

1175

1176

1177

1178

1179

1180

1184 }

1185

1186private:

1188 return new MCRegisterInfoImpl();

1189 }

1190};

1191

1192

1193

1194

1195

1196

1197

1198

1199

1203 }

1204};

1205

1206

1207

1208

1209

1210

1211

1212

1213

1217 }

1218

1219private:

1222 return new MCSubtargetInfoImpl();

1223 }

1224};

1225

1226

1227

1228

1229

1230

1231

1232

1233

1237 }

1238};

1239

1240

1241

1242

1243

1244

1245

1246

1247

1251 }

1252

1253private:

1257 std::optionalCodeModel::Model CM, CodeGenOptLevel OL, bool JIT) {

1258 return new TargetMachineImpl(T, TT, CPU, FS, Options, RM, CM, OL, JIT);

1259 }

1260};

1261

1262

1263

1264

1265

1266

1267

1268

1272 }

1273

1274private:

1278 return new MCAsmBackendImpl(T, STI, MRI);

1279 }

1280};

1281

1282

1283

1284

1285

1286

1287

1288

1289

1293 }

1294

1295private:

1299 return new MCAsmParserImpl(STI, P, MII, Options);

1300 }

1301};

1302

1303

1304

1305

1306

1307

1308

1309

1310

1314 }

1315

1316private:

1318 std::unique_ptr &&Streamer) {

1319 return new AsmPrinterImpl(TM, std::move(Streamer));

1320 }

1321};

1322

1323

1324

1325

1326

1327

1328

1329

1330

1334 }

1335

1336private:

1339 return new MCCodeEmitterImpl();

1340 }

1341};

1342

1343}

1344

1345#endif

unsigned const MachineRegisterInfo * MRI

Analysis containing CSE Info

#define LLVM_DEPRECATED(MSG, FIX)

dxil DXContainer Global Emitter

uint64_t IntrinsicInst * II

PassInstrumentationCallbacks PIC

assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())

This class is intended to be used as a driving class for all asm writers.

Lightweight error class with error context and mandatory checking.

Generic interface to target specific assembler backends.

This class is intended to be used as a base class for asm properties and features specific to the tar...

Generic assembler parser interface, for use by target specific assembly parsers.

MCCodeEmitter - Generic instruction encoding interface.

Context object for machine code objects.

Superclass for all disassemblers.

This is an instance of a target assembly language printer that converts an MCInst to valid target ass...

Interface to description of machine instruction set.

void initMCObjectFileInfo(MCContext &MCCtx, bool PIC, bool LargeCodeModel=false)

Defines the object file and target independent interfaces used by the assembler backend to write nati...

MCRegisterInfo base class - We assume that the target defines a static array of MCRegisterDesc object...

Create MCExprs from relocations found in an object file.

Streaming machine code generation interface.

Generic base class for all target subtargets.

Symbolize and annotate disassembled instructions.

MCTargetAsmParser - Generic interface to target specific assembly parsers.

Target specific streamer interface.

StringRef - Represent a constant reference to a string, i.e.

Primary interface to the complete machine description for the target machine.

bool operator!=(const iterator &x) const

const Target * operator->() const

bool operator==(const iterator &x) const

const Target & operator*() const

std::ptrdiff_t difference_type

std::forward_iterator_tag iterator_category

Target - Wrapper for Target specific information.

MCTargetStreamer *(*)(MCStreamer &S) NullTargetStreamerCtorTy

MCStreamer *(*)(const Triple &T, MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&Emitter) XCOFFStreamerCtorTy

MCDisassembler *(*)(const Target &T, const MCSubtargetInfo &STI, MCContext &Ctx) MCDisassemblerCtorTy

mca::InstrPostProcess *(*)(const MCSubtargetInfo &STI, const MCInstrInfo &MCII) InstrPostProcessCtorTy

MCAsmInfo *(*)(const MCRegisterInfo &MRI, const Triple &TT, const MCTargetOptions &Options) MCAsmInfoCtorFnTy

bool hasTargetMachine() const

hasTargetMachine - Check if this target supports code generation.

TargetMachine *(*)(const Target &T, const Triple &TT, StringRef CPU, StringRef Features, const TargetOptions &Options, std::optional< Reloc::Model > RM, std::optional< CodeModel::Model > CM, CodeGenOptLevel OL, bool JIT) TargetMachineCtorTy

MCCodeEmitter * createMCCodeEmitter(const MCInstrInfo &II, MCContext &Ctx) const

createMCCodeEmitter - Create a target specific code emitter.

const char * getName() const

getName - Get the target name.

MCObjectFileInfo * createMCObjectFileInfo(MCContext &Ctx, bool PIC, bool LargeCodeModel=false) const

Create a MCObjectFileInfo implementation for the specified target triple.

const Target * getNext() const

MCSubtargetInfo * createMCSubtargetInfo(StringRef TheTriple, StringRef CPU, StringRef Features) const

createMCSubtargetInfo - Create a MCSubtargetInfo implementation.

AsmPrinter *(*)(TargetMachine &TM, std::unique_ptr< MCStreamer > &&Streamer) AsmPrinterCtorTy

MCSymbolizer * createMCSymbolizer(StringRef TT, LLVMOpInfoCallback GetOpInfo, LLVMSymbolLookupCallback SymbolLookUp, void *DisInfo, MCContext *Ctx, std::unique_ptr< MCRelocationInfo > &&RelInfo) const

createMCSymbolizer - Create a target specific MCSymbolizer.

MCAsmBackend * createMCAsmBackend(const MCSubtargetInfo &STI, const MCRegisterInfo &MRI, const MCTargetOptions &Options) const

createMCAsmBackend - Create a target specific assembly parser.

MCObjectFileInfo *(*)(MCContext &Ctx, bool PIC, bool LargeCodeModel) MCObjectFileInfoCtorFnTy

bool hasMCAsmParser() const

hasMCAsmParser - Check if this target supports assembly parsing.

MCStreamer * createNullStreamer(MCContext &Ctx) const

MCRelocationInfo * createMCRelocationInfo(StringRef TT, MCContext &Ctx) const

createMCRelocationInfo - Create a target specific MCRelocationInfo.

MCStreamer *(*)(const Triple &T, MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&Emitter) ELFStreamerCtorTy

MCTargetStreamer * createAsmTargetStreamer(MCStreamer &S, formatted_raw_ostream &OS, MCInstPrinter *InstPrint) const

MCInstrAnalysis *(*)(const MCInstrInfo *Info) MCInstrAnalysisCtorFnTy

MCRegisterInfo * createMCRegInfo(StringRef TT) const

createMCRegInfo - Create a MCRegisterInfo implementation.

MCTargetStreamer *(*)(MCStreamer &S, const MCSubtargetInfo &STI) ObjectTargetStreamerCtorTy

MCRegisterInfo *(*)(const Triple &TT) MCRegInfoCtorFnTy

MCInstrInfo *(*)() MCInstrInfoCtorFnTy

MCStreamer * createMCObjectStreamer(const Triple &T, MCContext &Ctx, std::unique_ptr< MCAsmBackend > TAB, std::unique_ptr< MCObjectWriter > OW, std::unique_ptr< MCCodeEmitter > Emitter, const MCSubtargetInfo &STI) const

Create a target specific MCStreamer.

mca::CustomBehaviour * createCustomBehaviour(const MCSubtargetInfo &STI, const mca::SourceMgr &SrcMgr, const MCInstrInfo &MCII) const

createCustomBehaviour - Create a target specific CustomBehaviour.

bool(*)(Triple::ArchType Arch) ArchMatchFnTy

MCInstPrinter *(*)(const Triple &T, unsigned SyntaxVariant, const MCAsmInfo &MAI, const MCInstrInfo &MII, const MCRegisterInfo &MRI) MCInstPrinterCtorTy

MCDisassembler * createMCDisassembler(const MCSubtargetInfo &STI, MCContext &Ctx) const

mca::CustomBehaviour *(*)(const MCSubtargetInfo &STI, const mca::SourceMgr &SrcMgr, const MCInstrInfo &MCII) CustomBehaviourCtorTy

TargetMachine * createTargetMachine(StringRef TT, StringRef CPU, StringRef Features, const TargetOptions &Options, std::optional< Reloc::Model > RM, std::optional< CodeModel::Model > CM=std::nullopt, CodeGenOptLevel OL=CodeGenOptLevel::Default, bool JIT=false) const

createTargetMachine - Create a target specific machine implementation for the specified Triple.

bool hasMCAsmBackend() const

hasMCAsmBackend - Check if this target supports .o generation.

MCAsmInfo * createMCAsmInfo(const MCRegisterInfo &MRI, StringRef TheTriple, const MCTargetOptions &Options) const

createMCAsmInfo - Create a MCAsmInfo implementation for the specified target triple.

MCInstPrinter * createMCInstPrinter(const Triple &T, unsigned SyntaxVariant, const MCAsmInfo &MAI, const MCInstrInfo &MII, const MCRegisterInfo &MRI) const

MCSymbolizer *(*)(const Triple &TT, LLVMOpInfoCallback GetOpInfo, LLVMSymbolLookupCallback SymbolLookUp, void *DisInfo, MCContext *Ctx, std::unique_ptr< MCRelocationInfo > &&RelInfo) MCSymbolizerCtorTy

MCSubtargetInfo *(*)(const Triple &TT, StringRef CPU, StringRef Features) MCSubtargetInfoCtorFnTy

mca::InstrPostProcess * createInstrPostProcess(const MCSubtargetInfo &STI, const MCInstrInfo &MCII) const

createInstrPostProcess - Create a target specific InstrPostProcess.

const char * getBackendName() const

getBackendName - Get the backend name.

MCTargetStreamer *(*)(MCStreamer &S, formatted_raw_ostream &OS, MCInstPrinter *InstPrint) AsmTargetStreamerCtorTy

MCAsmBackend *(*)(const Target &T, const MCSubtargetInfo &STI, const MCRegisterInfo &MRI, const MCTargetOptions &Options) MCAsmBackendCtorTy

MCTargetAsmParser * createMCAsmParser(const MCSubtargetInfo &STI, MCAsmParser &Parser, const MCInstrInfo &MII, const MCTargetOptions &Options) const

createMCAsmParser - Create a target specific assembly parser.

MCInstrAnalysis * createMCInstrAnalysis(const MCInstrInfo *Info) const

createMCInstrAnalysis - Create a MCInstrAnalysis implementation.

const char * getShortDescription() const

getShortDescription - Get a short description of the target.

bool hasJIT() const

hasJIT - Check if this targets supports the just-in-time compilation.

MCCodeEmitter *(*)(const MCInstrInfo &II, MCContext &Ctx) MCCodeEmitterCtorTy

mca::InstrumentManager *(*)(const MCSubtargetInfo &STI, const MCInstrInfo &MCII) InstrumentManagerCtorTy

MCStreamer *(*)(MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&Emitter) COFFStreamerCtorTy

MCTargetStreamer * createNullTargetStreamer(MCStreamer &S) const

MCRelocationInfo *(*)(const Triple &TT, MCContext &Ctx) MCRelocationInfoCtorTy

MCStreamer * createAsmStreamer(MCContext &Ctx, std::unique_ptr< formatted_raw_ostream > OS, MCInstPrinter *IP, std::unique_ptr< MCCodeEmitter > CE, std::unique_ptr< MCAsmBackend > TAB) const

MCTargetAsmParser *(*)(const MCSubtargetInfo &STI, MCAsmParser &P, const MCInstrInfo &MII, const MCTargetOptions &Options) MCAsmParserCtorTy

MCStreamer *(*)(MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&Emitter) MachOStreamerCtorTy

AsmPrinter * createAsmPrinter(TargetMachine &TM, std::unique_ptr< MCStreamer > &&Streamer) const

createAsmPrinter - Create a target specific assembly printer pass.

MCInstrInfo * createMCInstrInfo() const

createMCInstrInfo - Create a MCInstrInfo implementation.

mca::InstrumentManager * createInstrumentManager(const MCSubtargetInfo &STI, const MCInstrInfo &MCII) const

createInstrumentManager - Create a target specific InstrumentManager.

Triple - Helper class for working with autoconf configuration names.

A Use represents the edge between a Value definition and its users.

formatted_raw_ostream - A raw_ostream that wraps another one and keeps track of line and column posit...

A range adaptor for a pair of iterators.

Class which can be overriden by targets to enforce instruction dependencies and behaviours that aren'...

Class which can be overriden by targets to modify the mca::Instruction objects before the pipeline st...

This class allows targets to optionally customize the logic that resolves scheduling class IDs.

This class implements an extremely fast bulk output stream that can only output to a stream.

const char *(* LLVMSymbolLookupCallback)(void *DisInfo, uint64_t ReferenceValue, uint64_t *ReferenceType, uint64_t ReferencePC, const char **ReferenceName)

The type for the symbol lookup function.

int(* LLVMOpInfoCallback)(void *DisInfo, uint64_t PC, uint64_t Offset, uint64_t OpSize, uint64_t InstSize, int TagType, void *TagBuf)

The type for the operand information call back function.

This provides a very simple, boring adaptor for a begin and end iterator into a range type.

This is an optimization pass for GlobalISel generic memory operations.

mca::CustomBehaviour * createCustomBehaviour(const MCSubtargetInfo &STI, const mca::SourceMgr &SrcMgr, const MCInstrInfo &MCII)

MCStreamer * createAsmStreamer(MCContext &Ctx, std::unique_ptr< formatted_raw_ostream > OS, MCInstPrinter *InstPrint, std::unique_ptr< MCCodeEmitter > &&CE, std::unique_ptr< MCAsmBackend > &&TAB)

Create a machine code streamer which will print out assembly for the native target,...

MCStreamer * createELFStreamer(MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&CE)

MCStreamer * createNullStreamer(MCContext &Ctx)

Create a dummy machine code streamer, which does nothing.

MCSymbolizer * createMCSymbolizer(const Triple &TT, LLVMOpInfoCallback GetOpInfo, LLVMSymbolLookupCallback SymbolLookUp, void *DisInfo, MCContext *Ctx, std::unique_ptr< MCRelocationInfo > &&RelInfo)

MCStreamer * createMachOStreamer(MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&CE, bool DWARFMustBeAtTheEnd, bool LabelSections=false)

MCRelocationInfo * createMCRelocationInfo(const Triple &TT, MCContext &Ctx)

CodeGenOptLevel

Code generation optimization level.

MCStreamer * createDXContainerStreamer(MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&CE)

mca::InstrumentManager * createInstrumentManager(const MCSubtargetInfo &STI, const MCInstrInfo &MCII)

MCStreamer * createWasmStreamer(MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&CE)

MCStreamer * createGOFFStreamer(MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&CE)

MCStreamer * createSPIRVStreamer(MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&CE)

mca::InstrPostProcess * createInstrPostProcess(const MCSubtargetInfo &STI, const MCInstrInfo &MCII)

Implement std::hash so that hash_code can be used in STL containers.

Description of the encoding of one expression Op.

RegisterAsmPrinter - Helper template for registering a target specific assembly printer,...

RegisterAsmPrinter(Target &T)

RegisterMCAsmBackend - Helper template for registering a target specific assembler backend.

RegisterMCAsmBackend(Target &T)

RegisterMCAsmInfoFn - Helper template for registering a target assembly info implementation.

RegisterMCAsmInfoFn(Target &T, Target::MCAsmInfoCtorFnTy Fn)

RegisterMCAsmInfo - Helper template for registering a target assembly info implementation.

RegisterMCAsmInfo(Target &T)

RegisterMCAsmParser - Helper template for registering a target specific assembly parser,...

RegisterMCAsmParser(Target &T)

RegisterMCCodeEmitter - Helper template for registering a target specific machine code emitter,...

RegisterMCCodeEmitter(Target &T)

RegisterMCInstrAnalysisFn - Helper template for registering a target instruction analyzer implementat...

RegisterMCInstrAnalysisFn(Target &T, Target::MCInstrAnalysisCtorFnTy Fn)

RegisterMCInstrAnalysis - Helper template for registering a target instruction analyzer implementatio...

RegisterMCInstrAnalysis(Target &T)

RegisterMCInstrInfoFn - Helper template for registering a target instruction info implementation.

RegisterMCInstrInfoFn(Target &T, Target::MCInstrInfoCtorFnTy Fn)

RegisterMCInstrInfo - Helper template for registering a target instruction info implementation.

RegisterMCInstrInfo(Target &T)

Helper template for registering a target object file info implementation.

RegisterMCObjectFileInfoFn(Target &T, Target::MCObjectFileInfoCtorFnTy Fn)

Helper template for registering a target object file info implementation.

RegisterMCObjectFileInfo(Target &T)

RegisterMCRegInfoFn - Helper template for registering a target register info implementation.

RegisterMCRegInfoFn(Target &T, Target::MCRegInfoCtorFnTy Fn)

RegisterMCRegInfo - Helper template for registering a target register info implementation.

RegisterMCRegInfo(Target &T)

RegisterMCSubtargetInfoFn - Helper template for registering a target subtarget info implementation.

RegisterMCSubtargetInfoFn(Target &T, Target::MCSubtargetInfoCtorFnTy Fn)

RegisterMCSubtargetInfo - Helper template for registering a target subtarget info implementation.

RegisterMCSubtargetInfo(Target &T)

RegisterTargetMachine - Helper template for registering a target machine implementation,...

RegisterTargetMachine(Target &T)

RegisterTarget - Helper template for registering a target, for use in the target's initialization fun...

static bool getArchMatch(Triple::ArchType Arch)

RegisterTarget(Target &T, const char *Name, const char *Desc, const char *BackendName)

TargetRegistry - Generic interface to target specific features.

static void RegisterMCSymbolizer(Target &T, Target::MCSymbolizerCtorTy Fn)

RegisterMCSymbolizer - Register an MCSymbolizer implementation for the given target.

static void RegisterMCRegInfo(Target &T, Target::MCRegInfoCtorFnTy Fn)

RegisterMCRegInfo - Register a MCRegisterInfo implementation for the given target.

static void RegisterAsmPrinter(Target &T, Target::AsmPrinterCtorTy Fn)

RegisterAsmPrinter - Register an AsmPrinter implementation for the given target.

static void RegisterMCAsmBackend(Target &T, Target::MCAsmBackendCtorTy Fn)

RegisterMCAsmBackend - Register a MCAsmBackend implementation for the given target.

static void RegisterXCOFFStreamer(Target &T, Target::XCOFFStreamerCtorTy Fn)

static void RegisterMCCodeEmitter(Target &T, Target::MCCodeEmitterCtorTy Fn)

RegisterMCCodeEmitter - Register a MCCodeEmitter implementation for the given target.

static void RegisterMCAsmInfo(Target &T, Target::MCAsmInfoCtorFnTy Fn)

RegisterMCAsmInfo - Register a MCAsmInfo implementation for the given target.

static void RegisterMCSubtargetInfo(Target &T, Target::MCSubtargetInfoCtorFnTy Fn)

RegisterMCSubtargetInfo - Register a MCSubtargetInfo implementation for the given target.

static void RegisterObjectTargetStreamer(Target &T, Target::ObjectTargetStreamerCtorTy Fn)

static void RegisterMCInstrAnalysis(Target &T, Target::MCInstrAnalysisCtorFnTy Fn)

RegisterMCInstrAnalysis - Register a MCInstrAnalysis implementation for the given target.

static void RegisterELFStreamer(Target &T, Target::ELFStreamerCtorTy Fn)

static void RegisterNullTargetStreamer(Target &T, Target::NullTargetStreamerCtorTy Fn)

static void RegisterInstrPostProcess(Target &T, Target::InstrPostProcessCtorTy Fn)

RegisterInstrPostProcess - Register an InstrPostProcess implementation for the given target.

static const Target * lookupTarget(StringRef Triple, std::string &Error)

lookupTarget - Lookup a target based on a target triple.

static void RegisterMCDisassembler(Target &T, Target::MCDisassemblerCtorTy Fn)

RegisterMCDisassembler - Register a MCDisassembler implementation for the given target.

static void RegisterMCAsmParser(Target &T, Target::MCAsmParserCtorTy Fn)

RegisterMCAsmParser - Register a MCTargetAsmParser implementation for the given target.

static void printRegisteredTargetsForVersion(raw_ostream &OS)

printRegisteredTargetsForVersion - Print the registered targets appropriately for inclusion in a tool...

static void RegisterTargetMachine(Target &T, Target::TargetMachineCtorTy Fn)

RegisterTargetMachine - Register a TargetMachine implementation for the given target.

static void RegisterMCInstPrinter(Target &T, Target::MCInstPrinterCtorTy Fn)

RegisterMCInstPrinter - Register a MCInstPrinter implementation for the given target.

static void RegisterCOFFStreamer(Target &T, Target::COFFStreamerCtorTy Fn)

static void RegisterTarget(Target &T, const char *Name, const char *ShortDesc, const char *BackendName, Target::ArchMatchFnTy ArchMatchFn, bool HasJIT=false)

RegisterTarget - Register the given target.

static void RegisterMCInstrInfo(Target &T, Target::MCInstrInfoCtorFnTy Fn)

RegisterMCInstrInfo - Register a MCInstrInfo implementation for the given target.

static iterator_range< iterator > targets()

static void RegisterInstrumentManager(Target &T, Target::InstrumentManagerCtorTy Fn)

RegisterInstrumentManager - Register an InstrumentManager implementation for the given target.

static void RegisterCustomBehaviour(Target &T, Target::CustomBehaviourCtorTy Fn)

RegisterCustomBehaviour - Register a CustomBehaviour implementation for the given target.

static void RegisterMachOStreamer(Target &T, Target::MachOStreamerCtorTy Fn)

static void RegisterMCObjectFileInfo(Target &T, Target::MCObjectFileInfoCtorFnTy Fn)

static void RegisterAsmTargetStreamer(Target &T, Target::AsmTargetStreamerCtorTy Fn)

static void RegisterMCRelocationInfo(Target &T, Target::MCRelocationInfoCtorTy Fn)

RegisterMCRelocationInfo - Register an MCRelocationInfo implementation for the given target.

Abstracting the input code sequence (a sequence of MCInst) and assigning unique identifiers to every ...