[IR] make a new ModFlagBehavior that errors when a module attribute is missing

[nickdesaulniers]

Summary

Promote override-stack-alignment to use it.

The problem with this approach is:
it looks like it's not possible to create a module with such semantics
then test it properly with llvm-link. The reason is that llvm-link
is structured to start with an empty module ("Composite"), then link in
the first module specified on the command line, then link in the rest of
the modules specified. So we can't disambiguate between the initial
empty module being linked against the initial source file with the
MDNode vs 2 full modules where 1 is missing the MD node. (ie. for two
input source files, the main module linking logic is run twice, not
once).

[nickdesaulniers]

Not planning on shipping this, just a demonstration.

[nickdesaulniers]

See also: https://reviews.llvm.org/D103048#2804089

clang/test/CodeGen/stackrealign-main.c

int main(int argc, char **argv) {
   other();
   return 0;
 }
 
 // CHECK: attributes [[OTHER]] = { noinline nounwind optnone
 // CHECK-NOT: "stackrealign"
 // CHECK: }
 // CHECK: attributes [[MAIN]] = { noinline nounwind optnone {{.*}}"stackrealign"{{.*}} }
-// CHECK: !{i32 1, !"override-stack-alignment", i32 64}
+// CHECK: !{i32 8, !"override-stack-alignment", i32 64}
 // DEFAULT-NOT: "override-stack-alignment"

llvm/include/llvm-c/Core.h

 typedef enum {
   LLVMInlineAsmDialectATT,
   LLVMInlineAsmDialectIntel
 } LLVMInlineAsmDialect;
 
 typedef enum {
   /**
    * Emits an error if two values disagree, otherwise the resulting value is
-   * that of the operands.
+   * that of the operands. Does not error if one module has a value but the
+   * other does not.
    *
    * @see Module::ModFlagBehavior::Error
    */
   LLVMModuleFlagBehaviorError,
   /**
    * Emits a warning if two values disagree. The result value will be the
    * operand for the flag from the first module being linked.
    *
typedef enum {
   /**
    * Appends the two values, which are required to be metadata
    * nodes. However, duplicate entries in the second list are dropped
    * during the append operation.
    *
    * @see Module::ModFlagBehavior::AppendUnique
    */
   LLVMModuleFlagBehaviorAppendUnique,
+
+  /**
+   * Emits an error if two values disagree, or when a value is specified for
+   * one module, but not another.
+   *
+   * @see Module::ModFlagBehavior::ErrorWhenMissing
+   */
+  LLVMModuleFlagBehaviorErrorWhenMissing,
 } LLVMModuleFlagBehavior;
 
 /**
  * Attribute index are either LLVMAttributeReturnIndex,
  * LLVMAttributeFunctionIndex or a parameter number from 1 to N.
  */
 enum {
   LLVMAttributeReturnIndex = 0U,

llvm/include/llvm/IR/Module.h

public:
   /// The named metadata iterators.
   using named_metadata_iterator = NamedMDListType::iterator;
   /// The named metadata constant iterators.
   using const_named_metadata_iterator = NamedMDListType::const_iterator;
 
   /// This enumeration defines the supported behaviors of module flags.
   enum ModFlagBehavior {
     /// Emits an error if two values disagree, otherwise the resulting value is
-    /// that of the operands.
+    /// that of the operands. Does not produce an error if one module is
+    /// missing a value.
     Error = 1,
 
     /// Emits a warning if two values disagree. The result value will be the
     /// operand for the flag from the first module being linked.
     Warning = 2,
 
     /// Adds a requirement that another module flag be present and have a
     /// specified value after linking is performed. The value must be a metadata
enum ModFlagBehavior {
     /// Appends the two values, which are required to be metadata
     /// nodes. However, duplicate entries in the second list are dropped
     /// during the append operation.
     AppendUnique = 6,
 
     /// Takes the max of the two values, which are required to be integers.
     Max = 7,
 
+    /// Emits an error if two values disagree, or when a value is specified for
+    /// one module, but not another.
+    ErrorWhenMissing = 8,
+
     // Markers:
     ModFlagBehaviorFirstVal = Error,
-    ModFlagBehaviorLastVal = Max
+    ModFlagBehaviorLastVal = ErrorWhenMissing
   };
 
   /// Checks if Metadata represents a valid ModFlagBehavior, and stores the
   /// converted result in MFB.
   static bool isValidModFlagBehavior(Metadata *MD, ModFlagBehavior &MFB);
 
   /// Check if the given module flag metadata represents a valid module flag,
   /// and store the flag behavior, the key string and the value metadata.

llvm/lib/IR/Core.cpp

map_to_llvmModFlagBehavior(LLVMModuleFlagBehavior Behavior) {
   case LLVMModuleFlagBehaviorRequire:
     return Module::ModFlagBehavior::Require;
   case LLVMModuleFlagBehaviorOverride:
     return Module::ModFlagBehavior::Override;
   case LLVMModuleFlagBehaviorAppend:
     return Module::ModFlagBehavior::Append;
   case LLVMModuleFlagBehaviorAppendUnique:
     return Module::ModFlagBehavior::AppendUnique;
+  case LLVMModuleFlagBehaviorErrorWhenMissing:
+    return Module::ModFlagBehavior::ErrorWhenMissing;
   }
   llvm_unreachable("Unknown LLVMModuleFlagBehavior");
 }
 
 static LLVMModuleFlagBehavior
 map_from_llvmModFlagBehavior(Module::ModFlagBehavior Behavior) {
   switch (Behavior) {
   case Module::ModFlagBehavior::Error:
     return LLVMModuleFlagBehaviorError;
   case Module::ModFlagBehavior::Warning:
     return LLVMModuleFlagBehaviorWarning;
   case Module::ModFlagBehavior::Require:
     return LLVMModuleFlagBehaviorRequire;
   case Module::ModFlagBehavior::Override:
     return LLVMModuleFlagBehaviorOverride;
   case Module::ModFlagBehavior::Append:
     return LLVMModuleFlagBehaviorAppend;
   case Module::ModFlagBehavior::AppendUnique:
     return LLVMModuleFlagBehaviorAppendUnique;
+  case Module::ModFlagBehavior::ErrorWhenMissing:
+    return LLVMModuleFlagBehaviorErrorWhenMissing;
   default:
     llvm_unreachable("Unhandled Flag Behavior");
   }
 }
 
 LLVMModuleFlagEntry *LLVMCopyModuleFlagsMetadata(LLVMModuleRef M, size_t *Len) {
   SmallVector<Module::ModuleFlagEntry, 8> MFEs;
   unwrap(M)->getModuleFlagsMetadata(MFEs);

llvm/lib/IR/Module.cpp

 unsigned Module::getOverrideStackAlignment() const {
   Metadata *MD = getModuleFlag("override-stack-alignment");
   if (auto *CI = mdconst::dyn_extract_or_null<ConstantInt>(MD))
     return CI->getZExtValue();
   return 0;
 }
 
 void Module::setOverrideStackAlignment(unsigned Align) {
-  addModuleFlag(ModFlagBehavior::Error, "override-stack-alignment", Align);
+  addModuleFlag(ModFlagBehavior::ErrorWhenMissing, "override-stack-alignment",
+                Align);
 }
 
 void Module::setSDKVersion(const VersionTuple &V) {
   SmallVector<unsigned, 3> Entries;
   Entries.push_back(V.getMajor());
   if (auto Minor = V.getMinor()) {
     Entries.push_back(*Minor);
     if (auto Subminor = V.getSubminor())

llvm/lib/IR/Verifier.cpp

Verifier::visitModuleFlag(const MDNode *Op,
   Assert(ID, "invalid ID operand in module flag (expected metadata string)",
          Op->getOperand(1));
 
   // Sanity check the values for behaviors with additional requirements.
   switch (MFB) {
   case Module::Error:
   case Module::Warning:
   case Module::Override:
+  case Module::ErrorWhenMissing:
     // These behavior types accept any value.
     break;
 
   case Module::Max: {
     Assert(mdconst::dyn_extract_or_null<ConstantInt>(Op->getOperand(2)),
            "invalid value for 'max' module flag (expected constant integer)",
            Op->getOperand(2));
     break;

llvm/lib/Linker/IRMover.cpp

for (const NamedMDNode &NMD : SrcM->named_metadata()) {
     // Add Src elements into Dest node.
     for (const MDNode *Op : NMD.operands())
       DestNMD->addOperand(Mapper.mapMDNode(*Op));
   }
 }
 
 /// Merge the linker flags in Src into the Dest module.
 Error IRLinker::linkModuleFlagsMetadata() {
-  // If the source module has no module flags, we are done.
-  const NamedMDNode *SrcModFlags = SrcM->getModuleFlagsMetadata();
-  if (!SrcModFlags)
+  NamedMDNode *SrcModFlags = SrcM->getModuleFlagsMetadata();
+  NamedMDNode *DstModFlags = DstM.getOrInsertModuleFlagsMetadata();
+
+  // If the source module has no module flags, we still need to scan the
+  // destination module for any ErrorWhenMissing, otherwise we are done.
+  if (!SrcModFlags) {
+    for (MDNode *Op : DstModFlags->operands()) {
+      ConstantInt *Behavior = mdconst::extract<ConstantInt>(Op->getOperand(0));
+      if (Behavior->getZExtValue() == Module::ErrorWhenMissing) {
+        MDString *ID = cast<MDString>(Op->getOperand(1));
+        return stringErr("linking module flags '" + ID->getString() +
+                         "': IDs have conflicting behaviors in '" +
+                         SrcM->getModuleIdentifier() + "' and '" +
+                         DstM.getModuleIdentifier() + "'");
+      }
+    }
     return Error::success();
+  }
 
   // If the destination module doesn't have module flags yet, then just copy
-  // over the source module's flags.
-  NamedMDNode *DstModFlags = DstM.getOrInsertModuleFlagsMetadata();
+  // over the source module's flags. Make sure to check for any
+  // ErrorWhenMissing.
   if (DstModFlags->getNumOperands() == 0) {
-    for (unsigned I = 0, E = SrcModFlags->getNumOperands(); I != E; ++I)
-      DstModFlags->addOperand(SrcModFlags->getOperand(I));
+    for (MDNode *Op : SrcModFlags->operands()) {
+      ConstantInt *Behavior = mdconst::extract<ConstantInt>(Op->getOperand(0));
+      if (Behavior->getZExtValue() == Module::ErrorWhenMissing) {
+        MDString *ID = cast<MDString>(Op->getOperand(1));
+        // TODO: main case is now failing.
+        return stringErr("linking module flags '" + ID->getString() +
+                         "': IDs have conflicting behaviors in '" +
+                         SrcM->getModuleIdentifier() + "' and '" +
+                         DstM.getModuleIdentifier() + "'");
+      }
+      DstModFlags->addOperand(Op);
+    }
 
     return Error::success();
   }
 
   // First build a map of the existing module flags and requirements.
   DenseMap<MDString *, std::pair<MDNode *, unsigned>> Flags;
   SmallSetVector<MDNode *, 16> Requirements;
   for (unsigned I = 0, E = DstModFlags->getNumOperands(); I != E; ++I) {
if (DstBehaviorValue == Module::Max || SrcBehaviorValue == Module::Max) {
       continue;
     }
 
     // Perform the merge for standard behavior types.
     switch (SrcBehaviorValue) {
     case Module::Require:
     case Module::Override:
       llvm_unreachable("not possible");
-    case Module::Error: {
+    case Module::Error:
+    case Module::ErrorWhenMissing: {
       // Emit an error if the values differ.
       if (SrcOp->getOperand(2) != DstOp->getOperand(2))
         return stringErr("linking module flags '" + ID->getString() +
                          "': IDs have conflicting values in '" +
                          SrcM->getModuleIdentifier() + "' and '" +
                          DstM.getModuleIdentifier() + "'");
       continue;
     }

llvm/test/Linker/stack-alignment.ll

 ; RUN: split-file %s %t
-; TODO: it seems that ModFlagBehavior::Error doesn't error when a module is
-;       missing a module level attribute. IRLinker::linkModuleFlagsMetadata
-;       seems to think this is ok. Debugging stack mismatch errors is not a fun
-;       time.
-; RUN not llvm-link %t/main.ll %t/none.ll 2>&1 | FileCheck --check-prefix=NONE %s
+; RUN: not llvm-link %t/main.ll %t/none.ll 2>&1 | FileCheck --check-prefix=NONE %s
+; RUN: not llvm-link %t/none.ll %t/main.ll 2>&1 | FileCheck --check-prefix=NONE %s
 ; RUN: llvm-link %t/main.ll %t/8.ll
 ; RUN: not llvm-link %t/main.ll %t/16.ll 2>&1 | FileCheck --check-prefix=CHECK-16 %s
 
 ;--- main.ll
-; NONE: error: linking module flags 'override-stack-alignment': IDs have conflicting values
-; CHECK-16: error: linking module flags 'override-stack-alignment': IDs have conflicting values
+; NONE: error: linking module flags 'override-stack-alignment': IDs have conflicting behaviors
+; CHECK-16: error: linking module flags 'override-stack-alignment': IDs have conflicting behaviors
 !llvm.module.flags = !{!0}
-!0 = !{i32 1, !"override-stack-alignment", i32 8}
+!0 = !{i32 8, !"override-stack-alignment", i32 8}
 
 ;--- none.ll
 ;--- 8.ll
 !llvm.module.flags = !{!0}
-!0 = !{i32 1, !"override-stack-alignment", i32 8}
+!0 = !{i32 8, !"override-stack-alignment", i32 8}
 ;--- 16.ll
 !llvm.module.flags = !{!0}
-!0 = !{i32 1, !"override-stack-alignment", i32 16}
+!0 = !{i32 8, !"override-stack-alignment", i32 16}