[ForceFunctionAttrs] Make options additionally work over entire module

[aidengrossman]

Summary

This patch makes the -force-attribute and -force-remove-attribute flags in the forceattrs pass additionally work over all the functions in a module rather than on specific functions. I often find myself dealing with bitcode from projects with arbitrary build systems that have applied the optnone attribute for various reasons and having the ability to do this in opt would be quite convenient. It's possible to remove the attribute by disassembling to textual IR, running sed, and then running opt over the result, but this option makes things just a bit easier.

[aidengrossman]

@jdoerfert also suggested doing this in an IPO pass (like FunctionAttrs) but it seemed simple enough to implement this way. I couldn't think of any benefit of doing it within an IPO pass, but definitely could be missing something. Also wondering if there are reasons for not doing this as I thought there would've been something like this already.

[nikic]

It seems like -force-remove-attribute should be able to do this, but apparently it doesn't allow removing an attribute from all functions currently, only explicitly named ones. Maybe we should extend that?

[jdoerfert]

In D158815#4616377, @nikic wrote:

It seems like -force-remove-attribute should be able to do this, but apparently it doesn't allow removing an attribute from all functions currently, only explicitly named ones. Maybe we should extend that?

^ seems reasonable and more generic. You often want to remove noinline as well, so there is the use case already

[aidengrossman]

Switch to modifying ForceFunctionAttrs rather than adding an opt option.

[nikic]

LGTM

llvm/lib/Transforms/IPO/ForceFunctionAttrs.cpp

 #include "llvm/IR/Module.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 using namespace llvm;
 
 #define DEBUG_TYPE "forceattrs"
 
-static cl::list<std::string>
-    ForceAttributes("force-attribute", cl::Hidden,
-                    cl::desc("Add an attribute to a function. This should be a "
-                             "pair of 'function-name:attribute-name', for "
-                             "example -force-attribute=foo:noinline. This "
-                             "option can be specified multiple times."));
+static cl::list<std::string> ForceAttributes(
+    "force-attribute", cl::Hidden,
+    cl::desc(
+        "Add an attribute to a function. This can be a "
+        "pair of 'function-name:attribute-name', to apply an attribute to a "
+        "specific function. For "
+        "example -force-attribute=foo:noinline. Specifying only an attribute "
+        "will apply the attribute to every function in the module. This "
 
 static cl::list<std::string> ForceRemoveAttributes(
     "force-remove-attribute", cl::Hidden,
-    cl::desc("Remove an attribute from a function. This should be a "
-             "pair of 'function-name:attribute-name', for "
-             "example -force-remove-attribute=foo:noinline. This "
+    cl::desc("Remove an attribute from a function. This can be a "
+             "pair of 'function-name:attribute-name' to remove an attribute "
+             "from a specific function. For "
+             "example -force-remove-attribute=foo:noinline. Specifying only an "
+             "attribute will remove the attribute from all functions in the "
+             "module. This "
              "option can be specified multiple times."));
 
 /// If F has any forced attributes given on the command line, add them.
 /// If F has any forced remove attributes given on the command line, remove
 /// them. When both force and force-remove are given to a function, the latter
 /// takes precedence.
 static void forceAttributes(Function &F) {
   auto ParseFunctionAndAttr = [&](StringRef S) {
-    auto Kind = Attribute::None;
+    StringRef AttributeText;
+    if (S.contains(':')) {
       auto KV = StringRef(S).split(':');
       if (KV.first != F.getName())
-      return Kind;
-    Kind = Attribute::getAttrKindFromName(KV.second);
+        return Attribute::None;
+      AttributeText = KV.second;
+    } else {
+      AttributeText = S;
+    }
+    auto Kind = Attribute::getAttrKindFromName(AttributeText);
     if (Kind == Attribute::None || !Attribute::canUseAsFnAttr(Kind)) {
-      LLVM_DEBUG(dbgs() << "ForcedAttribute: " << KV.second
+      LLVM_DEBUG(dbgs() << "ForcedAttribute: " << AttributeText
                         << " unknown or not a function attribute!\n");
     }
     return Kind;
   };
 
   for (const auto &S : ForceAttributes) {
     auto Kind = ParseFunctionAndAttr(S);
     if (Kind == Attribute::None || F.hasFnAttribute(Kind))

llvm/test/Transforms/ForcedFunctionAttrs/forced.ll

 ; RUN: opt < %s -S -passes=forceattrs | FileCheck %s --check-prefix=CHECK-CONTROL
 ; RUN: opt < %s -S -passes=forceattrs -force-attribute foo:noinline | FileCheck %s --check-prefix=CHECK-FOO
 ; RUN: opt < %s -S -passes=forceattrs -force-remove-attribute goo:cold | FileCheck %s --check-prefix=REMOVE-COLD
 ; RUN: opt < %s -S -passes=forceattrs -force-remove-attribute goo:noinline | FileCheck %s --check-prefix=REMOVE-NOINLINE
 ; RUN: opt < %s -S -passes=forceattrs -force-attribute goo:cold -force-remove-attribute goo:noinline | FileCheck %s --check-prefix=ADD-COLD-REMOVE-NOINLINE
 ; RUN: opt < %s -S -passes=forceattrs -force-attribute goo:noinline -force-remove-attribute goo:noinline | FileCheck %s --check-prefix=ADD-NOINLINE-REMOVE-NOINLINE
+; RUN: opt < %s -S -passes=forceattrs -force-attribute optsize | FileCheck %s --check-prefix=CHECK-ADD-ALL
+; RUN: opt < %s -S -passes=forceattrs -force-remove-attribute noinline | FileCheck %s --check-prefix=CHECK-REMOVE-ALL
 
 ; CHECK-CONTROL: define void @foo() {
 ; CHECK-FOO: define void @foo() #0 {
 define void @foo() {
   ret void
 }
 
 ; Ignore `cold` which does not exist before.

 define void @goo() #0 {
   ret void
 }
 attributes #0 = { noinline }
 
 ; CHECK-FOO: attributes #0 = { noinline }
 ; REMOVE-COLD: attributes #0 = { noinline }
 ; ADD-COLD-REMOVE-NOINLINE: attributes #0 = { cold }
+
+; When passing an attribute without specifying a function, the attribute
+; should be added to all functions in the module.
+; CHECK-ADD-ALL: define void @foo() #0 {
+; CHECK-ADD-ALL: define void @goo() #1 {
+; CHECK-ADD-ALL: attributes #0 = { optsize }
+; CHECK-ADD-ALL: attributes #1 = { noinline optsize }
+
+; When passing an attribute to be removed without specifying a function,
+; the attribute should be removed from all functions in the module that
+; have it.
+; CHECK-REMOVE-ALL: define void @foo() {
+; CHECK-REMOVE-ALL: define void @goo() {
+; CHECK-REMOVE-ALL-NOT: attributes #0
+