| /freebsd/contrib/llvm-project/llvm/include/llvm/Transforms/Scalar/ |
| H A D | ADCE.h | 1 //===- ADCE.h - Aggressive dead code elimination ----------------*- C++ -*-===//
9 // This file provides the interface for the Aggressive Dead Code Elimination
10 // pass. This pass optimistically assumes that all instructions are dead until
11 // proven otherwise, allowing it to eliminate dead computations that other DCE
25 /// A DCE pass that assumes instructions are dead until proven otherwise.
27 /// This pass eliminates dead code by optimistically assuming that all
28 /// instructions are dead until proven otherwise. This allows it to eliminate
29 /// dead computations that other DCE passes do not catch, particularly involving
|
| H A D | BDCE.h | 1 //===---- BDCE.cpp - Bit-tracking dead code elimination ---------*- C++ -*-===//
9 // This file implements the Bit-Tracking Dead Code Elimination pass. Some
11 // We track these dead bits and remove instructions that compute only these
12 // dead bits.
25 // The Bit-Tracking Dead Code Elimination pass.
|
| H A D | DCE.h | 1 //===- DCE.h - Dead code elimination ----------------------------*- C++ -*-===//
9 // This file provides the interface for the Dead Code Elimination pass.
22 /// Basic Dead Code Elimination pass.
|
| /freebsd/contrib/llvm-project/llvm/include/llvm/Transforms/IPO/ |
| H A D | DeadArgumentElimination.h | 1 //===- DeadArgumentElimination.h - Eliminate Dead Args ----------*- C++ -*-===//
9 // This pass deletes dead arguments from internal functions. Dead argument
10 // elimination removes arguments which are directly dead, as well as arguments
11 // only passed into function calls as dead arguments of other functions. This
12 // pass also deletes dead return values in a similar way.
15 // interprocedural passes, which add possibly-dead arguments or return values.
37 /// Eliminate dead arguments (and return values) from functions.
70 /// either alive or maybe alive. We don't mark anything explicitly dead (even
72 /// (in Uses) will never be marked alive and will thus become dead in the end.
119 /// This allows this pass to do double-duty as the dead arg hacking pass
|
| /freebsd/contrib/llvm-project/llvm/lib/CodeGen/ |
| H A D | DeadMachineInstructionElim.cpp | 1 //===- DeadMachineInstructionElim.cpp - Remove dead machine instructions --===//
9 // This is an extremely simple MachineInstr-level dead-code-elimination pass.
27 #define DEBUG_TYPE "dead-mi-elimination"
29 STATISTIC(NumDeletes, "Number of dead instructions deleted");
80 "Remove dead machine instructions", false, false)
110 assert(U.isUndef() && "'Undef' use on a 'dead' register is found!"); in isDead()
122 // If there are no defs with uses, the instruction is dead. in isDead()
143 // more likely that chains of dependent but ultimately dead instructions will in eliminateDeadMI()
148 // Now scan the instructions and delete dead ones, tracking physreg in eliminateDeadMI()
151 // If the instruction is dead, delete it! in eliminateDeadMI()
|
| H A D | LiveRangeEdit.cpp | 190 // DestReg of the cloned instruction cannot be Dead. Set isDead of DestReg in rematerializeAt()
208 SmallVectorImpl<MachineInstr*> &Dead) { in foldAsLoad() argument
261 Dead.push_back(DefMI); in foldAsLoad()
284 assert(MI->allDefsAreDead() && "Def isn't really dead"); in eliminateDeadDef()
290 LLVM_DEBUG(dbgs() << "Won't delete dead bundled inst: " << Idx << '\t' in eliminateDeadDef()
308 LLVM_DEBUG(dbgs() << "Deleting dead def " << Idx << '\t' << *MI); in eliminateDeadDef()
317 // otherwise we could leave some dead defs in the code. This case is in eliminateDeadDef()
327 // an empty live-range. It happens when it is dead, but in eliminateDeadDef()
437 void LiveRangeEdit::eliminateDeadDefs(SmallVectorImpl<MachineInstr *> &Dead, in eliminateDeadDefs() argument
442 // Erase all dead defs. in eliminateDeadDefs()
[all …]
|
| /freebsd/contrib/llvm-project/llvm/lib/Transforms/Scalar/ |
| H A D | DCE.cpp | 1 //===- DCE.cpp - Code to perform dead code elimination --------------------===//
9 // This file implements dead inst elimination and dead code elimination.
11 // Dead Inst Elimination performs a single pass over the function removing
12 // instructions that are obviously dead. Dead Code Elimination is similar, but
14 // they are newly dead.
66 // dead as we go.
74 // If the operand is an instruction that became dead as we nulled out the in run()
75 // operand, and if it is 'trivially' dead, delet in run()
[all...] |
| H A D | BDCE.cpp | 1 //===---- BDCE.cpp - Bit-tracking dead code elimination -------------------===//
9 // This file implements the Bit-Tracking Dead Code Elimination pass. Some
11 // We track these dead bits and remove instructions that compute only these
12 // dead bits. We also simplify sext that generates unused extension bits,
37 STATISTIC(NumSimplified, "Number of instructions trivialized (dead bits)");
41 /// If an instruction is trivialized (dead), then the chain of users of that
69 // readnone function is always dead (and so we can stop walking the use/def in clearAssumptionsOfUsers()
106 // Remove instructions that are dead, either because they were not reached in bitTrackingDCE()
167 // DemandedBits only detects dead integer uses. in bitTrackingDCE()
177 LLVM_DEBUG(dbgs() << "BDCE: Trivializing: " << U << " (all bits dead)\n"); in bitTrackingDCE()
|
| H A D | LoopSimplifyCFG.cpp | 172 PrintOutVector("Dead blocks from the original loop:", DeadLoopBlocks); in dump()
174 PrintOutVector("Dead exit blocks:", DeadExitBlocks); in dump()
219 // Collect live and dead loop blocks and exits. in analyze()
224 // If a loop block wasn't marked as live so far, then it's dead. in analyze()
250 // Amount of dead and live loop blocks should match the total number of in analyze()
255 // Now, all exit blocks that are not marked as live are dead, if all their in analyze()
322 /// We cannot simply remove edge from the loop to dead exit because in this
342 /// Doing so, we preserve static reachibility of all dead exits and can later
345 // If no dead exits, nothing to do. in handleDeadExits()
350 // dead exits. in handleDeadExits()
[all …]
|
| H A D | DeadStoreElimination.cpp | 1 //===- DeadStoreElimination.cpp - MemorySSA Backed Dead Store Elimination -===//
9 // The code below implements dead store elimination using MemorySSA. It uses
96 STATISTIC(NumCompletePartials, "Number of stores dead by later partials");
122 "dead store elimination (default = 150)"));
273 /// 'OW_PartialEarlierWithFullLater' means that a dead (big) store was
288 // dead store. in isPartialOverwrite()
323 // |--- dead 1 ---| |--- dead 2 ---| in isPartialOverwrite()
346 // Check for a dead store which writes to all the memory locations that in isPartialOverwrite()
351 LLVM_DEBUG(dbgs() << "DSE: Partial overwrite a dead load [" << DeadOff in isPartialOverwrite()
360 // dead store. in isPartialOverwrite()
[all …]
|
| H A D | ADCE.cpp | 1 //===- ADCE.cpp - Code to perform dead code elimination -------------------===//
9 // This file implements the Aggressive Dead Code Elimination pass. This pass
10 // optimistically assumes that all instructions are dead until proven otherwise,
11 // allowing it to eliminate dead computations that other DCE passes do not
84 /// Information about basic blocks relevant to dead code elimination.
179 /// Analyze dead branches to find those whose branches are the sources
189 /// dead terminators and rewrite the control flow graph to remove them.
325 // Build initial collection of blocks with dead terminators in initialize()
477 dbgs() << "dead terminator blocks:\n"; in markLiveBranchesFromControlDependences()
485 // which currently have dead terminators that are control in markLiveBranchesFromControlDependences()
[all …]
|
| /freebsd/contrib/llvm-project/llvm/lib/Target/AArch64/ |
| H A D | AArch64DeadRegisterDefinitionsPass.cpp | 1 //==-- AArch64DeadRegisterDefinitions.cpp - Replace dead defs w/ zero reg --==//
8 /// \file When allowed by the instruction, replace a dead definition of a GPR
28 #define DEBUG_TYPE "aarch64-dead-defs"
30 STATISTIC(NumDeadDefsReplaced, "Number of dead definitions replaced");
32 #define AARCH64_DEAD_REG_DEF_NAME "AArch64 Dead register definitions"
61 INITIALIZE_PASS(AArch64DeadRegisterDefinitions, "aarch64-dead-defs",
126 // dead def it uses a frame index which might expand into a multi in processMachineBasicBlock()
152 // zero before register allocation. So we just check for dead vreg defs. in processMachineBasicBlock()
157 LLVM_DEBUG(dbgs() << " Dead def operand #" << I << " in:\n "; in processMachineBasicBlock()
183 // Only replace one dead register, see check for zero register above. in processMachineBasicBlock()
[all …]
|
| /freebsd/contrib/llvm-project/llvm/lib/Transforms/IPO/ |
| H A D | StripDeadPrototypes.cpp | 10 // dead declarations and removes them. Dead declarations are declarations of
23 #define DEBUG_TYPE "strip-dead-prototypes"
25 STATISTIC(NumDeadPrototypes, "Number of dead prototypes removed");
30 // Erase dead function prototypes. in stripDeadPrototypes()
40 // Erase dead global var prototypes. in stripDeadPrototypes()
|
| H A D | DeadArgumentElimination.cpp | 1 //===- DeadArgumentElimination.cpp - Eliminate dead arguments -------------===//
9 // This pass deletes dead arguments from internal functions. Dead argument
10 // elimination removes arguments which are directly dead, as well as arguments
11 // only passed into function calls as dead arguments of other functions. This
12 // pass also deletes dead return values in a similar way.
15 // interprocedural passes, which add possibly-dead arguments or return values.
64 /// The dead argument elimination pass.
98 INITIALIZE_PASS(DAE, "deadargelim", "Dead Argument Elimination", false, false)
102 /// The DeadArgumentHacking pass, same as dead argument elimination, but deletes
117 "Dead Argument Hacking (BUGPOINT USE ONLY; DO NOT USE)", false,
[all …]
|
| /freebsd/contrib/bmake/unit-tests/ |
| H A D | suff-lookup.exp | 6 Adding suffix ".dead-end"
23 defining transformation from `.dead-end' to `.short'
24 inserting ".dead-end" (6) at end of list
26 transformation .dead-end.short complete
41 Adding suffix ".dead-end"
42 inserting ".dead-end" (6) at end of list
|
| H A D | suff-lookup.mk | 17 .SUFFIXES: .short .sho .dead-end
31 .dead-end.short:
40 .SUFFIXES: .c .cc .ccc .short .sho .dead-end
|
| /freebsd/contrib/llvm-project/llvm/lib/Target/BPF/ |
| H A D | BPFMIChecking.cpp | 67 // Make sure all Defs of XADD are dead, meaning any result of XADD insn is not
72 // dead info. If we rely on the generic MachineInstr::allDefsAreDead, then we
104 // implicit killed $r9, implicit-def dead $r9
106 // Even though w9 is not marked as Dead, the parent register r9 is marked as
107 // Dead correctly, and it is safe to use such information or our purpose.
125 // It is a GPR32 live Def, we are unsure whether it is really dead due to in hasLiveDefs()
132 // Record any GPR64 dead Def as some unmarked GPR32 could be alias of its in hasLiveDefs()
142 // No GPR64 dead Def, so all those GPR32 live Def can't have alias, therefore in hasLiveDefs()
147 // Otherwise, return true if any aliased SuperReg of GPR32 is not dead. in hasLiveDefs()
|
| /freebsd/contrib/llvm-project/llvm/lib/Analysis/ |
| H A D | DemandedBits.cpp | 181 // If the shift is nuw/nsw, then the high bits are not dead in determineLiveOperandBits()
198 // If the shift is exact, then the low bits are not dead in determineLiveOperandBits()
218 // If the shift is exact, then the low bits are not dead in determineLiveOperandBits()
229 // other operand are dead (unless they're both zero, in which in determineLiveOperandBits()
230 // case they can't both be dead, so just mark the LHS bits as in determineLiveOperandBits()
231 // dead). in determineLiveOperandBits()
242 // other operand are dead (unless they're both one, in which in determineLiveOperandBits()
243 // case they can't both be dead, so just mark the LHS bits as in determineLiveOperandBits()
244 // dead). in determineLiveOperandBits()
329 // check isAlwaysLive on every instruction when searching for dead in performAnalysis()
[all …]
|
| /freebsd/contrib/llvm-project/llvm/lib/Target/Hexagon/ |
| H A D | RDFDeadCode.cpp | 9 // RDF-based generic dead code elimination.
114 // Traverse the DFG and collect the set dead RefNodes and the set of
115 // dead instructions. Return "true" if any of these sets is non-empty,
118 // This function works by first finding all live nodes. The dead nodes in collect()
121 // Assume that all nodes are dead. Identify instructions which must be in collect()
169 dbgs() << "Dead instr: " << PrintNode<InstrNode*>(IA, DFG) << "\n"; in collect()
220 dbgs() << "Removing dead ref nodes:\n"; in erase()
230 // Now, remove all dead instruction nodes. in erase()
|
| H A D | RDFDeadCode.h | 9 // RDF-based generic dead code elimination.
17 // all post-increment instructions to see if the address update is dead
20 // dead defs from the updating instructions and the nodes corresponding
21 // to the dead instructions.
|
| /freebsd/contrib/llvm-project/llvm/include/llvm/CodeGen/ |
| H A D | LiveRangeEdit.h | 51 /// Called immediately before erasing a dead machine instruction.
81 /// DeadRemats - The saved instructions which have already been dead after
98 bool foldAsLoad(LiveInterval *LI, SmallVectorImpl<MachineInstr *> &Dead);
127 /// original reg and are dead after remat.
157 /// dead after rematerialization, we still want to keep it for following
233 /// eliminateDeadDefs - Try to delete machine instructions that are now dead
235 /// and further dead efs to be eliminated.
239 void eliminateDeadDefs(SmallVectorImpl<MachineInstr *> &Dead,
|
| H A D | LiveIntervals.h | 174 /// uses, and it doesn't remove dead defs.
175 /// Dead PHIDef values are marked as unused. New dead machine instructions
176 /// are added to the dead vector. Returns true if the interval may have been
179 SmallVectorImpl<MachineInstr *> *dead = nullptr);
182 /// shrinkToUses(LiveInterval *li, SmallVectorImpl<MachineInstr*> *dead)
464 /// Walk the values in \p LI and check for dead values:
465 /// - Dead PHIDef values are marked as unused.
466 /// - Dead operands are marked as such.
467 /// - Completely dead machine instructions are added to the \p dead vector
472 SmallVectorImpl<MachineInstr *> *dead);
|
| /freebsd/contrib/llvm-project/llvm/lib/Target/LoongArch/ |
| H A D | LoongArchDeadRegisterDefinitions.cpp | 1 //=== LoongArchDeadRegisterDefinitions.cpp - Replace dead defs w/ zero reg ===//
24 #define DEBUG_TYPE "loongarch-dead-defs"
25 #define LoongArch_DEAD_REG_DEF_NAME "LoongArch Dead register definitions"
27 STATISTIC(NumDeadDefsReplaced, "Number of dead definitions replaced");
89 LLVM_DEBUG(dbgs() << " Dead def operand #" << I << " in:\n "; in runOnMachineFunction()
|
| /freebsd/contrib/llvm-project/llvm/lib/Target/RISCV/ |
| H A D | RISCVDeadRegisterDefinitions.cpp | 1 //===- RISCVDeadRegisterDefinitions.cpp - Replace dead defs w/ zero reg --===//
24 #define DEBUG_TYPE "riscv-dead-defs"
25 #define RISCV_DEAD_REG_DEF_NAME "RISC-V Dead register definitions"
27 STATISTIC(NumDeadDefsReplaced, "Number of dead definitions replaced");
94 LLVM_DEBUG(dbgs() << " Dead def operand #" << I << " in:\n "; in runOnMachineFunction()
|
| /freebsd/contrib/llvm-project/lld/MachO/ |
| H A D | MapFile.cpp | 11 // The contents (typically symbols) are listed in address order. Dead-stripped
25 // # Dead Stripped Symbols:
27 // <<dead>> 0x00000001 [ 1] _foo
72 // Gather the dead symbols. We don't have to bother with the live ones in gatherMapInfo()
88 // Gather all the cstrings (both live and dead). A CString(Output)Section in gatherMapInfo()
261 os << "# Dead Stripped Symbols:\n"; in writeMapFile()
265 os << format("<<dead>>\t0x%08llX\t[%3u] %s\n", getSymSizeForMap(sym), in writeMapFile()
270 os << format("<<dead>>\t0x%08zX\t[%3u] literal string: ", in writeMapFile()
|