Revised args promoted flag name, LIT tests

[teamiceberg]

Revised args promoted flag name, LIT tests

[teamiceberg]

Abandoning this to setup a new base for revisions.

.gitignore

 /.idea
 
 #==============================================================================#
 # Directories to ignore (do not add trailing '/'s, they skip symlinks).
 #==============================================================================#
 # VS2017 and VSCode config files.
 .vscode
 .vs
+.code-workspace
 # clangd index
 .clangd

llvm/include/llvm/Transforms/IPO/ArgumentPromotion.h

 //===- ArgumentPromotion.h - Promote by-reference arguments -----*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TRANSFORMS_IPO_ARGUMENTPROMOTION_H
 #define LLVM_TRANSFORMS_IPO_ARGUMENTPROMOTION_H
 
 #include "llvm/Analysis/CGSCCPassManager.h"
 #include "llvm/Analysis/LazyCallGraph.h"
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 class TargetTransformInfo;
-
+static unsigned GL_NUMPROMARGS = 3; //opt flag (if supplied) populates this Global Variable 
 /// Argument promotion pass.
 ///
 /// This pass walks the functions in each SCC and for each one tries to
 /// transform it and all of its callers to replace indirect arguments with
 /// direct (by-value) arguments.
 class ArgumentPromotionPass : public PassInfoMixin<ArgumentPromotionPass> {
   unsigned MaxElements;
 
 public:
-  ArgumentPromotionPass(unsigned MaxElements = 3u) : MaxElements(MaxElements) {}
+  ArgumentPromotionPass(unsigned MaxElements = GL_NUMPROMARGS) : MaxElements(MaxElements) {}
 
   /// Check if callers and the callee \p F agree how promoted arguments would be
   /// passed. The ones that they do not agree on are eliminated from the sets but
   /// the return value has to be observed as well.
   static bool areFunctionArgsABICompatible(
       const Function &F, const TargetTransformInfo &TTI,
       SmallPtrSetImpl<Argument *> &ArgsToPromote,
       SmallPtrSetImpl<Argument *> &ByValArgsToTransform);

llvm/lib/Transforms/Hello/Hello.cpp

 //===- Hello.cpp - Example code from "Writing an LLVM Pass" ---------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements two versions of the LLVM "Hello World" pass described
 // in docs/WritingAnLLVMPass.html
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/Statistic.h"
 #include "llvm/IR/Function.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/IR/LegacyPassManager.h"
+#include "llvm/Transforms/IPO/PassManagerBuilder.h"
+
 using namespace llvm;
 
 #define DEBUG_TYPE "hello"
 
 STATISTIC(HelloCounter, "Counts number of functions greeted");
 
 namespace {
   // Hello - The first implementation, without getAnalysisUsage.
   struct Hello : public FunctionPass {
     static char ID; // Pass identification, replacement for typeid
     Hello() : FunctionPass(ID) {}
 
     bool runOnFunction(Function &F) override {
       ++HelloCounter;
       errs() << "Hello: ";
       errs().write_escaped(F.getName()) << '\n';
       return false;
     }
   };
 }
 
 char Hello::ID = 0;
 static RegisterPass<Hello> X("hello", "Hello World Pass");
+/*static llvm::RegisterStandardPasses A(
+    llvm::PassManagerBuilder::EP_EarlyAsPossible,
+    [](const llvm::PassManagerBuilder &Builder,
+       llvm::legacy::PassManagerBase &PM) { PM.add(new Hello()); });*/
 
 namespace {
   // Hello2 - The second implementation with getAnalysisUsage implemented.
   struct Hello2 : public FunctionPass {
     static char ID; // Pass identification, replacement for typeid
     Hello2() : FunctionPass(ID) {}
 
     bool runOnFunction(Function &F) override {
       ++HelloCounter;
       errs() << "Hello: ";
       errs().write_escaped(F.getName()) << '\n';
       return false;
     }
 
     // We don't modify the program, so we preserve all analyses.
     void getAnalysisUsage(AnalysisUsage &AU) const override {
       AU.setPreservesAll();
     }
   };
 }
 
 char Hello2::ID = 0;
 static RegisterPass<Hello2>
 Y("hello2", "Hello World Pass (with getAnalysisUsage implemented)");
+
+static llvm::RegisterStandardPasses B(
+    llvm::PassManagerBuilder::EP_EarlyAsPossible,
+    [](const llvm::PassManagerBuilder &Builder,
+       llvm::legacy::PassManagerBase &PM) { PM.add(new Hello2()); });
 No newline at end of file

llvm/lib/Transforms/IPO/ArgumentPromotion.cpp

 //===- ArgumentPromotion.cpp - Promote by-reference arguments -------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //

 #include <string>
 #include <utility>
 #include <vector>
 
 using namespace llvm;
 
 #define DEBUG_TYPE "argpromotion"
 
+//opt flag to capture user supplied value for GV: GL_NUMPROMARGS
+cl::opt<unsigned, true> argmax("numargspromoted", cl::desc("Specify number of args to promote"), cl::value_desc("numargs"), cl::location(llvm::GL_NUMPROMARGS));
+
 STATISTIC(NumArgumentsPromoted, "Number of pointer arguments promoted");
 STATISTIC(NumAggregatesPromoted, "Number of aggregate arguments promoted");
 STATISTIC(NumByValArgsPromoted, "Number of byval arguments promoted");
 STATISTIC(NumArgumentsDead, "Number of dead pointer args eliminated");
 
 /// A vector used to hold the indices of a single GEP instruction
 using IndicesVector = std::vector<uint64_t>;
 

 INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
 INITIALIZE_PASS_DEPENDENCY(CallGraphWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(TargetTransformInfoWrapperPass)
 INITIALIZE_PASS_END(ArgPromotion, "argpromotion",
                     "Promote 'by reference' arguments to scalars", false, false)
 
 Pass *llvm::createArgumentPromotionPass(unsigned MaxElements) {
-  return new ArgPromotion(MaxElements);
+  return new ArgPromotion(GL_NUMPROMARGS);
 }
 
 bool ArgPromotion::runOnSCC(CallGraphSCC &SCC) {
   if (skipSCC(SCC))
     return false;
 
   // Get the callgraph information that we need to update to reflect our
   // changes.

llvm/test/Transforms/ArgumentPromotion/magic-values/basictest.ll

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --scrub-attributes
+; NOTE: three scenarios: 1) zero arguments promoted, 2) Baseline (current state = 3 args promoted), 3) infinite arguments promoted 
+; RUN: opt < %s  -basicaa -argpromotion -numargspromoted=0 -mem2reg -S | FileCheck %s
+; RUN: opt < %s  -basicaa -argpromotion -mem2reg -S | FileCheck %s
+; RUN: opt < %s  -basicaa -argpromotion -numargspromoted=2147483647 -mem2reg -S | FileCheck %s
+target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
+
+define internal i32 @test(i32* %X, i32* %Y) {
+; CHECK-LABEL: define {{[^@]+}}@test
+; CHECK-SAME: (i32 [[X_VAL:%.*]], i32 [[Y_VAL:%.*]])
+; CHECK-NEXT:    [[C:%.*]] = add i32 [[X_VAL]], [[Y_VAL]]
+; CHECK-NEXT:    ret i32 [[C]]
+;
+  %A = load i32, i32* %X
+  %B = load i32, i32* %Y
+  %C = add i32 %A, %B
+  ret i32 %C
+}
+
+define internal i32 @caller(i32* %B) {
+; CHECK-LABEL: define {{[^@]+}}@caller
+; CHECK-SAME: (i32 [[B_VAL1:%.*]])
+; CHECK-NEXT:    [[C:%.*]] = call i32 @test(i32 1, i32 [[B_VAL1]])
+; CHECK-NEXT:    ret i32 [[C]]
+;
+  %A = alloca i32
+  store i32 1, i32* %A
+  %C = call i32 @test(i32* %A, i32* %B)
+  ret i32 %C
+}
+
+define i32 @callercaller() {
+; CHECK-LABEL: define {{[^@]+}}@callercaller()
+; CHECK-NEXT:    [[X:%.*]] = call i32 @caller(i32 2)
+; CHECK-NEXT:    ret i32 [[X]]
+;
+  %B = alloca i32
+  store i32 2, i32* %B
+  %X = call i32 @caller(i32* %B)
+  ret i32 %X
+}
+

llvm/test/Transforms/ArgumentPromotion/magic-values/lit.local.cfg

+if not 'X86' in config.root.targets:
+    config.unsupported = True

magic-llvm.code-workspace

+{
+  "folders": [
+    {
+      "path": "."
+    }
+  ],
+  "settings": {
+    "files.associations": {
+      "stdio.h": "c",
+      "iostream": "cpp",
+      "algorithm": "cpp",
+      "string": "cpp",
+      "filesystem": "cpp",
+      "iosfwd": "cpp",
+      "cmath": "cpp"
+    },
+    "python.pythonPath": "/System/Library/Frameworks/Python.framework/Versions/2.7/Resources/Python.app/Contents/MacOS/Python"
+  }
+}
 No newline at end of file