| /src/external/apache2/llvm/dist/llvm/include/llvm/CodeGen/ |
| CostTable.h | 1 //===-- CostTable.h - Instruction Cost Table handling -----------*- C++ -*-===//
10 /// Cost tables and simple lookup functions
23 /// Cost Table Entry
27 unsigned Cost;
30 /// Find in cost table, TypeTy must be comparable to CompareTy by ==
43 /// Type Conversion Cost Table
48 unsigned Cost;
51 /// Find in type conversion cost table, TypeTy must be comparable to CompareTy
|
| /src/external/apache2/llvm/dist/llvm/lib/Target/AMDGPU/ |
| AMDGPURegisterBankInfo.h | 133 int16_t Cost;
|
| /src/external/apache2/llvm/dist/llvm/lib/Target/RISCV/MCTargetDesc/ |
| RISCVMatInt.cpp | 118 // Split the constant into platform register sized chunks, and calculate cost
120 int Cost = 0;
124 Cost += MatSeq.size();
126 return std::max(1, Cost);
|
| /src/external/apache2/llvm/dist/llvm/lib/Target/WebAssembly/ |
| WebAssemblyTargetTransformInfo.cpp | 60 InstructionCost Cost =
74 Cost =
82 return Cost;
88 InstructionCost Cost =
93 return Cost + 25 * TargetTransformInfo::TCC_Expensive;
95 return Cost;
|
| /src/external/apache2/llvm/dist/llvm/lib/Analysis/ |
| CostModel.cpp | 1 //===- CostModel.cpp ------ Cost Model Analysis ---------------------------===//
9 // This file defines the cost model analysis. It provides a very basic cost
11 // to approximate the cost of any IR instruction when lowered to machine
12 // instructions. The cost results are unit-less and the cost number represents
14 // branches are predicted, etc. The cost numbers can be added in order to
31 "cost-kind", cl::desc("Target cost kind"),
43 #define CM_NAME "cost-model
[all...] |
| /src/external/apache2/llvm/dist/llvm/include/llvm/Analysis/ |
| InlineCost.h | 1 //===- InlineCost.h - Cost analysis for inliner -----------------*- C++ -*-===//
33 // Various thresholds used by inline cost analysis.
57 /// Represents the cost of inlining a function.
60 /// "never" be inlined. Otherwise, the cost represents a unitless amount;
65 /// directly tested to determine if inlining should occur given the cost and
66 /// threshold for this cost metric.
70 /// The estimated cost of inlining this callsite.
71 int Cost = 0;
73 /// The adjusted threshold against which this cost was computed.
80 InlineCost(int Cost, int Threshold, const char *Reason = nullptr
[all...] |
| /src/external/apache2/llvm/dist/llvm/lib/CodeGen/ |
| RegisterClassInfo.cpp | 117 uint8_t Cost = RegCosts[PhysReg];
118 MinCost = std::min(MinCost, Cost);
125 if (Cost != LastCost)
128 LastCost = Cost;
137 uint8_t Cost = RegCosts[PhysReg];
138 if (Cost != LastCost)
141 LastCost = Cost;
|
| /src/external/apache2/llvm/dist/llvm/lib/Transforms/Scalar/ |
| SpeculativeExecution.cpp | 82 "spec-exec-max-speculation-cost", cl::init(7), cl::Hidden,
84 "the cost of the instructions to speculatively execute "
297 const InstructionCost Cost = ComputeSpeculationCost(&I, *TTI);
298 if (Cost.isValid() && isSafeToSpeculativelyExecute(&I) &&
300 TotalSpeculationCost += Cost;
|
| GVNSink.cpp | 199 int Cost = -1;
205 Cost = (NumInstructions * (NumBlocks - 1)) -
212 return Cost > Other.Cost;
218 OS << "<Candidate Cost=" << C.Cost << " #Blocks=" << C.NumBlocks
810 if (Candidates.empty() || Candidates.front().Cost <= 0)
|
| LoopFlatten.cpp | 58 "loop-flatten-cost-threshold", cl::Hidden, cl::init(2),
59 cl::desc("Limit on the cost of instructions that can be repeated due to "
306 // a fall-through, so adds no cost.
316 InstructionCost Cost =
318 LLVM_DEBUG(dbgs() << "Cost " << Cost << ": "; I.dump());
319 RepeatedInstrCost += Cost;
323 LLVM_DEBUG(dbgs() << "Cost of instructions that will be repeated: "
|
| /src/external/apache2/llvm/dist/llvm/utils/TableGen/ |
| DAGISelEmitter.cpp | 45 unsigned Cost = 0;
48 Cost++;
51 Cost += 10;
54 Cost += getResultPatternCost(P->getChild(i), CGP);
55 return Cost;
64 unsigned Cost = 0;
67 Cost += Op->getValueAsInt("CodeSize");
70 Cost += getResultPatternSize(P->getChild(i), CGP);
71 return Cost;
76 // In particular, we want to match maximal patterns first and lowest cost withi
[all...] |
| /src/external/apache2/llvm/dist/llvm/lib/Target/SystemZ/ |
| SystemZHazardRecognizer.cpp | 12 // the state during scheduling, and provide cost functions for
40 static cl::opt<int> ProcResCostLim("procres-cost-lim", cl::Hidden,
346 // or fit naturally if current group is empty (negative cost).
388 int Cost = 0;
397 Cost = (isFPdOpPreferred_distance(SU) ? INT_MIN : INT_MAX);
398 // For other instructions, give a cost to the use of the critical resource.
404 Cost = PI->Cycles;
407 return Cost;
|
| SystemZTargetTransformInfo.cpp | 29 // SystemZ cost model.
38 // There is no cost model for constants with a bit size of 0. Return TCC_Free
42 // No cost model for operations on integers larger than 64 bit implemented yet.
73 // There is no cost model for constants with a bit size of 0. Return TCC_Free
77 // No cost model for operations on integers larger than 64 bit implemented yet.
193 // There is no cost model for constants with a bit size of 0. Return TCC_Free
197 // No cost model for operations on integers larger than 64 bit implemented yet.
390 // TODO: Handle more cost kinds.
511 // FP128, the scalar cost is 1, and there is no overhead since the values
520 // Return the cost of multiple scalar invocation plus the cost o
[all...] |
| /src/external/apache2/llvm/dist/llvm/utils/PerfectShuffle/ |
| PerfectShuffle.cpp | 88 unsigned Cost; // Number of instrs used to generate this value.
91 ShuffleVal() : Cost(1000000) {}
107 unsigned Cost;
110 unsigned cost = 1)
111 : Name(name), ShuffleMask(shufflemask), OpNum(opnum),Cost(cost) {
124 unsigned getCost() const { return Cost; }
152 assert(0 && "bad zero cost operation");
163 if (ShufTab[ShufTab[ThisOp].Arg0].Cost == 0) {
177 if (ShufTab[ShufTab[ThisOp].Arg1].Cost == 0)
[all...] |
| /src/external/apache2/llvm/dist/llvm/include/llvm/CodeGen/GlobalISel/ |
| RegisterBankInfo.h | 188 /// mapped and what is the related cost of such mapping.
195 /// Cost of this mapping.
196 unsigned Cost = 0;
216 InstructionMapping(unsigned ID, unsigned Cost,
219 : ID(ID), Cost(Cost), OperandsMapping(OperandsMapping),
227 /// Get the cost.
228 unsigned getCost() const { return Cost; }
519 unsigned Cost = 0,
526 getInstructionMapping(unsigned ID, unsigned Cost,
[all...] |
| /src/external/apache2/llvm/dist/llvm/lib/MCA/HardwareUnits/ |
| RegisterFile.cpp | 89 // The cost of a register definition is equivalent to the number of
154 // We optimistically assume that a register can be renamed at the cost of a
160 // Now update the cost of individual registers.
173 IPC = std::make_pair(RegisterFileIndex, RCE.Cost);
177 // Assume the same cost for each sub-register.
194 unsigned Cost = Entry.IndexPlusCost.second;
197 RMT.NumUsedPhysRegs += Cost;
198 UsedPhysRegs[RegisterFileIndex] += Cost;
202 RegisterFiles[0].NumUsedPhysRegs += Cost;
203 UsedPhysRegs[0] += Cost;
[all...] |
| /src/external/apache2/llvm/dist/llvm/lib/Target/Hexagon/ |
| HexagonTargetTransformInfo.cpp | 41 // Constant "cost factor" to make floating point operations more expensive
42 // in terms of vectorization cost. This isn't the best way, but it should
43 // do. Ultimately, the cost should use cycles.
165 // TODO: Handle other cost kinds.
181 // Cost of HVX loads.
184 // Cost of constructing HVX vector from scalar loads
195 // Add extra cost for floating point types.
196 unsigned Cost =
204 return Cost * NumLoads;
208 return (3 - LogA) * Cost * NumLoads
[all...] |
| /src/external/apache2/llvm/dist/llvm/lib/Transforms/Vectorize/ |
| LoopVectorizationPlanner.h | 181 // Vector width with best cost
183 // Cost of the loop with that width
184 InstructionCost Cost;
186 VectorizationFactor(ElementCount Width, InstructionCost Cost)
187 : Width(Width), Cost(Cost) {}
189 // Width 1 means no vectorization, cost 0 means uncomputed cost.
195 return Width == rhs.Width && Cost == rhs.Cost;
[all...] |
| /src/external/apache2/llvm/dist/llvm/include/llvm/MC/ |
| MCSchedule.h | 10 // for scheduling and other instruction cost heuristics.
136 /// Specify the cost of a register definition in terms of number of physical
142 /// the cost of a YMM write in the BtVer2 model is 2.
145 unsigned Cost;
152 /// helps describing the size of the register file, as well as the cost of
162 // Index of the first cost entry in MCExtraProcessorInfo::RegisterCostTable.
196 /// tables. Scheduler resource tables model the latency and cost for each
|
| /src/external/apache2/llvm/dist/llvm/include/llvm/Transforms/Utils/ |
| ScalarEvolutionExpander.h | 44 /// struct for holding enough information to help calculate the cost of the
232 /// a less pessimistic cost estimation.
239 return true; // by always claiming to be high-cost.
242 InstructionCost Cost = 0;
247 if (isHighCostExpansionHelper(WorkItem, L, *At, Cost, ScaledBudget, *TTI,
251 assert(Cost <= ScaledBudget && "Should have returned from inner loop.");
406 const Instruction &At, InstructionCost &Cost,
|
| /src/external/apache2/llvm/dist/llvm/lib/CodeGen/GlobalISel/ |
| RegBankSelect.cpp | 279 unsigned Cost = RBI->copyCost(*DesiredRegBank, *CurRegBank,
282 if (Cost != std::numeric_limits<unsigned>::max())
283 return Cost;
284 // Return the legalization cost of that repairing.
296 MappingCost Cost = MappingCost::ImpossibleCost();
301 computeMapping(MI, *CurMapping, LocalRepairPts, &Cost);
302 if (CurCost < Cost) {
304 Cost = CurCost;
384 // account for a repairing cost for each phi we silently change.
396 // in the repairing cost all the phi we changed
[all...] |
| /src/external/apache2/llvm/dist/llvm/lib/Target/X86/ |
| X86DomainReassignment.cpp | 105 /// \returns the cost increment incurred by converting \p MI.
165 // Assuming instructions have the same cost.
201 // Assuming instructions have the same cost, and that COPY is in the same
421 /// Calculate the total cost of reassigning the closure to \p Domain.
479 assert(C.isLegal(DstDomain) && "Cannot calculate cost for illegal closure");
481 double Cost = 0.0;
483 Cost += Converters.find({DstDomain, MI->getOpcode()})
485 return Cost;
|
| /src/external/apache2/llvm/dist/llvm/tools/llvm-diff/ |
| DifferenceEngine.cpp | 506 DiffEntry() : Cost(0) {}
508 unsigned Cost;
538 Cur[I].Cost = I * LeftCost;
546 Next[0].Cost += RightCost;
553 Next[Index].Cost += MatchCost;
556 } else if (Next[Index-1].Cost <= Cur[Index].Cost) {
558 Next[Index].Cost += LeftCost;
562 Next[Index].Cost += RightCost;
|
| /src/external/apache2/llvm/dist/llvm/tools/llvm-mca/Views/ |
| BottleneckAnalysis.h | 185 // It specifies the dependency type, as well as the edge cost in cycles.
189 uint64_t Cost;
208 // Each edge of the graph is associated with a cost value which is used
210 // performance (see field DependencyEdge::Dependency::Cost). In general, the
211 // higher the cost of an edge, the higher the impact on performance.
213 // The cost of a dependency is a function of both the latency and the number of
226 uint64_t Cost;
253 unsigned Cost) {
254 addDependency(From, To, {DependencyEdge::DT_REGISTER, RegID, Cost});
257 void addMemoryDep(unsigned From, unsigned To, unsigned Cost) {
[all...] |
| /src/external/apache2/llvm/dist/llvm/lib/Target/PowerPC/ |
| PPCTargetTransformInfo.cpp | 42 LsrNoInsnsCost("ppc-lsr-no-insns-cost", cl::Hidden, cl::init(false),
43 cl::desc("Do not add instruction count to lsr cost model"));
54 // PPC cost model.
330 // Instructions that need to be split should cost more.
797 // often outweigh the cost of a division to compute the trip count.
941 // Adjust the cost of vector instructions on targets which there is overlap
944 InstructionCost PPCTTIImpl::vectorCostAdjustment(InstructionCost Cost,
948 return Cost;
952 // double the cost at every step - only the last step.
954 return Cost;
[all...] |
