Value.h Source File (original) (raw)

13#ifndef LLVM_IR_VALUE_H

14#define LLVM_IR_VALUE_H

25#include

26#include

27#include

29namespace llvm {

76 const unsigned char SubclassID;

77 unsigned char HasValueHandle : 1;

79protected:

87private:

93 unsigned short SubclassData;

95protected:

100

101

102

103

104

105

106

107

110

111

114 unsigned HasMetadata : 1;

117

118private:

120 Use *UseList = nullptr;

121

124

125 template

126 class use_iterator_impl {

127 friend class Value;

128

129 UseT *U;

130

131 explicit use_iterator_impl(UseT *u) : U(u) {}

132

133 public:

134 using iterator_category = std::forward_iterator_tag;

135 using value_type = UseT;

136 using difference_type = std::ptrdiff_t;

137 using pointer = value_type *;

138 using reference = value_type &;

139

140 use_iterator_impl() : U() {}

141

142 bool operator==(const use_iterator_impl &x) const { return U == x.U; }

143 bool operator!=(const use_iterator_impl &x) const { return operator== (x); }

144

145 use_iterator_impl &operator++() {

146 assert(U && "Cannot increment end iterator!");

147 U = U->getNext();

148 return *this;

149 }

150

151 use_iterator_impl operator++(int) {

152 auto tmp = *this;

153 ++*this;

154 return tmp;

155 }

156

157 UseT &operator*() const {

158 assert(U && "Cannot dereference end iterator!");

159 return *U;

160 }

161

162 UseT *operator->() const { return &operator*(); }

163

164 operator use_iterator_impl() const {

165 return use_iterator_impl(U);

166 }

167 };

168

169 template

170 class user_iterator_impl {

171 use_iterator_impl UI;

172 explicit user_iterator_impl(Use *U) : UI(U) {}

173 friend class Value;

174

175 public:

176 using iterator_category = std::forward_iterator_tag;

177 using value_type = UserTy *;

178 using difference_type = std::ptrdiff_t;

179 using pointer = value_type *;

180 using reference = value_type &;

181

182 user_iterator_impl() = default;

183

184 bool operator==(const user_iterator_impl &x) const { return UI == x.UI; }

185 bool operator!=(const user_iterator_impl &x) const { return operator== (x); }

186

187

188 bool atEnd() const { return *this == user_iterator_impl(); }

189

190 user_iterator_impl &operator++() {

191 ++UI;

192 return *this;

193 }

194

195 user_iterator_impl operator++(int) {

196 auto tmp = *this;

197 ++*this;

198 return tmp;

199 }

200

201

202 UserTy *operator*() const {

203 return UI->getUser();

204 }

205

206 UserTy *operator->() const { return operator*(); }

207

208 operator user_iterator_impl() const {

209 return user_iterator_impl(*UI);

210 }

211

212 Use &getUse() const { return *UI; }

213 };

214

215protected:

217

218

219

220

221

222

223 LLVM_ABI ~Value();

224

225public:

228

229

231

232

234

235

236

239 bool IsForDebug = false) const;

240

241

242

243

244

245

246

247

248

250 const Module *M = nullptr) const;

253

254

255

257

258

260

261

265

266private:

267 void destroyValueName();

268 enum class ReplaceMetadataUses { No, Yes };

269 void doRAUW(Value *New, ReplaceMetadataUses);

270 void setNameImpl(const Twine &Name);

271

272public:

273

274

275

276

277

279

280

281

282

283

284

286

287

288

289

290

291

293

295

296

297

298

299

300

302

303

304

305

306

308

309

310

311

312

315

316

317

318

319

320

322

323

324

325

326

327

328

329

330

331

332

334

335

336

338#ifndef NDEBUG

340#endif

341 }

342

343

345

348 return UseList == nullptr;

349 }

350

352

355

388

390

393

434

435

436

437

438

440

441

443

444

445

446

448

449

450

451

452

453

454

455

456

458

459

460

465

466

467

472

473

474

475

476

478

479

480

481

483

484

485

486

487

488

489

490

493 [](const Use *) { return true; });

494

495

497

498

500

501

502

503

505

506

507

508

509

511

512

515 U.addToList(&UseList);

516 }

517

518

519

520

521

522

523

525#define HANDLE_VALUE(Name) Name##Val,

526#include "llvm/IR/Value.def"

527

528

529#define HANDLE_CONSTANT_MARKER(Marker, Constant) Marker = Constant##Val,

530#include "llvm/IR/Value.def"

531 };

532

533

534

535

536

537

538

539

540

541

542

544 return SubclassID;

545 }

546

547

548

549

553

554

558

559

563

564

566

567

569

570protected:

571

572

573

574

575

578 return nullptr;

580 }

582

583

584

585

586

587

592

593

594

595

596

597

600

601

603

604

605

612

613

614

615

616

617

618

621

622

623

624

627

628

629

630

631

633

634

636

637

639

640

641

642

644

645public:

646

647

648

649

651

652

653

654

655

658 return const_cast<Value *>(

659 static_cast<const Value *>(this)->stripPointerCasts());

660 }

661

662

663

664

665

668 return const_cast<Value *>(

669 static_cast<const Value *>(this)->stripPointerCastsAndAliases());

670 }

671

672

673

674

675

676

679 return const_cast<Value *>(static_cast<const Value *>(this)

680 ->stripPointerCastsSameRepresentation());

681 }

682

683

684

685

686

687

688

691 return const_cast<Value *>(static_cast<const Value *>(this)

692 ->stripPointerCastsForAliasAnalysis());

693 }

694

695

696

697

698

701 return const_cast<Value *>(

702 static_cast<const Value *>(this)->stripInBoundsConstantOffsets());

703 }

704

705

706

707

708

709

710

711

712

713

714

715

716

717

718

719

720

721

722

723

724

725

726

727

728

729

730

731

732

733

734

735

736

737

740 bool AllowInvariantGroup = false,

742 nullptr,

743 bool LookThroughIntToPtr = false) const;

744

747 bool AllowInvariantGroup = false,

749 nullptr,

750 bool LookThroughIntToPtr = false) {

751 return const_cast<Value *>(

752 static_cast<const Value *>(this)->stripAndAccumulateConstantOffsets(

753 DL, Offset, AllowNonInbounds, AllowInvariantGroup, ExternalAnalysis,

754 LookThroughIntToPtr));

755 }

756

757

758

769

770

771

772

773

777 [](const Value *) {}) {

778 return const_cast<Value *>(

780 }

781

782

783

784 LLVM_ABI std::optional<int64_t>

786

787

788

789

790

792

793

794

795

796

797

798

799

800

801

803 bool &CanBeNull,

804 bool &CanBeFreed) const;

805

806

807

808

809

811

812

813

814

815

816

817

819 const BasicBlock *PredBB) const;

821 return const_cast<Value *>(

822 static_cast<const Value *>(this)->DoPHITranslation(CurBB, PredBB));

823 }

824

825

826

827

828

831

832

833

834

835

836

837

841

842

843

844

845

846 template void sortUseList(Compare Cmp);

847

848

850

851private:

852

853

854

855

856

857

858

859

860 template

861 static Use *mergeUseLists(Use *L, Use *R, Compare Cmp) {

862 Use *Merged;

864

865 while (true) {

866 if (!L) {

868 break;

869 }

870 if (!R) {

872 break;

873 }

874 if (Cmp(*R, *L)) {

877 R = R->Next;

878 } else {

881 L = L->Next;

882 }

883 }

884

885 return Merged;

886 }

887

888protected:

891};

892

894

895

896

897

898using unique_value = std::unique_ptr<Value, ValueDeleter>;

899

901 V.print(OS);

902 return OS;

903}

904

906 removeFromList();

907 Val = V;

908 if (V)

909 V->addUse(*this);

910}

911

916

921

923 if (!UseList || !UseList->Next)

924

925 return;

926

927

928

929

930

931

932 const unsigned MaxSlots = 32;

933 Use *Slots[MaxSlots];

934

935

936 Use *Next = UseList->Next;

937 UseList->Next = nullptr;

938 unsigned NumSlots = 1;

939 Slots[0] = UseList;

940

941

942 while (Next->Next) {

944 Next = Current->Next;

945

946

947 Current->Next = nullptr;

948

949

950 unsigned I;

951 for (I = 0; I < NumSlots; ++I) {

952 if (!Slots[I])

953 break;

954

955

956

957

958

959 Current = mergeUseLists(Slots[I], Current, Cmp);

960 Slots[I] = nullptr;

961 }

962

963 if (I == NumSlots) {

964 ++NumSlots;

965 assert(NumSlots <= MaxSlots && "Use list bigger than 2^32");

966 }

967

968

969 Slots[I] = Current;

970 }

971

972

973 assert(Next && "Expected one more Use");

974 assert( Next ->Next && "Expected only one Use");

975 UseList = Next;

976 for (unsigned I = 0; I < NumSlots; ++I)

977 if (Slots[I])

978

979

980 UseList = mergeUseLists(Slots[I], UseList, Cmp);

981

982

983 for (Use *I = UseList, **Prev = &UseList; I; I = I->Next) {

984 I->Prev = Prev;

985 Prev = &I->Next;

986 }

987}

988

989

990

991

994 static_assert(Value::ConstantFirstVal == 0,

995 "Val.getValueID() >= Value::ConstantFirstVal");

996 return Val.getValueID() <= Value::ConstantLastVal;

997 }

998};

999

1002 static_assert(Value::ConstantDataFirstVal == 0,

1003 "Val.getValueID() >= Value::ConstantDataFirstVal");

1004 return Val.getValueID() <= Value::ConstantDataLastVal;

1005 }

1006};

1007

1010 return Val.getValueID() >= Value::ConstantAggregateFirstVal &&

1011 Val.getValueID() <= Value::ConstantAggregateLastVal;

1012 }

1013};

1014

1017 return Val.getValueID() == Value::ArgumentVal;

1018 }

1019};

1020

1023 return Val.getValueID() == Value::InlineAsmVal;

1024 }

1025};

1026

1029 return Val.getValueID() >= Value::InstructionVal;

1030 }

1031};

1032

1035 return Val.getValueID() == Value::BasicBlockVal;

1036 }

1037};

1038

1041 return Val.getValueID() == Value::FunctionVal;

1042 }

1043};

1044

1047 return Val.getValueID() == Value::GlobalVariableVal;

1048 }

1049};

1050

1053 return Val.getValueID() == Value::GlobalAliasVal;

1054 }

1055};

1056

1059 return Val.getValueID() == Value::GlobalIFuncVal;

1060 }

1061};

1062

1068

1075

1076

1078

1079

1081 return reinterpret_cast<Value**>(Vals);

1082}

1083

1084template

1086#ifndef NDEBUG

1088 unwrap(*I);

1089#endif

1091 return reinterpret_cast<T**>(Vals);

1092}

1093

1097

1098}

1099

1100#endif

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

MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL

static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")

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

#define DEFINE_ISA_CONVERSION_FUNCTIONS(ty, ref)

This defines the Use class.

bool operator==(const MergedFunctionsInfo &LHS, const MergedFunctionsInfo &RHS)

Class for arbitrary precision integers.

This class represents an incoming formal argument to a Function.

LLVM Basic Block Representation.

Base class for aggregate constants (with operands).

Base class for constants with no operands.

This is an important base class in LLVM.

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

This is an important class for using LLVM in a threaded context.

Manage lifetime of a slot tracker for printing IR.

A Module instance is used to store all the information related to an LLVM module.

This class consists of common code factored out of the SmallVector class to reduce code duplication b...

StringMapEntry - This is used to represent one value that is inserted into a StringMap.

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

Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...

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

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

LLVM_ABI void set(Value *Val)

Definition Value.h:905

LLVM_ABI Value * operator=(Value *RHS)

Definition Value.h:912

LLVM Value Representation.

Definition Value.h:75

iterator_range< user_iterator > materialized_users()

Definition Value.h:420

Type * getType() const

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

Definition Value.h:256

Value * stripInBoundsOffsets(function_ref< void(const Value *)> Func=[](const Value *) {})

Definition Value.h:776

unsigned short getSubclassDataFromValue() const

Definition Value.h:889

const_use_iterator materialized_use_begin() const

Definition Value.h:360

static constexpr uint64_t MaximumAlignment

Definition Value.h:830

Value * stripPointerCasts()

Definition Value.h:657

unsigned IsUsedByMD

Definition Value.h:112

bool hasMetadata(StringRef Kind) const

Definition Value.h:609

user_iterator_impl< const User > const_user_iterator

Definition Value.h:392

const Value * stripAndAccumulateInBoundsConstantOffsets(const DataLayout &DL, APInt &Offset) const

This is a wrapper around stripAndAccumulateConstantOffsets with the in-bounds requirement set to fals...

Definition Value.h:759

user_iterator user_begin()

Definition Value.h:402

LLVM_ABI const Value * DoPHITranslation(const BasicBlock *CurBB, const BasicBlock *PredBB) const

Translate PHI node to its predecessor from the given basic block.

unsigned HasName

Definition Value.h:113

LLVM_ABI Value(Type *Ty, unsigned scid)

@ NumUserOperandsBits

Definition Value.h:108

iterator_range< use_iterator > materialized_uses()

Definition Value.h:374

LLVM_ABI void print(raw_ostream &O, bool IsForDebug=false) const

Implement operator<< on Value.

use_iterator_impl< const Use > const_use_iterator

Definition Value.h:354

bool hasMetadata() const

Return true if this value has any metadata attached to it.

Definition Value.h:602

unsigned char SubclassOptionalData

Hold subclass data that can be dropped.

Definition Value.h:85

iterator_range< const_use_iterator > uses() const

Definition Value.h:384

const_use_iterator use_begin() const

Definition Value.h:368

iterator_range< const_user_iterator > materialized_users() const

Definition Value.h:423

LLVM_ABI void reverseUseList()

Reverse the use-list.

const User * getUniqueUndroppableUser() const

Definition Value.h:469

LLVM_ABI void assertModuleIsMaterializedImpl() const

LLVM_ABI bool hasNUndroppableUsesOrMore(unsigned N) const

Return true if this value has N uses or more.

LLVM_ABI bool hasOneUser() const

Return true if there is exactly one user of this value.

LLVM_ABI const Value * stripPointerCastsAndAliases() const

Strip off pointer casts, all-zero GEPs, address space casts, and aliases.

void assertModuleIsMaterialized() const

Definition Value.h:337

friend class ValueHandleBase

Definition Value.h:123

LLVM_ABI void setMetadata(unsigned KindID, MDNode *Node)

Set a particular kind of metadata attachment.

unsigned getRawSubclassOptionalData() const

Return the raw optional flags value contained in this value.

Definition Value.h:550

LLVM_ABI void setName(const Twine &Name)

Change the name of the value.

LLVM_ABI const Value * stripInBoundsConstantOffsets() const

Strip off pointer casts and all-constant inbounds GEPs.

LLVM_ABI std::string getNameOrAsOperand() const

bool hasOneUse() const

Return true if there is exactly one use of this value.

Definition Value.h:439

LLVM_ABI ~Value()

Value's destructor should be virtual by design, but that would require that Value and all of its subc...

LLVM_ABI void replaceAllUsesWith(Value *V)

Change all uses of this to point to a new Value.

friend class ValueAsMetadata

Definition Value.h:122

LLVM_ABI void getAllMetadata(SmallVectorImpl< std::pair< unsigned, MDNode * > > &MDs) const

Appends all metadata attached to this value to MDs, sorting by KindID.

LLVM_ABI const Value * stripInBoundsOffsets(function_ref< void(const Value *)> Func=[](const Value *) {}) const

Strip off pointer casts and inbounds GEPs.

iterator_range< user_iterator > users()

Definition Value.h:426

use_iterator use_begin()

Definition Value.h:364

static LLVM_ABI void dropDroppableUse(Use &U)

Remove the droppable use U.

void sortUseList(Compare Cmp)

Sort the use-list.

Definition Value.h:922

User * user_back()

Definition Value.h:412

iterator_range< const_user_iterator > users() const

Definition Value.h:430

LLVM_ABI Align getPointerAlignment(const DataLayout &DL) const

Returns an alignment of the pointer value.

void clearSubclassOptionalData()

Clear the optional flags contained in this value.

Definition Value.h:555

unsigned getValueID() const

Return an ID for the concrete type of this object.

Definition Value.h:543

Value * stripPointerCastsAndAliases()

Definition Value.h:667

LLVM_ABI bool isUsedInBasicBlock(const BasicBlock *BB) const

Check if this value is used in the specified basic block.

Value * stripAndAccumulateInBoundsConstantOffsets(const DataLayout &DL, APInt &Offset)

Definition Value.h:764

const User * user_back() const

Definition Value.h:416

LLVM_ABI MDNode * getMetadataImpl(unsigned KindID) const

Get metadata for the given kind, if any.

bool materialized_use_empty() const

Definition Value.h:351

LLVM_ABI void printAsOperand(raw_ostream &O, bool PrintType=true, const Module *M=nullptr) const

Print the name of this Value out to the specified raw_ostream.

bool hasUseList() const

Check if this Value has a use-list.

Definition Value.h:344

Value * stripAndAccumulateConstantOffsets(const DataLayout &DL, APInt &Offset, bool AllowNonInbounds, bool AllowInvariantGroup=false, function_ref< bool(Value &Value, APInt &Offset)> ExternalAnalysis=nullptr, bool LookThroughIntToPtr=false)

Definition Value.h:745

bool isUsedByMetadata() const

Return true if there is metadata referencing this value.

Definition Value.h:568

LLVM_ABI bool hasNUsesOrMore(unsigned N) const

Return true if this value has N uses or more.

LLVM_ABI void dropDroppableUsesIn(User &Usr)

Remove every use of this value in User that can safely be removed.

use_iterator materialized_use_begin()

Definition Value.h:356

LLVM_ABI Use * getSingleUndroppableUse()

Return true if there is exactly one use of this value that cannot be dropped.

LLVM_ABI bool canBeFreed() const

Return true if the memory object referred to by V can by freed in the scope for which the SSA value d...

LLVM_ABI bool hasNUses(unsigned N) const

Return true if this Value has exactly N uses.

LLVM_ABI void replaceUsesWithIf(Value *New, llvm::function_ref< bool(Use &U)> ShouldReplace)

Go through the uses list for this definition and make each use point to "V" if the callback ShouldRep...

Value(const Value &)=delete

iterator_range< const_use_iterator > materialized_uses() const

Definition Value.h:377

use_iterator_impl< Use > use_iterator

Definition Value.h:353

LLVM_ABI void setValueName(ValueName *VN)

LLVM_ABI User * getUniqueUndroppableUser()

Return true if there is exactly one unique user of this value that cannot be dropped (that user can h...

LLVM_ABI const Value * stripAndAccumulateConstantOffsets(const DataLayout &DL, APInt &Offset, bool AllowNonInbounds, bool AllowInvariantGroup=false, function_ref< bool(Value &Value, APInt &Offset)> ExternalAnalysis=nullptr, bool LookThroughIntToPtr=false) const

Accumulate the constant offset this value has compared to a base pointer.

LLVM_ABI const Value * stripPointerCasts() const

Strip off pointer casts, all-zero GEPs and address space casts.

LLVM_ABI bool isSwiftError() const

Return true if this value is a swifterror value.

LLVM_ABI void deleteValue()

Delete a pointer to a generic Value.

LLVM_ABI ValueName * getValueName() const

LLVM_ABI const Value * stripPointerCastsSameRepresentation() const

Strip off pointer casts, all-zero GEPs and address space casts but ensures the representation of the ...

bool use_empty() const

Definition Value.h:346

LLVM_ABI bool eraseMetadata(unsigned KindID)

Erase all metadata attachments with the given kind.

unsigned HasMetadata

Definition Value.h:114

LLVM_ABI void addMetadata(unsigned KindID, MDNode &MD)

Add a metadata attachment.

LLVM_ABI void dropDroppableUses(llvm::function_ref< bool(const Use *)> ShouldDrop=[](const Use *) { return true;})

Remove every uses that can safely be removed.

user_iterator user_end()

Definition Value.h:410

bool hasSameSubclassOptionalData(const Value *V) const

Check the optional flags for equality.

Definition Value.h:560

LLVM_ABI void replaceUsesOutsideBlock(Value *V, BasicBlock *BB)

replaceUsesOutsideBlock - Go through the uses list for this definition and make each use point to "V"...

void addUse(Use &U)

This method should only be used by the Use class.

Definition Value.h:513

void setValueSubclassData(unsigned short D)

Definition Value.h:890

LLVM_ABI void eraseMetadataIf(function_ref< bool(unsigned, MDNode *)> Pred)

Erase all metadata attachments matching the given predicate.

Value * DoPHITranslation(const BasicBlock *CurBB, const BasicBlock *PredBB)

Definition Value.h:820

LLVM_ABI LLVMContext & getContext() const

All values hold a context through their type.

static constexpr unsigned MaxAlignmentExponent

The maximum alignment for instructions.

Definition Value.h:829

bool hasValueHandle() const

Return true if there is a value handle associated with this value.

Definition Value.h:565

unsigned NumUserOperands

Definition Value.h:109

LLVM_ABI unsigned getNumUses() const

This method computes the number of uses of this Value.

Value & operator=(const Value &)=delete

unsigned HasHungOffUses

Definition Value.h:115

iterator_range< use_iterator > uses()

Definition Value.h:380

void mutateType(Type *Ty)

Mutate the type of this Value to be of the specified type.

Definition Value.h:838

const_use_iterator use_end() const

Definition Value.h:373

Value * stripPointerCastsForAliasAnalysis()

Definition Value.h:690

LLVM_ABI std::optional< int64_t > getPointerOffsetFrom(const Value *Other, const DataLayout &DL) const

If this ptr is provably equal to Other plus a constant offset, return that offset in bytes.

bool hasMetadata(unsigned KindID) const

Return true if this value has the given type of metadata attached.

Definition Value.h:606

Value * stripInBoundsConstantOffsets()

Definition Value.h:700

const Use * getSingleUndroppableUse() const

Definition Value.h:462

user_iterator_impl< User > user_iterator

Definition Value.h:391

user_iterator materialized_user_begin()

Definition Value.h:394

LLVM_ABI uint64_t getPointerDereferenceableBytes(const DataLayout &DL, bool &CanBeNull, bool &CanBeFreed) const

Returns the number of bytes known to be dereferenceable for the pointer value.

LLVM_ABI void clearMetadata()

Erase all metadata attached to this Value.

use_iterator use_end()

Definition Value.h:372

bool hasName() const

Definition Value.h:262

LLVM_ABI StringRef getName() const

Return a constant reference to the value's name.

LLVM_ABI void replaceNonMetadataUsesWith(Value *V)

Change non-metadata uses of this to point to a new Value.

Value * stripPointerCastsSameRepresentation()

Definition Value.h:678

unsigned HasDescriptor

Definition Value.h:116

const_user_iterator materialized_user_begin() const

Definition Value.h:398

LLVM_ABI void takeName(Value *V)

Transfer the name from V to this value.

const_user_iterator user_end() const

Definition Value.h:411

MDNode * getMetadata(unsigned KindID) const

Get the current metadata attachments for the given kind, if any.

Definition Value.h:576

bool user_empty() const

Definition Value.h:389

LLVM_ABI bool hasNUndroppableUses(unsigned N) const

Return true if there this value.

ValueTy

Concrete subclass of this.

Definition Value.h:524

LLVM_ABI const Value * stripPointerCastsForAliasAnalysis() const

Strip off pointer casts, all-zero GEPs, single-argument phi nodes and invariant group info.

LLVM_ABI void dump() const

Support for debugging, callable in GDB: V->dump()

const_user_iterator user_begin() const

Definition Value.h:406

An efficient, type-erasing, non-owning reference to a callable.

A range adaptor for a pair of iterators.

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

struct LLVMOpaqueValue * LLVMValueRef

Represents an individual value in LLVM IR.

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

NodeAddr< UseNode * > Use

This is an optimization pass for GlobalISel generic memory operations.

FunctionAddr VTableAddr Value

StringMapEntry< Value * > ValueName

Definition Value.h:56

iterator_range< T > make_range(T x, T y)

Convenience function for iterating over sub-ranges.

bool hasSingleElement(ContainerTy &&C)

Returns true if the given container only contains a single element.

std::unique_ptr< Value, ValueDeleter > unique_value

Use this instead of std::unique_ptr or std::unique_ptr.

Definition Value.h:898

bool isa(const From &Val)

isa - Return true if the parameter to the template is an instance of one of the template type argu...

Attribute unwrap(LLVMAttributeRef Attr)

FunctionAddr VTableAddr Next

raw_ostream & operator<<(raw_ostream &OS, const APFixedPoint &FX)

LLVMAttributeRef wrap(Attribute Attr)

void operator()(Value *V)

Definition Value.h:893