[llvm-commits] [llvm] r146186 - /llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
Chris Lattner
clattner at apple.com
Mon Dec 12 15:50:21 PST 2011
On Dec 8, 2011, at 1:37 PM, Chad Rosier wrote:
> Author: mcrosier
> Date: Thu Dec 8 15:37:10 2011
> New Revision: 146186
>
> URL: http://llvm.org/viewvc/llvm-project?rev=146186&view=rev
> Log:
> Add rather verbose stats for fast-isel failures.
Hi Chad,
This is very "exhastive", and makes the llc -stats output really annoying. How about only enabling this with a cl::opt in addition to !NDEBUG?
-Chris
>
> Modified:
> llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
>
> Modified: llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp?rev=146186&r1=146185&r2=146186&view=diff
> ==============================================================================
> --- llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp (original)
> +++ llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp Thu Dec 8 15:37:10 2011
> @@ -61,6 +61,77 @@
> STATISTIC(NumDAGBlocks, "Number of blocks selected using DAG");
> STATISTIC(NumDAGIselRetries,"Number of times dag isel has to try another path");
>
> +#ifndef NDEBUG
> + // Terminators
> +STATISTIC(NumFastIselFailRet,"Fast isel fails on Ret");
> +STATISTIC(NumFastIselFailBr,"Fast isel fails on Br");
> +STATISTIC(NumFastIselFailSwitch,"Fast isel fails on Switch");
> +STATISTIC(NumFastIselFailIndirectBr,"Fast isel fails on IndirectBr");
> +STATISTIC(NumFastIselFailInvoke,"Fast isel fails on Invoke");
> +STATISTIC(NumFastIselFailResume,"Fast isel fails on Resume");
> +STATISTIC(NumFastIselFailUnwind,"Fast isel fails on Unwind");
> +STATISTIC(NumFastIselFailUnreachable,"Fast isel fails on Unreachable");
> +
> + // Standard binary operators...
> +STATISTIC(NumFastIselFailAdd,"Fast isel fails on Add");
> +STATISTIC(NumFastIselFailFAdd,"Fast isel fails on FAdd");
> +STATISTIC(NumFastIselFailSub,"Fast isel fails on Sub");
> +STATISTIC(NumFastIselFailFSub,"Fast isel fails on FSub");
> +STATISTIC(NumFastIselFailMul,"Fast isel fails on Mul");
> +STATISTIC(NumFastIselFailFMul,"Fast isel fails on FMul");
> +STATISTIC(NumFastIselFailUDiv,"Fast isel fails on UDiv");
> +STATISTIC(NumFastIselFailSDiv,"Fast isel fails on SDiv");
> +STATISTIC(NumFastIselFailFDiv,"Fast isel fails on FDiv");
> +STATISTIC(NumFastIselFailURem,"Fast isel fails on URem");
> +STATISTIC(NumFastIselFailSRem,"Fast isel fails on SRem");
> +STATISTIC(NumFastIselFailFRem,"Fast isel fails on FRem");
> +
> + // Logical operators...
> +STATISTIC(NumFastIselFailAnd,"Fast isel fails on And");
> +STATISTIC(NumFastIselFailOr,"Fast isel fails on Or");
> +STATISTIC(NumFastIselFailXor,"Fast isel fails on Xor");
> +
> + // Memory instructions...
> +STATISTIC(NumFastIselFailAlloca,"Fast isel fails on Alloca");
> +STATISTIC(NumFastIselFailLoad,"Fast isel fails on Load");
> +STATISTIC(NumFastIselFailStore,"Fast isel fails on Store");
> +STATISTIC(NumFastIselFailAtomicCmpXchg,"Fast isel fails on AtomicCmpXchg");
> +STATISTIC(NumFastIselFailAtomicRMW,"Fast isel fails on AtomicRWM");
> +STATISTIC(NumFastIselFailFence,"Fast isel fails on Frence");
> +STATISTIC(NumFastIselFailGetElementPtr,"Fast isel fails on GetElementPtr");
> +
> + // Convert instructions...
> +STATISTIC(NumFastIselFailTrunc,"Fast isel fails on Trunc");
> +STATISTIC(NumFastIselFailZExt,"Fast isel fails on ZExt");
> +STATISTIC(NumFastIselFailSExt,"Fast isel fails on SExt");
> +STATISTIC(NumFastIselFailFPTrunc,"Fast isel fails on FPTrunc");
> +STATISTIC(NumFastIselFailFPExt,"Fast isel fails on FPExt");
> +STATISTIC(NumFastIselFailFPToUI,"Fast isel fails on FPToUI");
> +STATISTIC(NumFastIselFailFPToSI,"Fast isel fails on FPToSI");
> +STATISTIC(NumFastIselFailUIToFP,"Fast isel fails on UIToFP");
> +STATISTIC(NumFastIselFailSIToFP,"Fast isel fails on SIToFP");
> +STATISTIC(NumFastIselFailIntToPtr,"Fast isel fails on IntToPtr");
> +STATISTIC(NumFastIselFailPtrToInt,"Fast isel fails on PtrToInt");
> +STATISTIC(NumFastIselFailBitCast,"Fast isel fails on BitCast");
> +
> + // Other instructions...
> +STATISTIC(NumFastIselFailICmp,"Fast isel fails on ICmp");
> +STATISTIC(NumFastIselFailFCmp,"Fast isel fails on FCmp");
> +STATISTIC(NumFastIselFailPHI,"Fast isel fails on PHI");
> +STATISTIC(NumFastIselFailSelect,"Fast isel fails on Select");
> +STATISTIC(NumFastIselFailCall,"Fast isel fails on Call");
> +STATISTIC(NumFastIselFailShl,"Fast isel fails on Shl");
> +STATISTIC(NumFastIselFailLShr,"Fast isel fails on LShr");
> +STATISTIC(NumFastIselFailAShr,"Fast isel fails on AShr");
> +STATISTIC(NumFastIselFailVAArg,"Fast isel fails on VAArg");
> +STATISTIC(NumFastIselFailExtractElement,"Fast isel fails on ExtractElement");
> +STATISTIC(NumFastIselFailInsertElement,"Fast isel fails on InsertElement");
> +STATISTIC(NumFastIselFailShuffleVector,"Fast isel fails on ShuffleVector");
> +STATISTIC(NumFastIselFailExtractValue,"Fast isel fails on ExtractValue");
> +STATISTIC(NumFastIselFailInsertValue,"Fast isel fails on InsertValue");
> +STATISTIC(NumFastIselFailLandingPad,"Fast isel fails on LandingPad");
> +#endif
> +
> static cl::opt<bool>
> EnableFastISelVerbose("fast-isel-verbose", cl::Hidden,
> cl::desc("Enable verbose messages in the \"fast\" "
> @@ -821,6 +892,84 @@
> !FuncInfo->isExportedInst(I); // Exported instrs must be computed.
> }
>
> +#ifndef NDEBUG
> +static void collectFailStats(const Instruction *I) {
> + switch (I->getOpcode()) {
> + default: assert (0 && "<Invalid operator> ");
> +
> + // Terminators
> + case Instruction::Ret: NumFastIselFailRet++; return;
> + case Instruction::Br: NumFastIselFailBr++; return;
> + case Instruction::Switch: NumFastIselFailSwitch++; return;
> + case Instruction::IndirectBr: NumFastIselFailIndirectBr++; return;
> + case Instruction::Invoke: NumFastIselFailInvoke++; return;
> + case Instruction::Resume: NumFastIselFailResume++; return;
> + case Instruction::Unwind: NumFastIselFailUnwind++; return;
> + case Instruction::Unreachable: NumFastIselFailUnreachable++; return;
> +
> + // Standard binary operators...
> + case Instruction::Add: NumFastIselFailAdd++; return;
> + case Instruction::FAdd: NumFastIselFailFAdd++; return;
> + case Instruction::Sub: NumFastIselFailSub++; return;
> + case Instruction::FSub: NumFastIselFailFSub++; return;
> + case Instruction::Mul: NumFastIselFailMul++; return;
> + case Instruction::FMul: NumFastIselFailFMul++; return;
> + case Instruction::UDiv: NumFastIselFailUDiv++; return;
> + case Instruction::SDiv: NumFastIselFailSDiv++; return;
> + case Instruction::FDiv: NumFastIselFailFDiv++; return;
> + case Instruction::URem: NumFastIselFailURem++; return;
> + case Instruction::SRem: NumFastIselFailSRem++; return;
> + case Instruction::FRem: NumFastIselFailFRem++; return;
> +
> + // Logical operators...
> + case Instruction::And: NumFastIselFailAnd++; return;
> + case Instruction::Or: NumFastIselFailOr++; return;
> + case Instruction::Xor: NumFastIselFailXor++; return;
> +
> + // Memory instructions...
> + case Instruction::Alloca: NumFastIselFailAlloca++; return;
> + case Instruction::Load: NumFastIselFailLoad++; return;
> + case Instruction::Store: NumFastIselFailStore++; return;
> + case Instruction::AtomicCmpXchg: NumFastIselFailAtomicCmpXchg++; return;
> + case Instruction::AtomicRMW: NumFastIselFailAtomicRMW++; return;
> + case Instruction::Fence: NumFastIselFailFence++; return;
> + case Instruction::GetElementPtr: NumFastIselFailGetElementPtr++; return;
> +
> + // Convert instructions...
> + case Instruction::Trunc: NumFastIselFailTrunc++; return;
> + case Instruction::ZExt: NumFastIselFailZExt++; return;
> + case Instruction::SExt: NumFastIselFailSExt++; return;
> + case Instruction::FPTrunc: NumFastIselFailFPTrunc++; return;
> + case Instruction::FPExt: NumFastIselFailFPExt++; return;
> + case Instruction::FPToUI: NumFastIselFailFPToUI++; return;
> + case Instruction::FPToSI: NumFastIselFailFPToSI++; return;
> + case Instruction::UIToFP: NumFastIselFailUIToFP++; return;
> + case Instruction::SIToFP: NumFastIselFailSIToFP++; return;
> + case Instruction::IntToPtr: NumFastIselFailIntToPtr++; return;
> + case Instruction::PtrToInt: NumFastIselFailPtrToInt++; return;
> + case Instruction::BitCast: NumFastIselFailBitCast++; return;
> +
> + // Other instructions...
> + case Instruction::ICmp: NumFastIselFailICmp++; return;
> + case Instruction::FCmp: NumFastIselFailFCmp++; return;
> + case Instruction::PHI: NumFastIselFailPHI++; return;
> + case Instruction::Select: NumFastIselFailSelect++; return;
> + case Instruction::Call: NumFastIselFailCall++; return;
> + case Instruction::Shl: NumFastIselFailShl++; return;
> + case Instruction::LShr: NumFastIselFailLShr++; return;
> + case Instruction::AShr: NumFastIselFailAShr++; return;
> + case Instruction::VAArg: NumFastIselFailVAArg++; return;
> + case Instruction::ExtractElement: NumFastIselFailExtractElement++; return;
> + case Instruction::InsertElement: NumFastIselFailInsertElement++; return;
> + case Instruction::ShuffleVector: NumFastIselFailShuffleVector++; return;
> + case Instruction::ExtractValue: NumFastIselFailExtractValue++; return;
> + case Instruction::InsertValue: NumFastIselFailInsertValue++; return;
> + case Instruction::LandingPad: NumFastIselFailLandingPad++; return;
> + }
> + return;
> +}
> +#endif
> +
> void SelectionDAGISel::SelectAllBasicBlocks(const Function &Fn) {
> // Initialize the Fast-ISel state, if needed.
> FastISel *FastIS = 0;
> @@ -932,6 +1081,10 @@
> continue;
> }
>
> +#ifndef NDEBUG
> + collectFailStats(Inst);
> +#endif
> +
> // Then handle certain instructions as single-LLVM-Instruction blocks.
> if (isa<CallInst>(Inst)) {
>
>
>
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
More information about the llvm-commits
mailing list