Implement @optStrat UDA.

Resolves #1549.

Author: JohanEngelen

gen/uda.cpp

@@ -17,6 +17,7 @@ namespace {
 namespace attr {
 const std::string llvmAttr = "llvmAttr";
 const std::string llvmFastMathFlag = "llvmFastMathFlag";
+const std::string optStrat = "optStrat";
 const std::string section = "section";
 const std::string target = "target";
 const std::string weak = "_weak";
@@ -147,6 +148,30 @@ void applyAttrLLVMFastMathFlag(StructLiteralExp *sle, IrFunction *irFunc) {
   }
 }
 
+void applyAttrOptStrat(StructLiteralExp *sle, IrFunction *irFunc) {
+  checkStructElems(sle, {Type::tstring});
+  llvm::StringRef value = getStringElem(sle, 0);
+
+  if (value == "none") {
+    if (irFunc->decl->inlining == PINLINEalways) {
+      sle->error("cannot combine '@ldc.attributes.%s(\"none\")' with "
+                 "'pragma(inline, true)'",
+                 sle->sd->ident->string);
+      return;
+    }
+    irFunc->decl->inlining = PINLINEnever;
+    irFunc->func->addFnAttr(llvm::Attribute::OptimizeNone);
+  } else if (value == "optsize") {
+    irFunc->func->addFnAttr(llvm::Attribute::OptimizeForSize);
+  } else if (value == "minsize") {
+    irFunc->func->addFnAttr(llvm::Attribute::MinSize);
+  } else {
+    sle->warning(
+        "ignoring unrecognized parameter '%s' for '@ldc.attributes.%s'",
+        value.data(), sle->sd->ident->string);
+  }
+}
+
 void applyAttrSection(StructLiteralExp *sle, llvm::GlobalObject *globj) {
   checkStructElems(sle, {Type::tstring});
   globj->setSection(getFirstElemString(sle));
@@ -233,6 +258,10 @@ void applyVarDeclUDAs(VarDeclaration *decl, llvm::GlobalVariable *gvar) {
     auto name = sle->sd->ident->string;
     if (name == attr::section) {
       applyAttrSection(sle, gvar);
+    } else if (name == attr::optStrat) {
+      sle->error(
+          "Special attribute 'ldc.attributes.optStrat' is only valid for "
+          "functions");
     } else if (name == attr::target) {
       sle->error("Special attribute 'ldc.attributes.target' is only valid for "
                  "functions");
@@ -265,6 +294,8 @@ void applyFuncDeclUDAs(FuncDeclaration *decl, IrFunction *irFunc) {
       applyAttrLLVMAttr(sle, func);
     } else if (name == attr::llvmFastMathFlag) {
       applyAttrLLVMFastMathFlag(sle, irFunc);
+    } else if (name == attr::optStrat) {
+      applyAttrOptStrat(sle, irFunc);
     } else if (name == attr::section) {
       applyAttrSection(sle, func);
     } else if (name == attr::target) {

runtime/druntime

@@ -0,0 +1,51 @@
+// RUN: %ldc -I%S -c -output-ll -O3 -of=%t.ll %s && FileCheck %s < %t.ll
+
+// REQUIRES: atleast_llvm307
+
+import ldc.attributes;
+import inputs.inlinables;
+
+extern (C): // For easier name mangling
+
+// CHECK-LABEL: define{{.*}} @call_easily_inlinable(
+// CHECK-SAME: #[[OPTNONE:[0-9]+]]
+@optStrat("none")
+int call_easily_inlinable(int i)
+{
+    // CHECK: call {{.*}} @easily_inlinable(
+    return easily_inlinable(i);
+    // CHECK-NOT: ret i32 2
+}
+
+// CHECK-LABEL: define{{.*}} @call_always_inline(
+@optStrat("none")
+int call_always_inline()
+{
+    // CHECK-NOT: call {{.*}} @always_inline()
+    return always_inline();
+}
+
+// CHECK-LABEL: define{{.*}} @call_optnone(
+int call_optnone()
+{
+    // CHECK: call {{.*}} @optnone_function()
+    return optnone_function();
+}
+
+// CHECK-LABEL: define{{.*}} @foo(
+// CHECK-SAME: #[[OPTSIZE:[0-9]+]]
+@optStrat("optsize")
+void foo()
+{
+}
+
+// CHECK-LABEL: define{{.*}} @foo2(
+// CHECK-SAME: #[[MINSIZE:[0-9]+]]
+@optStrat("minsize")
+void foo2()
+{
+}
+
+// CHECK-DAG: attributes #[[OPTNONE]] = {{.*}} optnone
+// CHECK-DAG: attributes #[[OPTSIZE]] = {{.*}} optsize
+// CHECK-DAG: attributes #[[MINSIZE]] = {{.*}} minsize

tests/codegen/attr_optstrat.d

@@ -76,6 +76,12 @@ class A
     return 654;
 }
 
+// optnone functions should not be inlined.
+@optStrat("none") int optnone_function()
+{
+    return 654;
+}
+
 int module_variable = 666;
 pragma(inline, true) void write_module_variable(int i)
 {