Local.h Source File (original) (raw)

14#ifndef LLVM_TRANSFORMS_UTILS_LOCAL_H

15#define LLVM_TRANSFORMS_UTILS_LOCAL_H

23#include

25namespace llvm {

64 bool DeleteDeadConditions = false,

100 std::function<void(Value *)> AboutToDeleteCallback =

101 std::function<void(Value *)>());

102

103

104

105

106

107

108

109

110

114 std::function<void(Value *)> AboutToDeleteCallback =

115 std::function<void(Value *)>());

116

117

118

119

120

124 std::function<void(Value *)> AboutToDeleteCallback =

125 std::function<void(Value *)>());

126

127

128

129

130

131

136

137

138

139

140

141

145

146

147

148

149

151

152

153

154

155

156

157

158

161

162

163

164

165

169

170

171

172

173

174

176

177

178

179

180

181

184

185

186

187

188

189

190

196

197

198

199

201

202

203

204

209 unsigned BonusInstThreshold = 1);

210

211

212

213

214

215

218 std::optionalBasicBlock::iterator AllocaPoint = std::nullopt);

219

220

221

222

224 PHINode *P, std::optionalBasicBlock::iterator AllocaPoint = std::nullopt);

225

226

227

228

229

230

231

232

235

236

237

238

239

240

241

242

243

244

250

251

258

259

260

261

262

264

265

267

268

269

270

271

272

273

275 DIBuilder &Builder);

276

277

278

280 StoreInst *SI,

281 DIBuilder &Builder);

282

283

284

286 LoadInst *LI, DIBuilder &Builder);

287

288

289

291 PHINode *LI, DIBuilder &Builder);

292

293

295

296

299 SmallVectorImpl<PHINode *> &InsertedPHIs);

300

301

302

303

304

305

307 DIBuilder &Builder, uint8_t DIExprFlags,

309

310

311

312

313

314

316 DIBuilder &Builder, int Offset = 0);

317

318

319

320

322

323

324

325

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

353 SmallVectorImpl<uint64_t> &Ops,

354 SmallVectorImpl<Value *> &AdditionalValues);

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

371 Instruction &DomPoint, DominatorTree &DT);

372

373

374

375

376

379 SmallVectorImpl<Value *> &PoisonedValues);

380

381

382

383

385

386

387

389 bool PreserveLCSSA = false,

390 DomTreeUpdater *DTU = nullptr,

391 MemorySSAUpdater *MSSAU = nullptr);

392

393

394

395

396

399 DomTreeUpdater *DTU = nullptr);

400

401

402

403

404

405

406

407

409 DomTreeUpdater *DTU = nullptr);

410

411

412

413

415 DomTreeUpdater *DTU = nullptr,

416 MemorySSAUpdater *MSSAU = nullptr);

417

418

419

420

421

422

423

425 bool DoesKMove);

426

427

428

429

431

432

433

435

436

437

438

440

441

442

444

445

446

448 DominatorTree &DT,

449 const BasicBlockEdge &Edge);

450

451

453 DominatorTree &DT,

454 const BasicBlock *BB);

455

456

458 DominatorTree &DT,

459 const Instruction *I);

460

461

462

464 Value *From, Value *To, DominatorTree &DT, const BasicBlockEdge &Edge,

465 function_ref<bool(const Use &U, const Value *To)> ShouldReplace);

466

467

468

470 Value *From, Value *To, DominatorTree &DT, const BasicBlock *BB,

471 function_ref<bool(const Use &U, const Value *To)> ShouldReplace);

472

473

474

476 Value *From, Value *To, DominatorTree &DT, const Instruction *I,

477 function_ref<bool(const Use &U, const Value *To)> ShouldReplace);

478

479

480

481

482

483

484

485

486

488 const TargetLibraryInfo &TLI);

489

490

491

492

493

495 LoadInst &NewLI);

496

497

498

499

500

502 MDNode *N, LoadInst &NewLI);

503

504

506

507

508

509

510

511

513 Instruction *InsertPt, BasicBlock *BB);

514

515

517 const Constant &C, Type &Ty);

518

519

520

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

540 bool MatchBitReversals,

541 SmallVectorImpl<Instruction *> &InsertedInsts);

542

543

544

545

546

547

548

549

550

553 const TargetLibraryInfo *TLI);

554

555

556

557

558

559

560

563

564

565

566

567

568

570

571

572

573

574

575

576

578

579

580

581

582

587

588#ifndef NDEBUG

589

590

592#endif

593

594

595

596

597

600

602

603

605

606

608};

609

610}

611

612#endif

ReachingDefInfo InstSet & ToRemove

MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL

static GCRegistry::Add< ShadowStackGC > C("shadow-stack", "Very portable GC for uncooperative code generators")

const AbstractManglingParser< Derived, Alloc >::OperatorInfo AbstractManglingParser< Derived, Alloc >::Ops[]

MachineInstr unsigned OpIdx

uint64_t IntrinsicInst * II

StandardInstrumentations SI(Mod->getContext(), Debug, VerifyEach)

static TableGen::Emitter::OptClass< SkeletonEmitter > X("gen-skeleton-class", "Generate example skeleton class")

an instruction to allocate memory on the stack

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

A cache of @llvm.assume calls within a function.

LLVM Basic Block Representation.

Conditional or Unconditional Branch instruction.

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

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

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

Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.

An instruction for reading from memory.

A templated base class for SmallPtrSet which provides the typesafe interface that is common across al...

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

An instruction for storing to memory.

Provides information about what library functions are available for the current target.

This pass provides access to the codegen interfaces that are needed for IR-level transformations.

LLVM Value Representation.

Value handle that is nullable, but tries to track the Value.

A nullable Value handle that is nullable.

Abstract Attribute helper functions.

This is an optimization pass for GlobalISel generic memory operations.

LLVM_ABI unsigned removeAllNonTerminatorAndEHPadInstructions(BasicBlock *BB)

Remove all instructions from a basic block other than its terminator and any present EH pad instructi...

LLVM_ABI bool RecursivelyDeleteTriviallyDeadInstructions(Value *V, const TargetLibraryInfo *TLI=nullptr, MemorySSAUpdater *MSSAU=nullptr, std::function< void(Value *)> AboutToDeleteCallback=std::function< void(Value *)>())

If the specified value is a trivially dead instruction, delete it.

LLVM_ABI BasicBlock * changeToInvokeAndSplitBasicBlock(CallInst *CI, BasicBlock *UnwindEdge, DomTreeUpdater *DTU=nullptr)

Convert the CallInst to InvokeInst with the specified unwind edge basic block.

LLVM_ABI bool ConstantFoldTerminator(BasicBlock *BB, bool DeleteDeadConditions=false, const TargetLibraryInfo *TLI=nullptr, DomTreeUpdater *DTU=nullptr)

If a terminator instruction is predicated on a constant value, convert it into an unconditional branc...

LLVM_ABI bool FlattenCFG(BasicBlock *BB, AAResults *AA=nullptr)

This function is used to flatten a CFG.

LLVM_ABI unsigned replaceDominatedUsesWithIf(Value *From, Value *To, DominatorTree &DT, const BasicBlockEdge &Edge, function_ref< bool(const Use &U, const Value *To)> ShouldReplace)

Replace each use of 'From' with 'To' if that use is dominated by the given edge and the callback Shou...

LLVM_ABI unsigned replaceNonLocalUsesWith(Instruction *From, Value *To)

LLVM_ABI void salvageDebugInfo(const MachineRegisterInfo &MRI, MachineInstr &MI)

Assuming the instruction MI is going to be deleted, attempt to salvage debug users of MI by writing t...

LLVM_ABI CallInst * changeToCall(InvokeInst *II, DomTreeUpdater *DTU=nullptr)

This function converts the specified invoke into a normal call.

LLVM_ABI void copyMetadataForLoad(LoadInst &Dest, const LoadInst &Source)

Copy the metadata from the source instruction to the destination (the replacement for the source inst...

LLVM_ABI void InsertDebugValueAtStoreLoc(DbgVariableRecord *DVR, StoreInst *SI, DIBuilder &Builder)

===------------------------------------------------------------------—===// Dbg Intrinsic utilities

LLVM_ABI void remapDebugVariable(ValueToValueMapTy &Mapping, Instruction *Inst)

Remap the operands of the debug records attached to Inst, and the operands of Inst itself if it's a d...

LLVM_ABI bool SimplifyInstructionsInBlock(BasicBlock *BB, const TargetLibraryInfo *TLI=nullptr)

Scan the specified basic block and try to simplify any instructions in it and recursively delete dead...

LLVM_ABI void insertDebugValuesForPHIs(BasicBlock *BB, SmallVectorImpl< PHINode * > &InsertedPHIs)

Propagate dbg.value intrinsics through the newly inserted PHIs.

LLVM_ABI bool handleUnreachableTerminator(Instruction *I, SmallVectorImpl< Value * > &PoisonedValues)

If a terminator in an unreachable basic block has an operand of type Instruction, transform it into p...

LLVM_ABI AllocaInst * DemoteRegToStack(Instruction &X, bool VolatileLoads=false, std::optional< BasicBlock::iterator > AllocaPoint=std::nullopt)

This function takes a virtual register computed by an Instruction and replaces it with a slot in the ...

Align getKnownAlignment(Value *V, const DataLayout &DL, const Instruction *CxtI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr)

Try to infer an alignment for the specified pointer.

Definition Local.h:252

LLVM_ABI bool isInstructionTriviallyDead(Instruction *I, const TargetLibraryInfo *TLI=nullptr)

Return true if the result produced by the instruction is not used, and the instruction will return.

LLVM_ABI AllocaInst * DemotePHIToStack(PHINode *P, std::optional< BasicBlock::iterator > AllocaPoint=std::nullopt)

This function takes a virtual register computed by a phi node and replaces it with a slot in the stac...

LLVM_ABI bool TryToSimplifyUncondBranchFromEmptyBlock(BasicBlock *BB, DomTreeUpdater *DTU=nullptr)

BB is known to contain an unconditional branch, and contains no instructions other than PHI nodes,...

LLVM_ABI bool recognizeBSwapOrBitReverseIdiom(Instruction *I, bool MatchBSwaps, bool MatchBitReversals, SmallVectorImpl< Instruction * > &InsertedInsts)

Try to match a bswap or bitreverse idiom.

LLVM_ABI Align getOrEnforceKnownAlignment(Value *V, MaybeAlign PrefAlign, const DataLayout &DL, const Instruction *CxtI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr)

Try to ensure that the alignment of V is at least PrefAlign bytes.

LLVM_ABI bool wouldInstructionBeTriviallyDeadOnUnusedPaths(Instruction *I, const TargetLibraryInfo *TLI=nullptr)

Return true if the result produced by the instruction has no side effects on any paths other than whe...

LLVM_ABI bool LowerDbgDeclare(Function &F)

Lowers dbg.declare records into appropriate set of dbg.value records.

LLVM_ABI DIExpression * getExpressionForConstant(DIBuilder &DIB, const Constant &C, Type &Ty)

Given a constant, create a debug information expression.

LLVM_ABI CallInst * createCallMatchingInvoke(InvokeInst *II)

Create a call that matches the invoke II in terms of arguments, attributes, debug information,...

LLVM_ABI void ConvertDebugDeclareToDebugValue(DbgVariableRecord *DVR, StoreInst *SI, DIBuilder &Builder)

Inserts a dbg.value record before a store to an alloca'd value that has an associated dbg....

LLVM_ABI Instruction * removeUnwindEdge(BasicBlock *BB, DomTreeUpdater *DTU=nullptr)

Replace 'BB's terminator with one that does not have an unwind successor block.

LLVM_ABI bool wouldInstructionBeTriviallyDead(const Instruction *I, const TargetLibraryInfo *TLI=nullptr)

Return true if the result produced by the instruction would have no side effects if it was not used.

LLVM_ABI void patchReplacementInstruction(Instruction *I, Value *Repl)

Patch the replacement so that it is not more restrictive than the value being replaced.

LLVM_ABI void salvageDebugInfoForDbgValues(Instruction &I, ArrayRef< DbgVariableRecord * > DPInsns)

Implementation of salvageDebugInfo, applying only to instructions in Insns, rather than all debug use...

LLVM_ABI unsigned replaceDominatedUsesWith(Value *From, Value *To, DominatorTree &DT, const BasicBlockEdge &Edge)

Replace each use of 'From' with 'To' if that use is dominated by the given edge.

LLVM_ABI unsigned changeToUnreachable(Instruction *I, bool PreserveLCSSA=false, DomTreeUpdater *DTU=nullptr, MemorySSAUpdater *MSSAU=nullptr)

Insert an unreachable instruction before the specified instruction, making it and the rest of the cod...

LLVM_ABI bool replaceAllDbgUsesWith(Instruction &From, Value &To, Instruction &DomPoint, DominatorTree &DT)

Point debug users of From to To or salvage them.

LLVM_ABI Value * salvageDebugInfoImpl(Instruction &I, uint64_t CurrentLocOps, SmallVectorImpl< uint64_t > &Ops, SmallVectorImpl< Value * > &AdditionalValues)

LLVM_ABI void combineMetadataForCSE(Instruction *K, const Instruction *J, bool DoesKMove)

Combine the metadata of two instructions so that K can replace J.

LLVM_ABI void dropDebugUsers(Instruction &I)

Remove the debug intrinsic instructions for the given instruction.

LLVM_ABI void MergeBasicBlockIntoOnlyPred(BasicBlock *BB, DomTreeUpdater *DTU=nullptr)

BB is a block with one predecessor and its predecessor is known to have one successor (BB!...

LLVM_ABI cl::opt< bool > RequireAndPreserveDomTree

This function is used to do simplification of a CFG.

LLVM_ABI bool replaceDbgUsesWithUndef(Instruction *I)

Replace all the uses of an SSA value in @llvm.dbg intrinsics with undef.

LLVM_ABI void hoistAllInstructionsInto(BasicBlock *DomBlock, Instruction *InsertPt, BasicBlock *BB)

Hoist all of the instructions in the IfBlock to the dominant block DomBlock, by moving its instructio...

LLVM_ABI void copyRangeMetadata(const DataLayout &DL, const LoadInst &OldLI, MDNode *N, LoadInst &NewLI)

Copy a range metadata node to a new load instruction.

LLVM_ABI void copyNonnullMetadata(const LoadInst &OldLI, MDNode *N, LoadInst &NewLI)

Copy a nonnull metadata node to a new load instruction.

LLVM_ABI bool canReplaceOperandWithVariable(const Instruction *I, unsigned OpIdx)

Given an instruction, is it legal to set operand OpIdx to a non-constant value?

LLVM_ABI void replaceDbgValueForAlloca(AllocaInst *AI, Value *NewAllocaAddress, DIBuilder &Builder, int Offset=0)

Replaces multiple dbg.value records when the alloca it describes is replaced with a new value.

LLVM_ABI Align tryEnforceAlignment(Value *V, Align PrefAlign, const DataLayout &DL)

If the specified pointer points to an object that we control, try to modify the object's alignment to...

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

LLVM_ABI bool RecursivelyDeleteTriviallyDeadInstructionsPermissive(SmallVectorImpl< WeakTrackingVH > &DeadInsts, const TargetLibraryInfo *TLI=nullptr, MemorySSAUpdater *MSSAU=nullptr, std::function< void(Value *)> AboutToDeleteCallback=std::function< void(Value *)>())

Same functionality as RecursivelyDeleteTriviallyDeadInstructions, but allow instructions that are not...

ValueMap< const Value *, WeakTrackingVH > ValueToValueMapTy

LLVM_ABI bool simplifyCFG(BasicBlock *BB, const TargetTransformInfo &TTI, DomTreeUpdater *DTU=nullptr, const SimplifyCFGOptions &Options={}, ArrayRef< WeakVH > LoopHeaders={})

LLVM_ABI void combineAAMetadata(Instruction *K, const Instruction *J)

Combine metadata of two instructions, where instruction J is a memory access that has been merged int...

LLVM_ABI bool RecursivelyDeleteDeadPHINode(PHINode *PN, const TargetLibraryInfo *TLI=nullptr, MemorySSAUpdater *MSSAU=nullptr)

If the specified value is an effectively dead PHI node, due to being a def-use chain of single-use no...

LLVM_ABI bool foldBranchToCommonDest(BranchInst *BI, llvm::DomTreeUpdater *DTU=nullptr, MemorySSAUpdater *MSSAU=nullptr, const TargetTransformInfo *TTI=nullptr, unsigned BonusInstThreshold=1)

If this basic block is ONLY a setcc and a branch, and if a predecessor branches to us and one of our ...

LLVM_ABI bool inferAttributesFromOthers(Function &F)

If we can infer one attribute from another on the declaration of a function, explicitly materialize t...

LLVM_ABI Value * invertCondition(Value *Condition)

Invert the given true/false value, possibly reusing an existing copy.

LLVM_ABI void maybeMarkSanitizerLibraryCallNoBuiltin(CallInst *CI, const TargetLibraryInfo *TLI)

Given a CallInst, check if it calls a string function known to CodeGen, and mark it with NoBuiltin if...

LLVM_ABI bool removeUnreachableBlocks(Function &F, DomTreeUpdater *DTU=nullptr, MemorySSAUpdater *MSSAU=nullptr)

Remove all blocks that can not be reached from the function's entry.

LLVM_ABI bool EliminateDuplicatePHINodes(BasicBlock *BB)

Check for and eliminate duplicate PHI nodes in this block.

LLVM_ABI bool callsGCLeafFunction(const CallBase *Call, const TargetLibraryInfo &TLI)

Return true if this call calls a gc leaf function.

LLVM_ABI bool replaceDbgDeclare(Value *Address, Value *NewAddress, DIBuilder &Builder, uint8_t DIExprFlags, int Offset)

Replaces dbg.declare record when the address it describes is replaced with a new value.

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

This struct is a compact representation of a valid (power of two) or undefined (0) alignment.

bool AllKnownNonNegative

Definition Local.h:598

std::optional< unsigned > Opcode

Opcode of merged instructions.

Definition Local.h:591

LLVM_ABI void mergeFlags(Instruction &I)

Merge in the no-wrap flags from I.

bool HasNUW

Definition Local.h:584

bool AllKnownNonZero

Definition Local.h:599

OverflowTracking()=default

bool IsDisjoint

Definition Local.h:586

bool HasNSW

Definition Local.h:585

LLVM_ABI void applyFlags(Instruction &I)

Apply the no-wrap flags to I if applicable.