[FunctionPropertiesAnalysis] Add operand type counts

[aidengrossman]

Summary

This patch adds operand type counts to the detailed function properties
analysis. This is intended to enable more interesting and detailed
comparisons across different languages on specific metrics (like usage
of inline assembly or global values).

[aidengrossman]

Remove unnecessary includes.

[aidengrossman]

Planning on this and then probably a follow-up patch that adds more detailed statistics on phi nodes/branching and intrinsic usage, and then we should have a complete supserset of the statistics used in the literature (when combined with raw instruction counts).

[jdoerfert]

llvm/lib/Analysis/FunctionPropertiesAnalysis.cpp

122–123

Integer/FP constant count makes little sense. Make them "Operand" counts as well.

123–135

Add a "UnknownOperandCount".

131

The above should probably be a macro + a few invocations, also below. Anyway.

[aidengrossman]

Address some reviewer feedback.

• Denote integer and FP constant counts as operand counts.
• Add unknown operand count.

[aidengrossman]

llvm/lib/Analysis/FunctionPropertiesAnalysis.cpp

131

Can you explicate a little bit more on how you envision the macro? A macro defining a list of features that macros can then be plugged into for doing things like printing? Generating the operand counts with a macro seems a little counterintuitive to me since I believe it would be hard to preserve the semantics of the if/else if/else chain.

[jdoerfert]

llvm/lib/Analysis/FunctionPropertiesAnalysis.cpp

131

#define CHECK(TYPE) if (isa<TYPE>(Operand)) { TYPE ## OperandCount += 1; continue; }

[aidengrossman]

Address reviewer feedback.

• Convert counting operands into a macro.
• Convert printing properties into a macro.

[aidengrossman]

Remove extra includes.

llvm/include/llvm/Analysis/FunctionPropertiesAnalysis.h

public:
   int64_t CastInstructionCount = 0;
 
   // The number of floating point instructions inside the function.
   int64_t FloatingPointInstructionCount = 0;
 
   // The number of integer instructions inside the function.
   int64_t IntegerInstructionCount = 0;
 
-  // The number of integer constant operands inside the function.
-  int64_t IntegerConstantCount = 0;
-
-  // The number of floating point constant operands inside the function.
-  int64_t FloatingPointConstantCount = 0;
+  // Operand type couns
+  int64_t ConstantIntOperandCount = 0;
+  int64_t ConstantFPOperandCount = 0;
+  int64_t ConstantOperandCount = 0;
+  int64_t InstructionOperandCount = 0;
+  int64_t BasicBlockOperandCount = 0;
+  int64_t GlobalValueOperandCount = 0;
+  int64_t InlineAsmOperandCount = 0;
+  int64_t ArgumentOperandCount = 0;
+  int64_t UnknownOperandCount = 0;
 };
 
 // Analysis pass
 class FunctionPropertiesAnalysis
     : public AnalysisInfoMixin<FunctionPropertiesAnalysis> {
 
 public:
   static AnalysisKey Key;

llvm/lib/Analysis/FunctionPropertiesAnalysis.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Analysis/FunctionPropertiesAnalysis.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/IR/CFG.h"
+#include "llvm/IR/Constants.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/Support/CommandLine.h"
 #include <deque>
 
 using namespace llvm;
 
 cl::opt<bool> EnableDetailedFunctionProperties(
for (const Instruction &I : BB.instructionsWithoutDebug()) {
       if (I.isCast())
         CastInstructionCount += Direction;
 
       if (I.getType()->isFloatTy())
         FloatingPointInstructionCount += Direction;
       else if (I.getType()->isIntegerTy())
         IntegerInstructionCount += Direction;
 
+#define COUNT_OPERAND(OPTYPE)                                                  \
+  if (isa<OPTYPE>(Operand)) {                                                  \
+    OPTYPE##OperandCount += Direction;                                         \
+    continue;                                                                  \
+  }
+
       for (unsigned int OperandIndex = 0; OperandIndex < I.getNumOperands();
            ++OperandIndex) {
-        if (const Constant *C =
-                dyn_cast<Constant>(I.getOperand(OperandIndex))) {
-          if (C->getType()->isIntegerTy())
-            IntegerConstantCount += Direction;
-          else if (C->getType()->isFloatTy())
-            FloatingPointConstantCount += Direction;
-        }
+        Value *Operand = I.getOperand(OperandIndex);
+        COUNT_OPERAND(GlobalValue)
+        COUNT_OPERAND(ConstantInt)
+        COUNT_OPERAND(ConstantFP)
+        COUNT_OPERAND(Constant)
+        COUNT_OPERAND(Instruction)
+        COUNT_OPERAND(BasicBlock)
+        COUNT_OPERAND(InlineAsm)
+        COUNT_OPERAND(Argument)
+
+        // We only get to this point if we haven't matched any of the other
+        // operand types.
+        UnknownOperandCount += Direction;
       }
+
+#undef CHECK_OPERAND
     }
   }
 }
 
 void FunctionPropertiesInfo::updateAggregateStats(const Function &F,
                                                   const LoopInfo &LI) {
 
   Uses = getUses(F);
FunctionPropertiesInfo FunctionPropertiesInfo::getFunctionPropertiesInfo(
   for (const auto &BB : F)
     if (DT.isReachableFromEntry(&BB))
       FPI.reIncludeBB(BB);
   FPI.updateAggregateStats(F, LI);
   return FPI;
 }
 
 void FunctionPropertiesInfo::print(raw_ostream &OS) const {
-  OS << "BasicBlockCount: " << BasicBlockCount << "\n"
-     << "BlocksReachedFromConditionalInstruction: "
-     << BlocksReachedFromConditionalInstruction << "\n"
-     << "Uses: " << Uses << "\n"
-     << "DirectCallsToDefinedFunctions: " << DirectCallsToDefinedFunctions
-     << "\n"
-     << "LoadInstCount: " << LoadInstCount << "\n"
-     << "StoreInstCount: " << StoreInstCount << "\n"
-     << "MaxLoopDepth: " << MaxLoopDepth << "\n"
-     << "TopLevelLoopCount: " << TopLevelLoopCount << "\n"
-     << "TotalInstructionCount: " << TotalInstructionCount << "\n";
+#define PRINT_PROPERTY(PROP_NAME) OS << #PROP_NAME ": " << PROP_NAME << "\n";
+
+  PRINT_PROPERTY(BasicBlockCount)
+  PRINT_PROPERTY(BlocksReachedFromConditionalInstruction)
+  PRINT_PROPERTY(Uses)
+  PRINT_PROPERTY(DirectCallsToDefinedFunctions)
+  PRINT_PROPERTY(LoadInstCount)
+  PRINT_PROPERTY(StoreInstCount)
+  PRINT_PROPERTY(MaxLoopDepth)
+  PRINT_PROPERTY(TopLevelLoopCount)
+  PRINT_PROPERTY(TotalInstructionCount)
+
   if (EnableDetailedFunctionProperties) {
-    OS << "BasicBlocksWithSingleSuccessor: " << BasicBlocksWithSingleSuccessor
-       << "\n"
-       << "BasicBlocksWithTwoSuccessors: " << BasicBlocksWithTwoSuccessors
-       << "\n"
-       << "BasicBlocksWithMoreThanTwoSuccessors: "
-       << BasicBlocksWithMoreThanTwoSuccessors << "\n"
-       << "BasicBlocksWithSinglePredecessor: "
-       << BasicBlocksWithSinglePredecessor << "\n"
-       << "BasicBlocksWithTwoPredecessors: " << BasicBlocksWithTwoPredecessors
-       << "\n"
-       << "BasicBlocksWithMoreThanTwoPredecessors: "
-       << BasicBlocksWithMoreThanTwoPredecessors << "\n"
-       << "BigBasicBlocks: " << BigBasicBlocks << "\n"
-       << "MediumBasicBlocks: " << MediumBasicBlocks << "\n"
-       << "SmallBasicBlocks: " << SmallBasicBlocks << "\n"
-       << "CastInstructionCount: " << CastInstructionCount << "\n"
-       << "FloatingPointInstructionCount: " << FloatingPointInstructionCount
-       << "\n"
-       << "IntegerInstructionCount: " << IntegerInstructionCount << "\n"
-       << "IntegerConstantCount: " << IntegerConstantCount << "\n"
-       << "FloatingPointConstantCount: " << FloatingPointConstantCount << "\n";
+    PRINT_PROPERTY(BasicBlocksWithSingleSuccessor)
+    PRINT_PROPERTY(BasicBlocksWithTwoSuccessors)
+    PRINT_PROPERTY(BasicBlocksWithMoreThanTwoSuccessors)
+    PRINT_PROPERTY(BasicBlocksWithSinglePredecessor)
+    PRINT_PROPERTY(BasicBlocksWithTwoPredecessors)
+    PRINT_PROPERTY(BasicBlocksWithMoreThanTwoPredecessors)
+    PRINT_PROPERTY(BigBasicBlocks)
+    PRINT_PROPERTY(MediumBasicBlocks)
+    PRINT_PROPERTY(SmallBasicBlocks)
+    PRINT_PROPERTY(CastInstructionCount)
+    PRINT_PROPERTY(FloatingPointInstructionCount)
+    PRINT_PROPERTY(IntegerInstructionCount)
+    PRINT_PROPERTY(ConstantIntOperandCount)
+    PRINT_PROPERTY(ConstantFPOperandCount)
+    PRINT_PROPERTY(ConstantOperandCount)
+    PRINT_PROPERTY(InstructionOperandCount)
+    PRINT_PROPERTY(BasicBlockOperandCount)
+    PRINT_PROPERTY(GlobalValueOperandCount)
+    PRINT_PROPERTY(InlineAsmOperandCount)
+    PRINT_PROPERTY(ArgumentOperandCount)
+    PRINT_PROPERTY(UnknownOperandCount)
   }
+
+#undef PRINT_PROPERTY
+
   OS << "\n";
 }
 
 AnalysisKey FunctionPropertiesAnalysis::Key;
 
 FunctionPropertiesInfo
 FunctionPropertiesAnalysis::run(Function &F, FunctionAnalysisManager &FAM) {
   return FunctionPropertiesInfo::getFunctionPropertiesInfo(F, FAM);

llvm/test/Analysis/FunctionPropertiesAnalysis/matmul.ll

 ; DETAILED-PROPERTIES-DAG: BasicBlocksWithTwoPredecessors: 0
 ; DETAILED-PROPERTIES-DAG: BasicBlocksWithMoreThanTwoPredecessors: 0
 ; DETAILED-PROPERTIES-DAG: BigBasicBlocks: 0
 ; DETAILED-PROPERTIES-DAG: MediumBasicBlocks: 0
 ; DETAILED-PROPERTIES-DAG: SmallBasicBlocks: 1
 ; DETAILED-PROPERTIES-DAG: CastInstructionCount: 0
 ; DETAILED-PROPERTIES-DAG: FloatingPointInstructionCount: 0
 ; DETAILED-PROPERTIES-DAG: IntegerInstructionCount: 0
-; DETAILED-PROPERTIES-DAG: IntegerConstantCount: 14
-; DETAILED-PROPERTIES-DAG: FloatingPointConstantCount: 0
+; DETAILED-PROPERTIES-DAG: ConstantIntOperandCount: 14
+; DETAILED-PROPERTIES-DAG: ConstantFPOperandCount: 0
+; DETAILED-PROPERTIES-DAG: ConstantOperandCount: 0
+; DETAILED-PROPERTIES-DAG: InstructionOperandCount: 7
+; DETAILED-PROPERTIES-DAG: BasicBlockOperandCount: 0
+; DETAILED-PROPERTIES-DAG: GlobalValueOperandCount: 1
+; DETAILED-PROPERTIES-DAG: InlineAsmOperandCount: 0
+; DETAILED-PROPERTIES-DAG: ArgumentOperandCount: 0
+; DETAILED-PROPERTIES-DAG: UnknownOperandCount: 0
 
 define void @multiply([2 x i32]* %mat1, [2 x i32]* %mat2, [2 x i32]* %res) {
 ; CHECK-DAG: Printing analysis results of CFA for function 'multiply':
 ; DETAILED-PROPERTIES-DAG: Printing analysis results of CFA for function 'multiply':
 entry:
   %mat1.addr = alloca [2 x i32]*, align 8
   %mat2.addr = alloca [2 x i32]*, align 8
   %res.addr = alloca [2 x i32]*, align 8

 ; DETAILED-PROPERTIES-DAG: BasicBlocksWithTwoPredecessors: 3
 ; DETAILED-PROPERTIES-DAG: BasicBlocksWithMoreThanTwoPredecessors: 0
 ; DETAILED-PROPERTIES-DAG: BigBasicBlocks: 0
 ; DETAILED-PROPERTIES-DAG: MediumBasicBlocks: 11
 ; DETAILED-PROPERTIES-DAG: SmallBasicBlocks: 2
 ; DETAILED-PROPERTIES-DAG: CastInstructionCount: 8
 ; DETAILED-PROPERTIES-DAG: FloatingPointInstructionCount: 0
 ; DETAILED-PROPERTIES-DAG: IntegerInstructionCount: 33
-; DETAILED-PROPERTIES-DAG: IntegerConstantCount: 20
-; DETAILED-PROPERTIES-DAG: FloatingPointConstantCount: 0
+; DETAILED-PROPERTIES-DAG: ConstantIntOperandCount: 20
+; DETAILED-PROPERTIES-DAG: ConstantFPOperandCount: 0
+; DETAILED-PROPERTIES-DAG: ConstantOperandCount: 0
+; DETAILED-PROPERTIES-DAG: InstructionOperandCount: 73
+; DETAILED-PROPERTIES-DAG: BasicBlockOperandCount: 15
+; DETAILED-PROPERTIES-DAG: GlobalValueOperandCount: 0
+; DETAILED-PROPERTIES-DAG: InlineAsmOperandCount: 0
+; DETAILED-PROPERTIES-DAG: ArgumentOperandCount: 3
+; DETAILED-PROPERTIES-DAG: UnknownOperandCount: 0
+

llvm/unittests/Analysis/FunctionPropertiesAnalysisTest.cpp

)IR");
   EXPECT_EQ(DetailedBranchesFeatures.BasicBlocksWithTwoPredecessors, 1);
   EXPECT_EQ(DetailedBranchesFeatures.BasicBlocksWithMoreThanTwoPredecessors, 0);
   EXPECT_EQ(DetailedBranchesFeatures.BigBasicBlocks, 0);
   EXPECT_EQ(DetailedBranchesFeatures.MediumBasicBlocks, 0);
   EXPECT_EQ(DetailedBranchesFeatures.SmallBasicBlocks, 4);
   EXPECT_EQ(DetailedBranchesFeatures.CastInstructionCount, 0);
   EXPECT_EQ(DetailedBranchesFeatures.FloatingPointInstructionCount, 0);
   EXPECT_EQ(DetailedBranchesFeatures.IntegerInstructionCount, 4);
-  EXPECT_EQ(DetailedBranchesFeatures.IntegerConstantCount, 1);
-  EXPECT_EQ(DetailedBranchesFeatures.FloatingPointConstantCount, 0);
+  EXPECT_EQ(DetailedBranchesFeatures.ConstantIntOperandCount, 1);
+  EXPECT_EQ(DetailedBranchesFeatures.ConstantFPOperandCount, 0);
+  EXPECT_EQ(DetailedBranchesFeatures.ConstantOperandCount, 0);
+  EXPECT_EQ(DetailedBranchesFeatures.InstructionOperandCount, 4);
+  EXPECT_EQ(DetailedBranchesFeatures.BasicBlockOperandCount, 4);
+  EXPECT_EQ(DetailedBranchesFeatures.GlobalValueOperandCount, 2);
+  EXPECT_EQ(DetailedBranchesFeatures.InlineAsmOperandCount, 0);
+  EXPECT_EQ(DetailedBranchesFeatures.ArgumentOperandCount, 3);
+  EXPECT_EQ(DetailedBranchesFeatures.UnknownOperandCount, 0);
   EnableDetailedFunctionProperties.setValue(false);
 }
 
 TEST_F(FunctionPropertiesAnalysisTest, DifferentPredecessorSuccessorCounts) {
   LLVMContext C;
   std::unique_ptr<Module> M = makeLLVMModule(C,
                                              R"IR(
 define i64 @f1() {
)IR");
   EXPECT_EQ(DetailedF1Properties.BasicBlocksWithTwoPredecessors, 0);
   EXPECT_EQ(DetailedF1Properties.BasicBlocksWithMoreThanTwoPredecessors, 0);
   EXPECT_EQ(DetailedF1Properties.BigBasicBlocks, 0);
   EXPECT_EQ(DetailedF1Properties.MediumBasicBlocks, 0);
   EXPECT_EQ(DetailedF1Properties.SmallBasicBlocks, 3);
   EXPECT_EQ(DetailedF1Properties.CastInstructionCount, 0);
   EXPECT_EQ(DetailedF1Properties.FloatingPointInstructionCount, 0);
   EXPECT_EQ(DetailedF1Properties.IntegerInstructionCount, 0);
-  EXPECT_EQ(DetailedF1Properties.IntegerConstantCount, 3);
-  EXPECT_EQ(DetailedF1Properties.FloatingPointConstantCount, 0);
+  EXPECT_EQ(DetailedF1Properties.ConstantIntOperandCount, 3);
+  EXPECT_EQ(DetailedF1Properties.ConstantFPOperandCount, 0);
+  EXPECT_EQ(DetailedF1Properties.ConstantOperandCount, 0);
+  EXPECT_EQ(DetailedF1Properties.InstructionOperandCount, 0);
+  EXPECT_EQ(DetailedF1Properties.BasicBlockOperandCount, 2);
+  EXPECT_EQ(DetailedF1Properties.GlobalValueOperandCount, 0);
+  EXPECT_EQ(DetailedF1Properties.InlineAsmOperandCount, 0);
+  EXPECT_EQ(DetailedF1Properties.ArgumentOperandCount, 0);
+  EXPECT_EQ(DetailedF1Properties.UnknownOperandCount, 0);
   EnableDetailedFunctionProperties.setValue(false);
 }
 
 TEST_F(FunctionPropertiesAnalysisTest, InlineSameBBSimple) {
   LLVMContext C;
   std::unique_ptr<Module> M = makeLLVMModule(C,
                                              R"IR(
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
)IR");
   FunctionPropertiesUpdater FPU(FPI, *CB);
   InlineFunctionInfo IFI;
   auto IR = llvm::InlineFunction(*CB, IFI);
   EXPECT_TRUE(IR.isSuccess());
   invalidate(*F1);
   EXPECT_TRUE(FPU.finishAndTest(FAM));
   EXPECT_EQ(FPI, ExpectedFinal);
 }
+
+TEST_F(FunctionPropertiesAnalysisTest, DetailedOperandCount) {
+  LLVMContext C;
+  std::unique_ptr<Module> M = makeLLVMModule(C,
+                                             R"IR(
+@a = global i64 1
+
+define i64 @f1(i64 %e) {
+  %b = load i64, i64* @a
+  %c = add i64 %b, 2
+  %d = call i64 asm "mov $1,$0", "=r,r" (i64 %c)                                            
+  %f = add i64 %d, %e
+  ret i64 %f
+}
+)IR");
+
+  Function *F1 = M->getFunction("f1");
+  EnableDetailedFunctionProperties.setValue(true);
+  FunctionPropertiesInfo DetailedF1Properties = buildFPI(*F1);
+  EXPECT_EQ(DetailedF1Properties.BasicBlocksWithSingleSuccessor, 0);
+  EXPECT_EQ(DetailedF1Properties.BasicBlocksWithTwoSuccessors, 0);
+  EXPECT_EQ(DetailedF1Properties.BasicBlocksWithMoreThanTwoSuccessors, 0);
+  EXPECT_EQ(DetailedF1Properties.BasicBlocksWithSinglePredecessor, 0);
+  EXPECT_EQ(DetailedF1Properties.BasicBlocksWithTwoPredecessors, 0);
+  EXPECT_EQ(DetailedF1Properties.BasicBlocksWithMoreThanTwoPredecessors, 0);
+  EXPECT_EQ(DetailedF1Properties.BigBasicBlocks, 0);
+  EXPECT_EQ(DetailedF1Properties.MediumBasicBlocks, 0);
+  EXPECT_EQ(DetailedF1Properties.SmallBasicBlocks, 1);
+  EXPECT_EQ(DetailedF1Properties.CastInstructionCount, 0);
+  EXPECT_EQ(DetailedF1Properties.FloatingPointInstructionCount, 0);
+  EXPECT_EQ(DetailedF1Properties.IntegerInstructionCount, 4);
+  EXPECT_EQ(DetailedF1Properties.ConstantIntOperandCount, 1);
+  EXPECT_EQ(DetailedF1Properties.ConstantFPOperandCount, 0);
+  EXPECT_EQ(DetailedF1Properties.ConstantOperandCount, 0);
+  EXPECT_EQ(DetailedF1Properties.InstructionOperandCount, 4);
+  EXPECT_EQ(DetailedF1Properties.BasicBlockOperandCount, 0);
+  EXPECT_EQ(DetailedF1Properties.GlobalValueOperandCount, 1);
+  EXPECT_EQ(DetailedF1Properties.InlineAsmOperandCount, 1);
+  EXPECT_EQ(DetailedF1Properties.ArgumentOperandCount, 1);
+  EXPECT_EQ(DetailedF1Properties.UnknownOperandCount, 0);
+  EnableDetailedFunctionProperties.setValue(false);
+}
 } // end anonymous namespace