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 {

89 std::unique_ptr InstPrint,

90 std::unique_ptr CE,

91 std::unique_ptr TAB);

94 std::unique_ptr &&TAB,

95 std::unique_ptr &&OW,

96 std::unique_ptr &&CE);

98 std::unique_ptr &&TAB,

99 std::unique_ptr &&OW,

100 std::unique_ptr &&CE);

102 std::unique_ptr &&TAB,

103 std::unique_ptr &&OW,

104 std::unique_ptr &&CE,

105 bool DWARFMustBeAtTheEnd,

106 bool LabelSections = false);

108 std::unique_ptr &&TAB,

109 std::unique_ptr &&OW,

110 std::unique_ptr &&CE);

112 std::unique_ptr &&TAB,

113 std::unique_ptr &&OW,

114 std::unique_ptr &&CE);

117 std::unique_ptr &&OW,

118 std::unique_ptr &&CE);

119

122

126 MCContext *Ctx, std::unique_ptr &&RelInfo);

127

131

134

137

138

139

140

141

142

143

144

145

147public:

149

151

156 bool PIC,

157 bool LargeCodeModel);

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

168

169

170

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

184 unsigned SyntaxVariant,

192 std::unique_ptr &&TAB,

193 std::unique_ptr &&OW,

194 std::unique_ptr &&Emitter);

197 std::unique_ptr &&OW,

198 std::unique_ptr &&Emitter);

201 std::unique_ptr &&OW,

202 std::unique_ptr &&Emitter);

205 std::unique_ptr &&TAB,

206 std::unique_ptr &&OW,

207 std::unique_ptr &&Emitter);

208

214 *(*)(MCContext & Ctx, std::unique_ptr<formatted_raw_ostream> OS,

215 std::unique_ptr IP, std::unique_ptr CE,

216 std::unique_ptr TAB);

225 std::unique_ptr &&RelInfo);

226

231

235

239

240private:

241

242

244

245

247

248

249 const char *Name;

250

251

252 const char *ShortDesc;

253

254

255

256 const char *BackendName;

257

258

259 bool HasJIT;

260

261

262

264

265

267

268

269

271

272

273

275

276

277

279

280

281

283

284

285

287

288

289

291

292

293

295

296

297

299

300

301

303

304

305

307

308

309

311

312

317

318

319

321

322

323

325

326

327

329

330

331

333

334

335

337

338

339

341

342

343

345

346

347

349

350

351

353

354public:

356

357

358

359

360

362

363

364 const char *getName() const { return Name; }

365

366

368

369

371

372

373

374

375

376

377 bool hasJIT() const { return HasJIT; }

378

379

381

382

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

384

385

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

387

388

389

390

391

392

393 [[deprecated("Use overload accepting Triple instead")]]

396 if (!MCAsmInfoCtorFn)

397 return nullptr;

399 }

400

401

402

403

404

405

406

407

410 if (!MCAsmInfoCtorFn)

411 return nullptr;

412 return MCAsmInfoCtorFn(MRI, TheTriple, Options);

413 }

414

415

416

417

419 bool LargeCodeModel = false) const {

420 if (!MCObjectFileInfoCtorFn) {

423 return MOFI;

424 }

425 return MCObjectFileInfoCtorFn(Ctx, PIC, LargeCodeModel);

426 }

427

428

429

431 if (!MCInstrInfoCtorFn)

432 return nullptr;

433 return MCInstrInfoCtorFn();

434 }

435

436

437

439 if (!MCInstrAnalysisCtorFn)

440 return nullptr;

441 return MCInstrAnalysisCtorFn(Info);

442 }

443

444

445 [[deprecated("Use overload accepting Triple instead")]]

447 if (!MCRegInfoCtorFn)

448 return nullptr;

449 return MCRegInfoCtorFn(Triple(TT));

450 }

451

452

454 if (!MCRegInfoCtorFn)

455 return nullptr;

456 return MCRegInfoCtorFn(TT);

457 }

458

459

460 [[deprecated("Use overload accepting Triple instead")]]

463 if (!MCSubtargetInfoCtorFn)

464 return nullptr;

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

466 }

467

468

469

470

471

472

473

474

475

476

479 if (!MCSubtargetInfoCtorFn)

480 return nullptr;

481 return MCSubtargetInfoCtorFn(TheTriple, CPU, Features);

482 }

483

484

485

486

487

488

489

490

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

496 if (!TargetMachineCtorFn)

497 return nullptr;

498 return TargetMachineCtorFn(*this, TT, CPU, Features, Options, RM, CM, OL,

499 JIT);

500 }

501

502

506 if (!MCAsmBackendCtorFn)

507 return nullptr;

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

509 }

510

511

512

513

514

519 if (!MCAsmParserCtorFn)

520 return nullptr;

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

522 }

523

524

525

527 std::unique_ptr &&Streamer) const {

528 if (!AsmPrinterCtorFn)

529 return nullptr;

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

531 }

532

535 if (!MCDisassemblerCtorFn)

536 return nullptr;

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

538 }

539

544 if (!MCInstPrinterCtorFn)

545 return nullptr;

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

547 }

548

549

552 if (!MCCodeEmitterCtorFn)

553 return nullptr;

554 return MCCodeEmitterCtorFn(II, Ctx);

555 }

556

557

558

559

560

561

562

563

565 const Triple &T, MCContext &Ctx, std::unique_ptr TAB,

566 std::unique_ptr OW,

568

571 std::unique_ptr IP,

572 std::unique_ptr CE,

573 std::unique_ptr TAB) const;

574

578 if (AsmTargetStreamerCtorFn)

579 return AsmTargetStreamerCtorFn(S, OS, InstPrint);

580 return nullptr;

581 }

582

588

590 if (NullTargetStreamerCtorFn)

591 return NullTargetStreamerCtorFn(S);

592 return nullptr;

593 }

594

595

596 [[deprecated("Use overload accepting Triple instead")]]

600

601

602

603

604

608 ? MCRelocationInfoCtorFn

610 return Fn(TT, Ctx);

611 }

612

613

614 [[deprecated("Use overload accepting Triple instead")]]

619 std::unique_ptr &&RelInfo) const {

621 std::move(RelInfo));

622 }

623

624

625

626

627

628

629

630

631

632

633

634

635

640 std::unique_ptr &&RelInfo) const {

643 return Fn(TT, GetOpInfo, SymbolLookUp, DisInfo, Ctx, std::move(RelInfo));

644 }

645

646

647

651 if (CustomBehaviourCtorFn)

652 return CustomBehaviourCtorFn(STI, SrcMgr, MCII);

653 return nullptr;

654 }

655

656

657

660 if (InstrPostProcessCtorFn)

661 return InstrPostProcessCtorFn(STI, MCII);

662 return nullptr;

663 }

664

665

666

667

671 if (InstrumentManagerCtorFn)

672 return InstrumentManagerCtorFn(STI, MCII);

673 return nullptr;

674 }

675

676

677};

678

679

681

682

683

684

686

687 class iterator {

689

690 const Target *Current = nullptr;

691

693

694 public:

700

702

703 bool operator==(const iterator &x) const { return Current == x.Current; }

705

706

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

709 Current = Current->getNext();

710 return *this;

711 }

713 iterator tmp = *this;

714 ++*this;

715 return tmp;

716 }

717

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

720 return *Current;

721 }

722

724 };

725

726

727

729

730

731

732

734

735

736

737

738

739

740

741 [[deprecated("Use overload accepting Triple instead")]]

745

746

747

748

749

750

752 std::string &Error);

753

754

755

756

757

758

759

760

761

762

763

764

767

768

769

770

771

772

773

774

775

776

777

778

779

780

781

782

783

784

785

786

787

788

789

791 const char *ShortDesc,

792 const char *BackendName,

794 bool HasJIT = false);

795

796

797

798

799

800

801

802

803

804

806 T.MCAsmInfoCtorFn = Fn;

807 }

808

809

810

811

812

813

814

815

816

819 T.MCObjectFileInfoCtorFn = Fn;

820 }

821

822

823

824

825

826

827

828

829

830

832 T.MCInstrInfoCtorFn = Fn;

833 }

834

835

836

839 T.MCInstrAnalysisCtorFn = Fn;

840 }

841

842

843

844

845

846

847

848

849

850

852 T.MCRegInfoCtorFn = Fn;

853 }

854

855

856

857

858

859

860

861

862

863

866 T.MCSubtargetInfoCtorFn = Fn;

867 }

868

869

870

871

872

873

874

875

876

877

879 T.TargetMachineCtorFn = Fn;

880 }

881

882

883

884

885

886

887

888

889

890

892 T.MCAsmBackendCtorFn = Fn;

893 }

894

895

896

897

898

899

900

901

902

903

905 T.MCAsmParserCtorFn = Fn;

906 }

907

908

909

910

911

912

913

914

915

916

918 T.AsmPrinterCtorFn = Fn;

919 }

920

921

922

923

924

925

926

927

928

929

932 T.MCDisassemblerCtorFn = Fn;

933 }

934

935

936

937

938

939

940

941

942

943

945 T.MCInstPrinterCtorFn = Fn;

946 }

947

948

949

950

951

952

953

954

955

956

958 T.MCCodeEmitterCtorFn = Fn;

959 }

960

962 T.COFFStreamerCtorFn = Fn;

963 }

964

966 T.MachOStreamerCtorFn = Fn;

967 }

968

970 T.ELFStreamerCtorFn = Fn;

971 }

972

974 T.XCOFFStreamerCtorFn = Fn;

975 }

976

979 T.NullTargetStreamerCtorFn = Fn;

980 }

981

983 T.AsmStreamerCtorFn = Fn;

984 }

985

988 T.AsmTargetStreamerCtorFn = Fn;

989 }

990

991 static void

994 T.ObjectTargetStreamerCtorFn = Fn;

995 }

996

997

998

999

1000

1001

1002

1003

1004

1005

1008 T.MCRelocationInfoCtorFn = Fn;

1009 }

1010

1011

1012

1013

1014

1015

1016

1017

1018

1019

1021 T.MCSymbolizerCtorFn = Fn;

1022 }

1023

1024

1025

1026

1027

1028

1029

1030

1031

1032

1035 T.CustomBehaviourCtorFn = Fn;

1036 }

1037

1038

1039

1040

1041

1042

1043

1044

1045

1046

1049 T.InstrPostProcessCtorFn = Fn;

1050 }

1051

1052

1053

1054

1055

1056

1057

1058

1059

1060

1061

1064 T.InstrumentManagerCtorFn = Fn;

1065 }

1066

1067

1068};

1069

1070

1071

1072

1073

1074

1075

1076

1077

1078

1079

1080

1081

1082

1083

1085 bool HasJIT = false>

1088 const char *BackendName) {

1090 HasJIT);

1091 }

1092

1094 return Arch == TargetArchType;

1095 }

1096};

1097

1098

1099

1100

1101

1102

1103

1104

1105

1110

1111private:

1114 return new MCAsmInfoImpl(TT, Options);

1115 }

1116};

1117

1118

1119

1120

1121

1122

1123

1124

1125

1131

1132

1133

1134

1135

1136

1137

1138

1139

1144

1145private:

1147 bool LargeCodeModel = false) {

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

1149 }

1150};

1151

1152

1153

1154

1155

1156

1157

1158

1164

1165

1166

1167

1168

1169

1170

1171

1172

1181

1182

1183

1184

1185

1186

1187

1188

1189

1195

1196

1197

1198

1199

1200

1201

1202

1203

1208

1209private:

1211 return new MCInstrAnalysisImpl(Info);

1212 }

1213};

1214

1215

1216

1217

1218

1219

1220

1221

1222

1228

1229

1230

1231

1232

1233

1234

1235

1236

1241

1242private:

1244 return new MCRegisterInfoImpl();

1245 }

1246};

1247

1248

1249

1250

1251

1252

1253

1254

1255

1261

1262

1263

1264

1265

1266

1267

1268

1269

1274

1275private:

1278 return new MCSubtargetInfoImpl();

1279 }

1280};

1281

1282

1283

1284

1285

1286

1287

1288

1289

1295

1296

1297

1298

1299

1300

1301

1302

1303

1308

1309private:

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

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

1315 }

1316};

1317

1318

1319

1320

1321

1322

1323

1324

1329

1330private:

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

1335 }

1336};

1337

1338

1339

1340

1341

1342

1343

1344

1345

1350

1351private:

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

1356 }

1357};

1358

1359

1360

1361

1362

1363

1364

1365

1366

1371

1372private:

1374 std::unique_ptr &&Streamer) {

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

1376 }

1377};

1378

1379

1380

1381

1382

1383

1384

1385

1386

1391

1392private:

1395 return new MCCodeEmitterImpl();

1396 }

1397};

1398

1399}

1400

1401#endif

unsigned const MachineRegisterInfo * MRI

assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")

Analysis containing CSE Info

dxil DXContainer Global Emitter

uint64_t IntrinsicInst * II

PassInstrumentationCallbacks PIC

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

Definition TargetRegistry.h:704

const Target * operator->() const

Definition TargetRegistry.h:723

friend struct TargetRegistry

Definition TargetRegistry.h:688

bool operator==(const iterator &x) const

Definition TargetRegistry.h:703

Target value_type

Definition TargetRegistry.h:696

const Target & operator*() const

Definition TargetRegistry.h:718

value_type & reference

Definition TargetRegistry.h:699

iterator & operator++()

Definition TargetRegistry.h:707

std::ptrdiff_t difference_type

Definition TargetRegistry.h:697

value_type * pointer

Definition TargetRegistry.h:698

iterator operator++(int)

Definition TargetRegistry.h:712

std::forward_iterator_tag iterator_category

Definition TargetRegistry.h:695

Target - Wrapper for Target specific information.

Definition TargetRegistry.h:146

TargetMachine * createTargetMachine(const Triple &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.

Definition TargetRegistry.h:491

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

Definition TargetRegistry.h:219

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

Definition TargetRegistry.h:203

MCRegisterInfo * createMCRegInfo(const Triple &TT) const

Create a MCRegisterInfo implementation.

Definition TargetRegistry.h:453

MCTargetStreamer *(*)(MCStreamer &S) NullTargetStreamerCtorTy

Definition TargetRegistry.h:209

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

Definition TargetRegistry.h:152

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

Definition TargetRegistry.h:232

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

Definition TargetRegistry.h:236

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

Definition TargetRegistry.h:161

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

Definition TargetRegistry.h:188

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

Definition TargetRegistry.h:217

bool hasTargetMachine() const

hasTargetMachine - Check if this target supports code generation.

Definition TargetRegistry.h:380

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

createMCCodeEmitter - Create a target specific code emitter.

Definition TargetRegistry.h:550

const char * getName() const

getName - Get the target name.

Definition TargetRegistry.h:364

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

Create a MCObjectFileInfo implementation for the specified target triple.

Definition TargetRegistry.h:418

const Target * getNext() const

Definition TargetRegistry.h:361

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

Definition TargetRegistry.h:155

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

Definition TargetRegistry.h:461

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

Create a MCAsmInfo implementation for the specified target triple.

Definition TargetRegistry.h:408

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

Definition TargetRegistry.h:180

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

Definition TargetRegistry.h:616

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

Definition TargetRegistry.h:173

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

createMCAsmBackend - Create a target specific assembly parser.

Definition TargetRegistry.h:503

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

Definition TargetRegistry.h:199

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

Definition TargetRegistry.h:210

bool hasMCAsmParser() const

hasMCAsmParser - Check if this target supports assembly parsing.

Definition TargetRegistry.h:386

MCStreamer * createNullStreamer(MCContext &Ctx) const

Definition TargetRegistry.h:583

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

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

Definition TargetRegistry.h:597

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

Definition TargetRegistry.h:195

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

Definition TargetRegistry.h:575

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

Definition TargetRegistry.h:159

MCRegisterInfo * createMCRegInfo(StringRef TT) const

Definition TargetRegistry.h:446

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

Definition TargetRegistry.h:160

MCInstrInfo *(*)() MCInstrInfoCtorFnTy

Definition TargetRegistry.h:158

LLVM_ABI 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.

Definition TargetRegistry.h:648

friend struct TargetRegistry

Definition TargetRegistry.h:148

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

Definition TargetRegistry.h:227

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

Definition TargetRegistry.h:150

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

createMCSymbolizer - Create a target specific MCSymbolizer.

Definition TargetRegistry.h:637

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

Definition TargetRegistry.h:533

bool hasMCAsmBackend() const

hasMCAsmBackend - Check if this target supports .o generation.

Definition TargetRegistry.h:383

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

Definition TargetRegistry.h:394

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

Definition TargetRegistry.h:540

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

createInstrPostProcess - Create a target specific InstrPostProcess.

Definition TargetRegistry.h:658

const char * getBackendName() const

getBackendName - Get the backend name.

Definition TargetRegistry.h:370

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

createMCRelocationInfo - Create a target specific MCRelocationInfo.

Definition TargetRegistry.h:605

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

createMCAsmParser - Create a target specific assembly parser.

Definition TargetRegistry.h:515

MCInstrAnalysis * createMCInstrAnalysis(const MCInstrInfo *Info) const

createMCInstrAnalysis - Create a MCInstrAnalysis implementation.

Definition TargetRegistry.h:438

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

createMCSubtargetInfo - Create a MCSubtargetInfo implementation.

Definition TargetRegistry.h:477

const char * getShortDescription() const

getShortDescription - Get a short description of the target.

Definition TargetRegistry.h:367

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

Definition TargetRegistry.h:213

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

Definition TargetRegistry.h:221

bool hasJIT() const

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

Definition TargetRegistry.h:377

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

Definition TargetRegistry.h:171

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

Definition TargetRegistry.h:164

MCTargetStreamer * createNullTargetStreamer(MCStreamer &S) const

Definition TargetRegistry.h:589

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

Definition TargetRegistry.h:183

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

createAsmPrinter - Create a target specific assembly printer pass.

Definition TargetRegistry.h:526

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

Definition TargetRegistry.h:177

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

Definition TargetRegistry.h:190

MCInstrInfo * createMCInstrInfo() const

createMCInstrInfo - Create a MCInstrInfo implementation.

Definition TargetRegistry.h:430

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

createInstrumentManager - Create a target specific InstrumentManager.

Definition TargetRegistry.h:669

Triple - Helper class for working with autoconf configuration names.

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.

Definition TargetRegistry.h:61

This is an optimization pass for GlobalISel generic memory operations.

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

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

LLVM_ABI MCStreamer * createAsmStreamer(MCContext &Ctx, std::unique_ptr< formatted_raw_ostream > OS, std::unique_ptr< 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,...

LLVM_ABI MCStreamer * createNullStreamer(MCContext &Ctx)

Create a dummy machine code streamer, which does nothing.

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

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

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

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

CodeGenOptLevel

Code generation optimization level.

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

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

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

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

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

RegisterAsmPrinter(Target &T)

Definition TargetRegistry.h:1368

RegisterMCAsmBackend(Target &T)

Definition TargetRegistry.h:1326

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

Definition TargetRegistry.h:1127

RegisterMCAsmInfo(Target &T)

Definition TargetRegistry.h:1107

RegisterMCAsmParser(Target &T)

Definition TargetRegistry.h:1347

RegisterMCCodeEmitter(Target &T)

Definition TargetRegistry.h:1388

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

Definition TargetRegistry.h:1224

RegisterMCInstrAnalysis(Target &T)

Definition TargetRegistry.h:1205

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

Definition TargetRegistry.h:1191

RegisterMCInstrInfo(Target &T)

Definition TargetRegistry.h:1174

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

Definition TargetRegistry.h:1160

RegisterMCObjectFileInfo(Target &T)

Definition TargetRegistry.h:1141

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

Definition TargetRegistry.h:1257

RegisterMCRegInfo(Target &T)

Definition TargetRegistry.h:1238

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

Definition TargetRegistry.h:1291

RegisterMCSubtargetInfo(Target &T)

Definition TargetRegistry.h:1271

RegisterTargetMachine(Target &T)

Definition TargetRegistry.h:1305

static bool getArchMatch(Triple::ArchType Arch)

Definition TargetRegistry.h:1093

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

Definition TargetRegistry.h:1087

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

lookupTarget - Lookup a target based on a target triple.

Definition TargetRegistry.h:742

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

RegisterMCSymbolizer - Register an MCSymbolizer implementation for the given target.

Definition TargetRegistry.h:1020

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

RegisterMCRegInfo - Register a MCRegisterInfo implementation for the given target.

Definition TargetRegistry.h:851

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

RegisterAsmPrinter - Register an AsmPrinter implementation for the given target.

Definition TargetRegistry.h:917

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

RegisterMCAsmBackend - Register a MCAsmBackend implementation for the given target.

Definition TargetRegistry.h:891

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

Definition TargetRegistry.h:973

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

RegisterMCCodeEmitter - Register a MCCodeEmitter implementation for the given target.

Definition TargetRegistry.h:957

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

RegisterMCAsmInfo - Register a MCAsmInfo implementation for the given target.

Definition TargetRegistry.h:805

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

RegisterMCSubtargetInfo - Register a MCSubtargetInfo implementation for the given target.

Definition TargetRegistry.h:864

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

Definition TargetRegistry.h:992

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

RegisterMCInstrAnalysis - Register a MCInstrAnalysis implementation for the given target.

Definition TargetRegistry.h:837

static void RegisterAsmStreamer(Target &T, Target::AsmStreamerCtorTy Fn)

Definition TargetRegistry.h:982

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

Definition TargetRegistry.h:969

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

Definition TargetRegistry.h:977

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

RegisterInstrPostProcess - Register an InstrPostProcess implementation for the given target.

Definition TargetRegistry.h:1047

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

RegisterMCDisassembler - Register a MCDisassembler implementation for the given target.

Definition TargetRegistry.h:930

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

RegisterMCAsmParser - Register a MCTargetAsmParser implementation for the given target.

Definition TargetRegistry.h:904

static LLVM_ABI 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.

Definition TargetRegistry.h:878

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

RegisterMCInstPrinter - Register a MCInstPrinter implementation for the given target.

Definition TargetRegistry.h:944

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

Definition TargetRegistry.h:961

static LLVM_ABI 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.

Definition TargetRegistry.h:831

static LLVM_ABI iterator_range< iterator > targets()

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

RegisterInstrumentManager - Register an InstrumentManager implementation for the given target.

Definition TargetRegistry.h:1062

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

RegisterCustomBehaviour - Register a CustomBehaviour implementation for the given target.

Definition TargetRegistry.h:1033

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

Definition TargetRegistry.h:965

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

Definition TargetRegistry.h:817

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

Definition TargetRegistry.h:986

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

RegisterMCRelocationInfo - Register an MCRelocationInfo implementation for the given target.

Definition TargetRegistry.h:1006

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