FunctionComparator.cpp Source File (original) (raw)

43#include

44#include

45#include

46#include

48using namespace llvm;

50#define DEBUG_TYPE "functioncomparator"

53 if (L < R)

54 return -1;

55 if (L > R)

56 return 1;

57 return 0;

58}

61 if (L.value() < R.value())

62 return -1;

63 if (L.value() > R.value())

64 return 1;

65 return 0;

66}

69 if ((int)L < (int)R)

70 return -1;

71 if ((int)L > (int)R)

72 return 1;

73 return 0;

74}

77 if (int Res = cmpNumbers(L.getBitWidth(), R.getBitWidth()))

78 return Res;

79 if (L.ugt(R))

80 return 1;

81 if (R.ugt(L))

82 return -1;

83 return 0;

84}

88 if (int Res = cmpAPInts(L.getLower(), R.getLower()))

89 return Res;

90 return cmpAPInts(L.getUpper(), R.getUpper());

91}

96 const fltSemantics &SL = L.getSemantics(), &SR = R.getSemantics();

99 return Res;

102 return Res;

105 return Res;

108 return Res;

109 return cmpAPInts(L.bitcastToAPInt(), R.bitcastToAPInt());

110}

111

113

114 if (int Res = cmpNumbers(L.size(), R.size()))

115 return Res;

116

117

118

119 return std::clamp(L.compare(R), -1, 1);

120}

121

122int FunctionComparator::cmpAttrs(const AttributeList L,

123 const AttributeList R) const {

124 if (int Res = cmpNumbers(L.getNumAttrSets(), R.getNumAttrSets()))

125 return Res;

126

127 for (unsigned i : L.indexes()) {

132 for (; LI != LE && RI != RE; ++LI, ++RI) {

138

140 Type *TyR = RA.getValueAsType();

141 if (TyL && TyR) {

142 if (int Res = cmpTypes(TyL, TyR))

143 return Res;

144 continue;

145 }

146

147

148

150 return Res;

151 continue;

153 RA.isConstantRangeAttribute()) {

156

158 return Res;

159 continue;

161 RA.isConstantRangeListAttribute()) {

164

168 return Res;

169

170 for (const auto &[L, R] : zip(CRL, CRR))

172 return Res;

173 continue;

174 }

175 if (LA < RA)

176 return -1;

177 if (RA < LA)

178 return 1;

179 }

180 if (LI != LE)

181 return 1;

182 if (RI != RE)

183 return -1;

184 }

185 return 0;

186}

187

188int FunctionComparator::cmpMetadata(const Metadata *L,

190

191

192

193

194

195

198 if (MDStringL && MDStringR) {

199 if (MDStringL == MDStringR)

200 return 0;

201 return MDStringL->getString().compare(MDStringR->getString());

202 }

203 if (MDStringR)

204 return -1;

205 if (MDStringL)

206 return 1;

207

210 if (CL == CR)

211 return 0;

212 if (!CL)

213 return -1;

214 if (!CR)

215 return 1;

216 return cmpConstants(CL->getValue(), CR->getValue());

217}

218

219int FunctionComparator::cmpMDNode(const MDNode *L, const MDNode *R) const {

220 if (L == R)

221 return 0;

222 if (!L)

223 return -1;

224 if (!R)

225 return 1;

226

227

228

229

230

231

232 if (int Res = cmpNumbers(L->getNumOperands(), R->getNumOperands()))

233 return Res;

234 for (size_t I = 0; I < L->getNumOperands(); ++I)

235 if (int Res = cmpMetadata(L->getOperand(I), R->getOperand(I)))

236 return Res;

237 return 0;

238}

239

240int FunctionComparator::cmpInstMetadata(Instruction const *L,

242

243

244

246 L->getAllMetadataOtherThanDebugLoc(MDL);

247 R->getAllMetadataOtherThanDebugLoc(MDR);

249 return 1;

250 else if (MDL.size() < MDR.size())

251 return -1;

252 for (size_t I = 0, N = MDL.size(); I < N; ++I) {

253 auto const [KeyL, ML] = MDL[I];

254 auto const [KeyR, MR] = MDR[I];

255 if (int Res = cmpNumbers(KeyL, KeyR))

256 return Res;

257 if (int Res = cmpMDNode(ML, MR))

258 return Res;

259 }

260 return 0;

261}

262

263int FunctionComparator::cmpOperandBundlesSchema(const CallBase &LCS,

266

267 if (int Res =

269 return Res;

270

274

275 if (int Res = OBL.getTagName().compare(OBR.getTagName()))

276 return Res;

277

278 if (int Res = cmpNumbers(OBL.Inputs.size(), OBR.Inputs.size()))

279 return Res;

280 }

281

282 return 0;

283}

284

285

286

287

288

289

292 Type *TyL = L->getType();

293 Type *TyR = R->getType();

294

295

296

297

298 int TypesRes = cmpTypes(TyL, TyR);

299 if (TypesRes != 0) {

300

303 return -1;

304

305

306 return TypesRes;

307 }

310 return 1;

311 return TypesRes;

312 }

313

314

315

316 unsigned TyLWidth = 0;

317 unsigned TyRWidth = 0;

318

320 TyLWidth = VecTyL->getPrimitiveSizeInBits().getFixedValue();

322 TyRWidth = VecTyR->getPrimitiveSizeInBits().getFixedValue();

323

324 if (TyLWidth != TyRWidth)

325 return cmpNumbers(TyLWidth, TyRWidth);

326

327

328 if (!TyLWidth) {

331 if (PTyL && PTyR) {

334 if (int Res = cmpNumbers(AddrSpaceL, AddrSpaceR))

335 return Res;

336 }

337 if (PTyL)

338 return 1;

339 if (PTyR)

340 return -1;

341

342

343

344 return TypesRes;

345 }

346 }

347

348

349

350 if (L->isNullValue() && R->isNullValue())

351 return TypesRes;

352 if (L->isNullValue() && !R->isNullValue())

353 return 1;

354 if (!L->isNullValue() && R->isNullValue())

355 return -1;

356

359 if (GlobalValueL && GlobalValueR) {

361 }

362

363 if (int Res = cmpNumbers(L->getValueID(), R->getValueID()))

364 return Res;

365

368

369

370

371

372

373 return cmpMem(SeqL->getRawDataValues(), SeqR->getRawDataValues());

374 }

375

376 switch (L->getValueID()) {

377 case Value::UndefValueVal:

378 case Value::PoisonValueVal:

379 case Value::ConstantTokenNoneVal:

380 return TypesRes;

381 case Value::ConstantIntVal: {

385 }

386 case Value::ConstantFPVal: {

390 }

391 case Value::ConstantArrayVal: {

396 if (int Res = cmpNumbers(NumElementsL, NumElementsR))

397 return Res;

398 for (uint64_t i = 0; i < NumElementsL; ++i) {

401 return Res;

402 }

403 return 0;

404 }

405 case Value::ConstantStructVal: {

408 unsigned NumElementsL = cast(TyL)->getNumElements();

409 unsigned NumElementsR = cast(TyR)->getNumElements();

410 if (int Res = cmpNumbers(NumElementsL, NumElementsR))

411 return Res;

412 for (unsigned i = 0; i != NumElementsL; ++i) {

415 return Res;

416 }

417 return 0;

418 }

419 case Value::ConstantVectorVal: {

424 if (int Res = cmpNumbers(NumElementsL, NumElementsR))

425 return Res;

426 for (uint64_t i = 0; i < NumElementsL; ++i) {

429 return Res;

430 }

431 return 0;

432 }

433 case Value::ConstantExprVal: {

437 return Res;

438 unsigned NumOperandsL = LE->getNumOperands();

440 if (int Res = cmpNumbers(NumOperandsL, NumOperandsR))

441 return Res;

442 for (unsigned i = 0; i < NumOperandsL; ++i) {

445 return Res;

446 }

449 if (int Res = cmpTypes(GEPL->getSourceElementType(),

450 GEPR->getSourceElementType()))

451 return Res;

452 if (int Res = cmpNumbers(GEPL->getNoWrapFlags().getRaw(),

453 GEPR->getNoWrapFlags().getRaw()))

454 return Res;

455

456 std::optional InRangeL = GEPL->getInRange();

457 std::optional InRangeR = GEPR->getInRange();

458 if (InRangeL) {

459 if (!InRangeR)

460 return 1;

462 return Res;

463 } else if (InRangeR) {

464 return -1;

465 }

466 }

469 if (int Res =

470 cmpNumbers(OBOL->hasNoUnsignedWrap(), OBOR->hasNoUnsignedWrap()))

471 return Res;

472 if (int Res =

473 cmpNumbers(OBOL->hasNoSignedWrap(), OBOR->hasNoSignedWrap()))

474 return Res;

475 }

476 return 0;

477 }

478 case Value::BlockAddressVal: {

482 return Res;

484

485

489 if (LBB == RBB)

490 return 0;

492 if (&BB == LBB) {

494 return -1;

495 }

496 if (&BB == RBB)

497 return 1;

498 }

499 llvm_unreachable("Basic Block Address does not point to a basic block in "

500 "its function.");

501 return -1;

502 } else {

503

504

505

507

508

510 }

511 }

512 case Value::DSOLocalEquivalentVal: {

513

514

515

516

519 return cmpGlobalValues(LEquiv->getGlobalValue(), REquiv->getGlobalValue());

520 }

521 default:

522 LLVM_DEBUG(dbgs() << "Looking at valueID " << L->getValueID() << "\n");

524 return -1;

525 }

526}

527

529 uint64_t LNumber = GlobalNumbers->getNumber(L);

530 uint64_t RNumber = GlobalNumbers->getNumber(R);

532}

533

534

535

536

540

543 TyL = DL.getIntPtrType(TyL);

545 TyR = DL.getIntPtrType(TyR);

546

547 if (TyL == TyR)

548 return 0;

549

551 return Res;

552

554 default:

559

569 return 0;

570

572 assert(PTyL && PTyR && "Both types must be pointers here.");

574

580

583

584 for (unsigned i = 0, e = STyL->getNumElements(); i != e; ++i) {

586 return Res;

587 }

588 return 0;

589 }

590

596

599

601 return Res;

602

603 for (unsigned i = 0, e = FTyL->getNumParams(); i != e; ++i) {

605 return Res;

606 }

607 return 0;

608 }

609

613 if (STyL->getNumElements() != STyR->getNumElements())

614 return cmpNumbers(STyL->getNumElements(), STyR->getNumElements());

615 return cmpTypes(STyL->getElementType(), STyR->getElementType());

616 }

621 if (STyL->getElementCount().isScalable() !=

622 STyR->getElementCount().isScalable())

623 return cmpNumbers(STyL->getElementCount().isScalable(),

624 STyR->getElementCount().isScalable());

625 if (STyL->getElementCount() != STyR->getElementCount())

626 return cmpNumbers(STyL->getElementCount().getKnownMinValue(),

627 STyR->getElementCount().getKnownMinValue());

628 return cmpTypes(STyL->getElementType(), STyR->getElementType());

629 }

630 }

631}

632

633

634

635

636

639 bool &needToCmpOperands) const {

640 needToCmpOperands = true;

642 return Res;

643

644

645

646

647

648 if (int Res = cmpNumbers(L->getOpcode(), R->getOpcode()))

649 return Res;

650

652 needToCmpOperands = false;

654 if (int Res =

656 return Res;

657 return cmpGEPs(GEPL, GEPR);

658 }

659

660 if (int Res = cmpNumbers(L->getNumOperands(), R->getNumOperands()))

661 return Res;

662

663 if (int Res = cmpTypes(L->getType(), R->getType()))

664 return Res;

665

666 if (int Res = cmpNumbers(L->getRawSubclassOptionalData(),

667 R->getRawSubclassOptionalData()))

668 return Res;

669

670

671

672 for (unsigned i = 0, e = L->getNumOperands(); i != e; ++i) {

673 if (int Res =

674 cmpTypes(L->getOperand(i)->getType(), R->getOperand(i)->getType()))

675 return Res;

676 }

677

678

680 if (int Res = cmpTypes(AI->getAllocatedType(),

682 return Res;

684 }

687 return Res;

689 return Res;

690 if (int Res =

691 cmpOrderings(LI->getOrdering(), cast(R)->getOrdering()))

692 return Res;

693 if (int Res = cmpNumbers(LI->getSyncScopeID(),

695 return Res;

696 return cmpInstMetadata(L, R);

697 }

699 if (int Res =

701 return Res;

703 return Res;

704 if (int Res =

705 cmpOrderings(SI->getOrdering(), cast(R)->getOrdering()))

706 return Res;

709 }

714 if (int Res = cmpNumbers(CBL->getCallingConv(), CBR->getCallingConv()))

715 return Res;

716 if (int Res = cmpAttrs(CBL->getAttributes(), CBR->getAttributes()))

717 return Res;

718 if (int Res = cmpOperandBundlesSchema(*CBL, *CBR))

719 return Res;

721 if (int Res = cmpNumbers(CI->getTailCallKind(),

723 return Res;

724 return cmpMDNode(L->getMetadata(LLVMContext::MD_range),

725 R->getMetadata(LLVMContext::MD_range));

726 }

729 if (int Res = cmpConstants(LCase.getCaseValue(), RCase.getCaseValue()))

730 return Res;

731 return 0;

732 }

737 return Res;

738 for (size_t i = 0, e = LIndices.size(); i != e; ++i) {

739 if (int Res = cmpNumbers(LIndices[i], RIndices[i]))

740 return Res;

741 }

742 return 0;

743 }

748 return Res;

749 for (size_t i = 0, e = LIndices.size(); i != e; ++i) {

750 if (int Res = cmpNumbers(LIndices[i], RIndices[i]))

751 return Res;

752 }

753 }

755 if (int Res =

756 cmpOrderings(FI->getOrdering(), cast(R)->getOrdering()))

757 return Res;

758 return cmpNumbers(FI->getSyncScopeID(),

760 }

762 if (int Res = cmpNumbers(CXI->isVolatile(),

764 return Res;

765 if (int Res =

767 return Res;

768 if (int Res =

769 cmpOrderings(CXI->getSuccessOrdering(),

771 return Res;

772 if (int Res =

773 cmpOrderings(CXI->getFailureOrdering(),

775 return Res;

776 return cmpNumbers(CXI->getSyncScopeID(),

778 }

780 if (int Res = cmpNumbers(RMWI->getOperation(),

782 return Res;

783 if (int Res = cmpNumbers(RMWI->isVolatile(),

785 return Res;

786 if (int Res = cmpOrderings(RMWI->getOrdering(),

788 return Res;

789 return cmpNumbers(RMWI->getSyncScopeID(),

791 }

796 return Res;

797 for (size_t i = 0, e = LMask.size(); i != e; ++i) {

798 if (int Res = cmpNumbers(LMask[i], RMask[i]))

799 return Res;

800 }

801 }

804

805

806

807 for (unsigned i = 0, e = PNL->getNumIncomingValues(); i != e; ++i) {

808 if (int Res =

810 return Res;

811 }

812 }

813 return 0;

814}

815

816

817

818int FunctionComparator::cmpGEPs(const GEPOperator *GEPL,

822

824 return Res;

825

826

827

829 unsigned OffsetBitWidth = DL.getIndexSizeInBits(ASL);

830 APInt OffsetL(OffsetBitWidth, 0), OffsetR(OffsetBitWidth, 0);

833 return cmpAPInts(OffsetL, OffsetR);

834 if (int Res =

836 return Res;

837

839 return Res;

840

841 for (unsigned i = 0, e = GEPL->getNumOperands(); i != e; ++i) {

843 return Res;

844 }

845

846 return 0;

847}

848

849int FunctionComparator::cmpInlineAsm(const InlineAsm *L,

851

852

853 if (L == R)

854 return 0;

855 if (int Res = cmpTypes(L->getFunctionType(), R->getFunctionType()))

856 return Res;

857 if (int Res = cmpMem(L->getAsmString(), R->getAsmString()))

858 return Res;

859 if (int Res = cmpMem(L->getConstraintString(), R->getConstraintString()))

860 return Res;

861 if (int Res = cmpNumbers(L->hasSideEffects(), R->hasSideEffects()))

862 return Res;

863 if (int Res = cmpNumbers(L->isAlignStack(), R->isAlignStack()))

864 return Res;

865 if (int Res = cmpNumbers(L->getDialect(), R->getDialect()))

866 return Res;

867 assert(L->getFunctionType() != R->getFunctionType());

868 return 0;

869}

870

871

872

873

874

876

877 if (L == FnL) {

878 if (R == FnR)

879 return 0;

880 return -1;

881 }

882 if (R == FnR) {

883 if (L == FnL)

884 return 0;

885 return 1;

886 }

887

890 if (ConstL && ConstR) {

891 if (L == R)

892 return 0;

894 }

895

896 if (ConstL)

897 return 1;

898 if (ConstR)

899 return -1;

900

903 if (MetadataValueL && MetadataValueR) {

904 if (MetadataValueL == MetadataValueR)

905 return 0;

906

907 return cmpMetadata(MetadataValueL->getMetadata(),

909 }

910

911 if (MetadataValueL)

912 return 1;

913 if (MetadataValueR)

914 return -1;

915

918

919 if (InlineAsmL && InlineAsmR)

920 return cmpInlineAsm(InlineAsmL, InlineAsmR);

921 if (InlineAsmL)

922 return 1;

923 if (InlineAsmR)

924 return -1;

925

926 auto LeftSN = sn_mapL.insert(std::make_pair(L, sn_mapL.size())),

927 RightSN = sn_mapR.insert(std::make_pair(R, sn_mapR.size()));

928

929 return cmpNumbers(LeftSN.first->second, RightSN.first->second);

930}

931

932

937

938 do {

939 bool needToCmpOperands = true;

940 if (int Res = cmpOperations(&*InstL, &*InstR, needToCmpOperands))

941 return Res;

942 if (needToCmpOperands) {

943 assert(InstL->getNumOperands() == InstR->getNumOperands());

944

945 for (unsigned i = 0, e = InstL->getNumOperands(); i != e; ++i) {

946 Value *OpL = InstL->getOperand(i);

947 Value *OpR = InstR->getOperand(i);

948 if (int Res = cmpValues(OpL, OpR))

949 return Res;

950

952 }

953 }

954

955 ++InstL;

956 ++InstR;

957 } while (InstL != InstLE && InstR != InstRE);

958

959 if (InstL != InstLE && InstR == InstRE)

960 return 1;

961 if (InstL == InstLE && InstR != InstRE)

962 return -1;

963 return 0;

964}

965

967 if (int Res = cmpAttrs(FnL->getAttributes(), FnR->getAttributes()))

968 return Res;

969

971 return Res;

972

973 if (FnL->hasGC()) {

974 if (int Res = cmpMem(FnL->getGC(), FnR->getGC()))

975 return Res;

976 }

977

978 if (int Res = cmpNumbers(FnL->hasSection(), FnR->hasSection()))

979 return Res;

980

981 if (FnL->hasSection()) {

982 if (int Res = cmpMem(FnL->getSection(), FnR->getSection()))

983 return Res;

984 }

985

987 return Res;

988

989

990

991 if (int Res = cmpNumbers(FnL->getCallingConv(), FnR->getCallingConv()))

992 return Res;

993

994 if (int Res = cmpTypes(FnL->getFunctionType(), FnR->getFunctionType()))

995 return Res;

996

998 "Identically typed functions have different numbers of args!");

999

1000

1001

1003 ArgRI = FnR->arg_begin(),

1004 ArgLE = FnL->arg_end();

1005 ArgLI != ArgLE; ++ArgLI, ++ArgRI) {

1006 if (cmpValues(&*ArgLI, &*ArgRI) != 0)

1008 }

1009 return 0;

1010}

1011

1012

1015

1017 return Res;

1018

1019

1020

1021

1022

1025

1028

1029 VisitedBBs.insert(FnLBBs[0]);

1030 while (!FnLBBs.empty()) {

1033

1034 if (int Res = cmpValues(BBL, BBR))

1035 return Res;

1036

1038 return Res;

1039

1042

1044 for (unsigned i = 0, e = TermL->getNumSuccessors(); i != e; ++i) {

1046 continue;

1047

1050 }

1051 }

1052 return 0;

1053}

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

This file declares a class to represent arbitrary precision floating point values and provide a varie...

This file implements a class to represent arbitrary precision integral constant values and operations...

MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL

This file contains the simple types necessary to represent the attributes associated with functions a...

static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")

This file contains the declarations for the subclasses of Constant, which represent the different fla...

Module.h This file contains the declarations for the Module class.

SI optimize exec mask operations pre RA

This file defines the SmallPtrSet class.

This file defines the SmallVector class.

static unsigned getBitWidth(Type *Ty, const DataLayout &DL)

Returns the bitwidth of the given scalar or pointer type.

static LLVM_ABI ExponentType semanticsMinExponent(const fltSemantics &)

static LLVM_ABI unsigned int semanticsSizeInBits(const fltSemantics &)

static LLVM_ABI ExponentType semanticsMaxExponent(const fltSemantics &)

static LLVM_ABI unsigned int semanticsPrecision(const fltSemantics &)

Class for arbitrary precision integers.

an instruction to allocate memory on the stack

ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...

size_t size() const

size - Get the array size.

An instruction that atomically checks whether a specified value is in a memory location,...

an instruction that atomically reads a memory location, combines it with another value,...

This class holds the attributes for a particular argument, parameter, function, or return value.

const Attribute * iterator

LLVM_ABI iterator begin() const

LLVM_ABI iterator end() const

Functions, function parameters, and return types can have attributes to indicate how they should be t...

LLVM_ABI const ConstantRange & getRange() const

Returns the value of the range attribute.

LLVM_ABI bool isConstantRangeAttribute() const

Return true if the attribute is a ConstantRange attribute.

LLVM_ABI Attribute::AttrKind getKindAsEnum() const

Return the attribute's kind as an enum (Attribute::AttrKind).

LLVM_ABI ArrayRef< ConstantRange > getValueAsConstantRangeList() const

Return the attribute's value as a ConstantRange array.

LLVM_ABI bool isTypeAttribute() const

Return true if the attribute is a type attribute.

LLVM_ABI bool isConstantRangeListAttribute() const

Return true if the attribute is a ConstantRangeList attribute.

LLVM_ABI Type * getValueAsType() const

Return the attribute's value as a Type.

LLVM Basic Block Representation.

iterator begin()

Instruction iterator methods.

InstListType::const_iterator const_iterator

const Instruction * getTerminator() const LLVM_READONLY

Returns the terminator instruction if the block is well formed or null if the block is not well forme...

The address of a basic block.

Function * getFunction() const

BasicBlock * getBasicBlock() const

Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...

OperandBundleUse getOperandBundleAt(unsigned Index) const

Return the operand bundle at a specific index.

unsigned getNumOperandBundles() const

Return the number of operand bundles associated with this User.

This class represents a function call, abstracting a target machine's calling convention.

This class is the base class for the comparison instructions.

ConstantArray - Constant Array Declarations.

A constant value that is initialized with an expression using other constant values.

unsigned getOpcode() const

Return the opcode at the root of this constant expression.

This class represents a range of values.

Constant Vector Declarations.

This is an important base class in LLVM.

A parsed version of the target data layout string in and methods for querying it.

An instruction for ordering other memory operations.

LLVM_ABI int cmpBasicBlocks(const BasicBlock *BBL, const BasicBlock *BBR) const

Test whether two basic blocks have equivalent behaviour.

Definition FunctionComparator.cpp:933

LLVM_ABI int cmpConstantRanges(const ConstantRange &L, const ConstantRange &R) const

Definition FunctionComparator.cpp:86

LLVM_ABI int compareSignature() const

Compares the signature and other general attributes of the two functions.

Definition FunctionComparator.cpp:966

LLVM_ABI int cmpMem(StringRef L, StringRef R) const

Definition FunctionComparator.cpp:112

LLVM_ABI int compare()

Test whether the two functions have equivalent behaviour.

Definition FunctionComparator.cpp:1013

LLVM_ABI int cmpAPFloats(const APFloat &L, const APFloat &R) const

Definition FunctionComparator.cpp:93

LLVM_ABI int cmpTypes(Type *TyL, Type *TyR) const

cmpType - compares two types, defines total ordering among the types set.

Definition FunctionComparator.cpp:537

LLVM_ABI int cmpOperations(const Instruction *L, const Instruction *R, bool &needToCmpOperands) const

Compare two Instructions for equivalence, similar to Instruction::isSameOperationAs.

Definition FunctionComparator.cpp:637

LLVM_ABI int cmpNumbers(uint64_t L, uint64_t R) const

Definition FunctionComparator.cpp:52

LLVM_ABI int cmpAligns(Align L, Align R) const

Definition FunctionComparator.cpp:60

void beginCompare()

Start the comparison.

LLVM_ABI int cmpValues(const Value *L, const Value *R) const

Assign or look up previously assigned numbers for the two values, and return whether the numbers are ...

Definition FunctionComparator.cpp:875

LLVM_ABI int cmpGlobalValues(GlobalValue *L, GlobalValue *R) const

Compares two global values by number.

Definition FunctionComparator.cpp:528

LLVM_ABI int cmpConstants(const Constant *L, const Constant *R) const

Constants comparison.

Definition FunctionComparator.cpp:290

LLVM_ABI int cmpAPInts(const APInt &L, const APInt &R) const

Definition FunctionComparator.cpp:76

Class to represent function types.

unsigned getNumParams() const

Return the number of fixed parameters this function type requires.

Type * getParamType(unsigned i) const

Parameter type accessors.

Type * getReturnType() const

const DataLayout & getDataLayout() const

Get the data layout of the module this function belongs to.

const Argument * const_arg_iterator

LLVM_ABI Type * getSourceElementType() const

LLVM_ABI bool accumulateConstantOffset(const DataLayout &DL, APInt &Offset, function_ref< bool(Value &, APInt &)> ExternalAnalysis=nullptr) const

Accumulate the constant address offset of this GEP if possible.

unsigned getPointerAddressSpace() const

Method to return the address space of the pointer operand.

an instruction for type-safe pointer arithmetic to access elements of arrays and structs

Value * getPointerOperand()

This instruction inserts a struct field of array element value into an aggregate value.

LLVM_ABI unsigned getNumSuccessors() const LLVM_READONLY

Return the number of successors that this instruction has.

LLVM_ABI BasicBlock * getSuccessor(unsigned Idx) const LLVM_READONLY

Return the specified successor. This instruction must be a terminator.

unsigned getOpcode() const

Returns a member of one of the enums like Instruction::Add.

An instruction for reading from memory.

BasicBlock * getIncomingBlock(unsigned i) const

Return incoming basic block number i.

Class to represent pointers.

unsigned getAddressSpace() const

Return the address space of the Pointer type.

This instruction constructs a fixed permutation of two input vectors.

std::pair< iterator, bool > insert(PtrType Ptr)

Inserts Ptr if and only if there is no element in the container equal to Ptr.

SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.

void push_back(const T &Elt)

This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.

An instruction for storing to memory.

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

Class to represent struct types.

unsigned getNumElements() const

Random access to the elements.

Type * getElementType(unsigned N) const

The instances of the Type class are immutable: once they are created, they are never changed.

@ VoidTyID

type with no size

@ ScalableVectorTyID

Scalable SIMD vector type.

@ FloatTyID

32-bit floating point type

@ IntegerTyID

Arbitrary bit width integers.

@ FixedVectorTyID

Fixed width SIMD vector type.

@ DoubleTyID

64-bit floating point type

@ X86_FP80TyID

80-bit floating point type (X87)

@ PPC_FP128TyID

128-bit floating point type (two 64-bits, PowerPC)

@ FP128TyID

128-bit floating point type (112-bit significand)

LLVM_ABI bool isFirstClassType() const

Return true if the type is "first class", meaning it is a valid type for a Value.

TypeID getTypeID() const

Return the type id for the type.

Value * getOperand(unsigned i) const

unsigned getNumOperands() const

LLVM Value Representation.

Type * getType() const

All values are typed, get the type of this value.

#define llvm_unreachable(msg)

Marks that the current location is not supposed to be reachable.

This is an optimization pass for GlobalISel generic memory operations.

detail::zippy< detail::zip_shortest, T, U, Args... > zip(T &&t, U &&u, Args &&...args)

zip iterator for two or more iteratable types.

decltype(auto) dyn_cast(const From &Val)

dyn_cast - Return the argument parameter cast to the specified type.

LLVM_ABI raw_ostream & dbgs()

dbgs() - This returns a reference to a raw_ostream for debugging messages.

class LLVM_GSL_OWNER SmallVector

Forward declaration of SmallVector so that calculateSmallVectorDefaultInlinedElements can reference s...

AtomicOrdering

Atomic ordering for LLVM's memory model.

ArrayRef(const T &OneElt) -> ArrayRef< T >

decltype(auto) cast(const From &Val)

cast - Return the argument parameter cast to the specified type.

This struct is a compact representation of a valid (non-zero power of two) alignment.