Chnaged to platform agnostic names for llvm metadata and variables used

Author: Tony Varghese

clang/lib/CodeGen/CodeGenModule.cpp

@@ -42,6 +42,7 @@
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticFrontend.h"
 #include "clang/Basic/Module.h"
+#include "clang/Basic/PragmaKinds.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Basic/Version.h"
@@ -1569,10 +1570,10 @@ void CodeGenModule::Release() {
 
   EmitBackendOptionsMetadata(getCodeGenOpts());
 
-  // Emit copyright metadata for AIX
-  if (AIXCopyrightComment) {
-    auto *NMD = getModule().getOrInsertNamedMetadata("aix.copyright.comment");
-    NMD->addOperand(AIXCopyrightComment);
+  // Emit copyright metadata
+  if (CopyrightCommentInTU) {
+    auto *NMD = getModule().getOrInsertNamedMetadata("loadtime.copyright.comment");
+    NMD->addOperand(CopyrightCommentInTU);
   }
 
   // If there is device offloading code embed it in the host now.
@@ -3410,17 +3411,20 @@ void CodeGenModule::AddDependentLib(StringRef Lib) {
 
 /// Process the #pragma comment(copyright, "copyright string ")
 /// and create llvm metadata for the copyright
-void CodeGenModule::ProcessPragmaCommentCopyright(StringRef Comment) {
+void CodeGenModule::ProcessPragmaComment(PragmaMSCommentKind Kind,
+                                         StringRef Comment) {
 
-  if (!getTriple().isOSAIX())
+  if (!getTriple().isOSAIX() || Kind != PCK_Copyright)
     return;
 
+  assert(
+      !CopyrightCommentInTU &&
+      "Only one copyright comment should be present in the Translation Unit");
   // Create llvm metadata with the comment string
   auto &C = getLLVMContext();
   llvm::Metadata *Ops[] = {llvm::MDString::get(C, Comment.str())};
   auto *Node = llvm::MDNode::get(C, Ops);
-  if(!AIXCopyrightComment)
-    AIXCopyrightComment = Node;
+  CopyrightCommentInTU = Node;
 }
 
 /// Add link options implied by the given module, including modules
@@ -7604,7 +7608,7 @@ void CodeGenModule::EmitTopLevelDecl(Decl *D) {
       // Skip pragmas deserialized from modules/PCHs
       if (PCD->isFromASTFile())
         break;
-      ProcessPragmaCommentCopyright(PCD->getArg());
+      ProcessPragmaComment(PCD->getCommentKind(), PCD->getArg());
       break;
     case PCK_Compiler:
     case PCK_ExeStr:

clang/lib/CodeGen/CodeGenModule.h

@@ -587,9 +587,9 @@ class CodeGenModule : public CodeGenTypeCache {
   /// A vector of metadata strings for dependent libraries for ELF.
   SmallVector<llvm::MDNode *, 16> ELFDependentLibraries;
 
-  /// Single module-level copyright comment for AIX (if any).
+  /// Single module-level copyright comment (if any).
   /// We only ever accept one per TU.
-  llvm::MDNode *AIXCopyrightComment = nullptr;
+  llvm::MDNode *CopyrightCommentInTU = nullptr;
 
   /// @name Cache for Objective-C runtime types
   /// @{
@@ -1462,8 +1462,8 @@ class CodeGenModule : public CodeGenTypeCache {
   /// Appends a dependent lib to the appropriate metadata value.
   void AddDependentLib(StringRef Lib);
 
-  /// Record the AIX copyright comment in module-level metadata.
-  void ProcessPragmaCommentCopyright(StringRef Comment); 
+  /// Process pragma comment
+  void ProcessPragmaComment(PragmaMSCommentKind Kind, StringRef Comment); 
 
   llvm::GlobalVariable::LinkageTypes getFunctionLinkage(GlobalDecl GD);
 

clang/lib/Parse/ParsePragma.cpp

@@ -236,7 +236,7 @@ struct PragmaCommentHandler : public PragmaHandler {
 
 private:
   Sema &Actions;
-  bool SeenAIXCopyright = false; // TU-scoped
+  bool SeenCopyrightInTU = false; // TU-scoped
 };
 
 struct PragmaDetectMismatchHandler : public PragmaHandler {
@@ -3205,14 +3205,26 @@ void PragmaCommentHandler::HandlePragma(Preprocessor &PP,
   // Verify that this is one of the 5 explicitly listed options.
   IdentifierInfo *II = Tok.getIdentifierInfo();
   PragmaMSCommentKind Kind =
-    llvm::StringSwitch<PragmaMSCommentKind>(II->getName())
-    .Case("linker",   PCK_Linker)
-    .Case("lib",      PCK_Lib)
-    .Case("compiler", PCK_Compiler)
-    .Case("exestr",   PCK_ExeStr)
-    .Case("user",     PCK_User)
-    .Case("copyright", PCK_Copyright)
-    .Default(PCK_Unknown);
+      llvm::StringSwitch<PragmaMSCommentKind>(II->getName())
+          .Case("linker", PCK_Linker)
+          .Case("lib", PCK_Lib)
+          .Case("compiler", PCK_Compiler)
+          .Case("exestr", PCK_ExeStr)
+          .Case("user", PCK_User)
+          .Case("copyright", PCK_Copyright)
+          .Default(PCK_Unknown);
+
+  // Restrict copyright to AIX targets only
+  if (!PP.getTargetInfo().getTriple().isOSAIX()) {
+    switch (Kind) {
+    case PCK_Copyright:
+      Kind = PCK_Unknown;
+      break;
+    default:
+      break;
+    }
+  }
+
   if (Kind == PCK_Unknown) {
     PP.Diag(Tok.getLocation(), diag::err_pragma_comment_unknown_kind);
     return;
@@ -3225,13 +3237,13 @@ void PragmaCommentHandler::HandlePragma(Preprocessor &PP,
   }
 
   // On AIX, pragma comment copyright can each appear only once in a TU.
-  if (PP.getTargetInfo().getTriple().isOSAIX() && Kind == PCK_Copyright) {
-      if (SeenAIXCopyright) {
-        PP.Diag(Tok.getLocation(), diag::warn_pragma_comment_once)
-            << II->getName();
-        return;
-      }
-      SeenAIXCopyright = true;
+  if (Kind == PCK_Copyright) {
+    if (SeenCopyrightInTU) {
+      PP.Diag(Tok.getLocation(), diag::warn_pragma_comment_once)
+          << II->getName();
+      return;
+    }
+    SeenCopyrightInTU = true;
   }
 
   // Read the optional string if present.
@@ -3260,11 +3272,9 @@ void PragmaCommentHandler::HandlePragma(Preprocessor &PP,
     return;
   }
 
-  if (PP.getTargetInfo().getTriple().isOSAIX()) {
-    // Accept and ignore well-formed copyright with empty string.
-    if(Kind == PCK_Copyright && ArgumentString.empty())
-      return;
-  }
+  // Accept and ignore well-formed copyright with empty string.
+  if (Kind == PCK_Copyright && ArgumentString.empty())
+    return;
 
   // If the pragma is lexically sound, notify any interested PPCallbacks.
   if (PP.getPPCallbacks())

clang/test/CodeGen/PowerPC/pragma-comment-copyright-aix.c

@@ -20,7 +20,7 @@
 int main() { return 0; }
 
 // Check that both metadata sections are present
-// CHECK: !aix.copyright.comment = !{![[copyright:[0-9]+]]}
+// CHECK: !loadtime.copyright.comment = !{![[copyright:[0-9]+]]}
 
 // Check individual metadata content
 // CHECK: ![[copyright]] = !{!"@(#) Copyright"}

llvm/lib/Transforms/Utils/CopyrightMetadataPass.cpp

@@ -1,15 +1,15 @@
-//===-- CopyrightMetadataPass.cpp - Lower AIX copyright metadata ----------===//
+//===-- CopyrightMetadataPass.cpp - Lower copyright metadata -------------===//
 //
 // 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
 //
-//===----------------------------------------------------------------------===//
+//===---------------------------------------------------------------------===//
 //
 // CopyrightMetadataPass pass lowers module-level copyright metadata emitted by
 // Clang:
 //
-//     !aix.copyright.comment = !{!"Copyright ..."}
+//     !loadtime.copyright.comment = !{!"Copyright ..."}
 //
 // into concrete, translation-unit–local globals to ensure that copyright
 // strings:
@@ -20,8 +20,8 @@
 // For each module (translation unit), the pass performs the following:
 //
 //   1. Creates a null-terminated, internal constant string global
-//      (`__aix_copyright_str`) containing the copyright text in
-//      `__aix_copyright` section..
+//      (`__loadtime_copyright_str`) containing the copyright text in
+//      `__copyright_comment` section.
 //
 //   2. Marks the string in `llvm.used` so it cannot be dropped by
 //      optimization or LTO.
@@ -33,16 +33,16 @@
 //      discarding it (as long as the referencing symbol is kept).
 //
 //  Input IR:
-//     !aix.copyright.comment = !{!"Copyright"}
+//     !loadtime.copyright.comment = !{!"Copyright"}
 //  Output IR:
-//     @__aix_copyright_str = internal constant [N x i8] c"Copyright\00",
-//                          section "__aix_copyright"
-//     @llvm.used = appending global [1 x ptr] [ptr @__aix_copyright_str]
+//     @__loadtime_copyright_str = internal constant [N x i8] c"Copyright\00",
+//                          section "__copyright_comment"
+//     @llvm.used = appending global [1 x ptr] [ptr @__loadtime_copyright_str]
 //
 //     define i32 @func() !implicit.ref !5 { ... }
-//     !5 = !{ptr @__aix_copyright_str}
+//     !5 = !{ptr @__loadtime_copyright_str}
 //
-// The copyright string is placed in the "__aix_copyright" section (mapped to
+// The copyright string is placed in the "__copyright_comment" section (mapped to
 // an XCOFF csect with [RO] storage class), making it easily identifiable in
 // object files and executables. The R_REF relocation prevents the linker
 // from discarding this section during garbage collection.  Copyright string (if
@@ -90,9 +90,9 @@ PreservedAnalyses CopyrightMetadataPass::run(Module &M,
 
   LLVMContext &Ctx = M.getContext();
 
-  // Single-metadata: !aix.copyright.comment = !{!0}
+  // Single-metadata: !loadtime.copyright.comment = !{!0}
   // Each operand node is expected to have one MDString operand.
-  NamedMDNode *MD = M.getNamedMetadata("aix.copyright.comment");
+  NamedMDNode *MD = M.getNamedMetadata("loadtime.copyright.comment");
   if (!MD || MD->getNumOperands() == 0)
     return PreservedAnalyses::all();
 
@@ -117,23 +117,23 @@ PreservedAnalyses CopyrightMetadataPass::run(Module &M,
   auto *StrGV = new GlobalVariable(M, StrInit->getType(),
                                    /*isConstant=*/true,
                                    GlobalValue::InternalLinkage, StrInit,
-                                   /*Name=*/"__aix_copyright_str");
+                                   /*Name=*/"__loadtime_copyright_str");
   // Set unnamed_addr to allow the linker to merge identical strings
   StrGV->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
   StrGV->setAlignment(Align(1));
-  // Place in the "__aix_copyright" section.
+  // Place in the "__copyright_comment" section.
   // Backend maps this to an appropriate XCOFF csect (typically [RO])
   // The section will appear in assembly as:
-  //   .csect __aix_copyright[RO],2
-  StrGV->setSection("__aix_copyright");
+  //   .csect __copyright_comment[RO],2
+  StrGV->setSection("__copyright_comment");
 
   // 2. Add the string to llvm.used to prevent LLVM optimization/LTO passes from
   // removing it.
   appendToUsed(M, {StrGV});
 
   // 3. Attach !implicit ref to every defined function
   // Create a metadata node pointing to the copyright string:
-  //   !N = !{ptr @__aix_copyright_str}
+  //   !N = !{ptr @__loadtime_copyright_str}
   Metadata *Ops[] = {ConstantAsMetadata::get(StrGV)};
   MDNode *ImplicitRefMD = MDNode::get(Ctx, Ops);
 

llvm/test/CodeGen/PowerPC/pragma-comment-copyright-aix.ll

@@ -6,13 +6,14 @@
 ; RUN: opt --O2 -S %s -o - | FileCheck %s --check-prefixes=CHECK,CHECK-ON
 ; RUN: opt --O3 -S %s -o - | FileCheck %s --check-prefixes=CHECK,CHECK-ON
 
-; Verify that CopyrightMetadataPass lowers !aix.copyright.comment 
+; Verify that CopyrightMetadataPass lowers !loadtime.copyright.comment 
 ; into concrete, translation-unit–local globals.
 ;
 ; For each module (translation unit), the pass performs the following:
 ;
 ;   1. Creates a null-terminated, internal constant string global
-;      (`__aix_copyright_str`) containing the copyright text.
+;      (`__loadtime_copyright_str`) containing the copyright text in
+;      `__copyright_comment` section.
 ;
 ;   2. Marks the string in `llvm.used` so it cannot be dropped by
 ;      optimization or LTO.
@@ -37,14 +38,14 @@ entry:
 !llvm.module.flags = !{!0}
 !0 = !{i32 1, !"wchar_size", i32 2}
 
-!aix.copyright.comment = !{!1}
+!loadtime.copyright.comment = !{!1}
 !1 = !{!"@(#) Copyright IBM 2025"}
 
 
 ; ---- Globals--------------------------------------------
-; CHECK: @__aix_copyright_str = internal unnamed_addr constant [24 x i8] c"@(#) Copyright IBM 2025\00", section "__aix_copyright", align 1
+; CHECK: @__loadtime_copyright_str = internal unnamed_addr constant [24 x i8] c"@(#) Copyright IBM 2025\00", section "__copyright_comment", align 1
 ; Preservation in llvm.used sets
-; CHECK-NEXT: @llvm.used = appending global [1 x ptr] [ptr @__aix_copyright_str], section "llvm.metadata"
+; CHECK-NEXT: @llvm.used = appending global [1 x ptr] [ptr @__loadtime_copyright_str], section "llvm.metadata"
 ; CHECK-NOT: ![[copyright:[0-9]+]] = !{!"@(#) Copyright IBM 2025"}
 
 ; Function has an implicit ref MD pointing at the string:
@@ -54,5 +55,5 @@ entry:
 ; CHECK-ON: define noundef i32 @main() local_unnamed_addr #0 !implicit.ref ![[MD]]
 
 ; Verify metadata content
-; CHECK-O0: ![[MD]] = !{ptr @__aix_copyright_str}
-; CHECK-ON: ![[MD]] = !{ptr @__aix_copyright_str}
+; CHECK-O0: ![[MD]] = !{ptr @__loadtime_copyright_str}
+; CHECK-ON: ![[MD]] = !{ptr @__loadtime_copyright_str}