[lld] [llvm] [lld][AArch64][Build Attributes] Add support for converting AArch64 Build Attributes to GNU Properties (PR #131990)

[via llvm-commits]

================
@@ -207,6 +212,166 @@ static void updateSupportedARMFeatures(Ctx &ctx,
   ctx.arg.armHasThumb2ISA |= thumb && *thumb >= ARMBuildAttrs::AllowThumb32;
 }
 
+// Sanitize pauth values
+static void sanitizePauthSubSection(
+    Ctx &ctx, std::optional<llvm::BuildAttributeSubSection> &pauthSubSection,
+    InputSection isec) {
+  /*
+    Incomplete data: ignore
+  */
+  if (!pauthSubSection)
+    return;
+  // Currently there are 2 known tags defined for the pauth subsection,
+  // however, user is allowed to add other, unknown tag. If such tags exists,
+  // remove them. (no need to check for duplicates, they should not be possible)
+  pauthSubSection->Content.erase(
+      std::remove_if(pauthSubSection->Content.begin(),
+                     pauthSubSection->Content.end(),
+                     [](const BuildAttributeItem &item) {
+                       return item.Tag != 1 && item.Tag != 2;
+                     }),
+      pauthSubSection->Content.end());
+
+  if (pauthSubSection->Content.size() < 2) {
+    if (0 == pauthSubSection->Content.size())
+      Warn(ctx) << &isec
+                << ": AArch64 Build Attributes: empty 'aeabi_pauthabi' "
+                   "subsection detected; ignoring subsection";
+    if (1 == pauthSubSection->Content.size()) {
+      if (1 == pauthSubSection->Content[0].Tag)
+        Warn(ctx)
+            << &isec
+            << ": AArch64 Build Attributes: 'aeabi_pauthabi' subsection "
+               "contains only an ID (scheme missing); ignoring subsection";
+      if (2 == pauthSubSection->Content[0].Tag)
+        Warn(ctx) << &isec
+                  << ": AArch64 Build Attributes: 'aeabi_pauthabi' subsection "
+                     "contains only a scheme (ID missing); ignoring subsection";
+    }
+    pauthSubSection = std::nullopt;
+    return;
+  }
+  // printvec(*pauthSubSection);
+  assert(2 == pauthSubSection->Content.size() && "vector size should be 2");
+  std::sort(pauthSubSection->Content.begin(), pauthSubSection->Content.end(),
+            [](const auto &a, const auto &b) { return a.Tag < b.Tag; });
+  assert(1 == pauthSubSection->Content[0].Tag && "first tag should be 1");
+  assert(2 == pauthSubSection->Content[1].Tag && "first tag should be 2");
+}
+
+// Sanitize features bits
+static void sanitizeFAndBSubSection(
+    std::optional<llvm::BuildAttributeSubSection> &fAndBSubSection) {
+  /*
+    Same as gnu properties: treat a missing 'aeabi_feature_and_bits' feature as
+    being set to 0
+  */
+  if (!fAndBSubSection) {
+    fAndBSubSection.emplace("aeabi_feature_and_bits", 1, 0,
+                            SmallVector<BuildAttributeItem, 64>());
+  } else {
+    // Currently there are 3 known tags defined for the features and bits
+    // subsection, however, user is allowed to add other, unknown tag. If such
+    // tags exists, remove them. (duplicates are not possible)
+    fAndBSubSection->Content.erase(
+        std::remove_if(fAndBSubSection->Content.begin(),
+                       fAndBSubSection->Content.end(),
+                       [](const BuildAttributeItem &item) {
+                         return item.Tag != 0 && item.Tag != 1 && item.Tag != 2;
+                       }),
+        fAndBSubSection->Content.end());
+  }
+
+  constexpr unsigned tagBTI = 0, tagPAC = 1, tagGCS = 2;
+  // Find missing tags
+  std::set<unsigned> requiredTags = {tagBTI, tagPAC, tagGCS};
+  for (const auto &item : fAndBSubSection->Content)
+    requiredTags.erase(item.Tag);
+
+  // Add missing tags
+  for (const auto &tag : requiredTags)
+    fAndBSubSection->Content.push_back(
+        BuildAttributeItem(BuildAttributeItem::NumericAttribute, tag, 0, ""));
+
+  assert(3 == fAndBSubSection->Content.size() && "vector size should be 3");
+  std::sort(fAndBSubSection->Content.begin(), fAndBSubSection->Content.end(),
+            [](const auto &a, const auto &b) { return a.Tag < b.Tag; });
+  assert(0 == fAndBSubSection->Content[0].Tag && "first tag should be 0");
+  assert(1 == fAndBSubSection->Content[1].Tag && "first tag should be 1");
+  assert(2 == fAndBSubSection->Content[2].Tag && "first tag should be 2");
+}
+
+static std::array<std::optional<llvm::BuildAttributeSubSection>, 2>
+extractBuildAttributesSubsection(
+    Ctx &ctx,
+    const SmallVector<llvm::BuildAttributeSubSection, 8>
+        &buildAttributesSubsections,
+    InputSection isec) {
+
+  std::optional<llvm::BuildAttributeSubSection> newPauthSubSection;
+  std::optional<llvm::BuildAttributeSubSection> newFAndBSubSection;
+
+  for (const auto &newSubSection : buildAttributesSubsections) {
+    if (newPauthSubSection && newFAndBSubSection)
+      break;
+    if ("aeabi_pauthabi" == newSubSection.Name) {
+      newPauthSubSection.emplace(newSubSection);
+      continue;
+    }
+    if ("aeabi_feature_and_bits" == newSubSection.Name) {
+      newFAndBSubSection.emplace(newSubSection);
+    }
+  }
+  sanitizePauthSubSection(ctx, newPauthSubSection, isec);
+  sanitizeFAndBSubSection(newFAndBSubSection);
+
+  return {std::move(newPauthSubSection), std::move(newFAndBSubSection)};
+}
+
+// Merge AArch64 Build Attributes subsection
+static void mergeAArch64BuildAttributes(
+    Ctx &ctx,
+    const std::array<std::optional<llvm::BuildAttributeSubSection>, 2>
+        &buildAttributesSubsections,
+    InputSection isec) {
+
+  auto [newPauthSubSection, newFAndBSubSection] = buildAttributesSubsections;
+
+  if (ctx.mergedPauthSubSection == std::nullopt) {
+    ctx.mergedPauthSubSection = newPauthSubSection;
+  }
+
+  if (ctx.mergedFAndBSubSection == std::nullopt)
+    ctx.mergedFAndBSubSection = newFAndBSubSection;
+
+  if (newPauthSubSection) {
+    // Since sanitizePauthSubSection sorts, we know that both vectors align.
+    // Merge pauth (values has to match)
+    if ((ctx.mergedPauthSubSection->Content[0].IntValue !=
+         newPauthSubSection->Content[0].IntValue) ||
+        ctx.mergedPauthSubSection->Content[1].IntValue !=
+            newPauthSubSection->Content[1].IntValue) {
+      ctx.mergedPauthSubSection->Content[0].IntValue =
+          std::numeric_limits<unsigned>::max();
+      ctx.mergedPauthSubSection->Content[1].IntValue =
+          std::numeric_limits<unsigned>::max();
+      Warn(ctx)
+          << &isec
+          << ": AArch64 Build Attributes: mismatch in 'aeabi_pauthabi' values "
+             "detected; marking 'aeabi_pauthabi' as invalid for this project";
+    }
+  }
+
+  // Since sanitizeFAndBSubSection sorts, we know that both vectors align.
----------------
sivan-shani wrote:

Using vectors here was indeed needlessly complicated

https://github.com/llvm/llvm-project/pull/131990