[reproduce] Preserve linker inputs when reproduce link fails

Capture linker scripts and unresolved namespecs when input
activation fails so the reproduce response preserves the original
failure. Avoid applying mapping-file resolution to unmapped
replay namespecs while retaining normal mapped namespec behavior.

Fix: #1014

Signed-off-by: Steven Ramirez Rosa <ramirezr@qti.qualcomm.com>

Author: Steven6798

include/eld/Input/Input.h

@@ -142,6 +142,10 @@ class Input {
   // -----------------------Namespec support -------------------------------
   bool resolvePath(const LinkerConfig &PConfig);
 
+  /// Resolve an input using reproduce mapping semantics.
+  /// Unmapped namespecs retain normal -l search behavior.
+  bool resolveReproducePath(const LinkerConfig &PConfig);
+
   bool resolvePathMappingFile(const LinkerConfig &PConfig);
 
   /// -------------------------Input Type ---------------------------

lib/Input/Input.cpp

@@ -77,6 +77,19 @@ bool Input::resolvePathMappingFile(const LinkerConfig &PConfig) {
   return true;
 }
 
+bool Input::resolveReproducePath(const LinkerConfig &PConfig) {
+  if (!PConfig.options().hasMappingFile() || isInternal())
+    return false;
+
+  // An unmapped namespec must retain normal -l search semantics. A namespec
+  // with an explicit mapping entry still uses mapping-file behavior so normal
+  // mapped links are unchanged.
+  if (Type == Input::Namespec && !PConfig.hasMappingForFile(FileName))
+    return false;
+
+  return resolvePathMappingFile(PConfig);
+}
+
 bool Input::isPathValid(const std::string &Path) const {
   if (llvm::sys::fs::is_directory(Path)) {
     DiagEngine->raise(Diag::fatal_cannot_read_input_err)
@@ -109,8 +122,8 @@ std::string Input::expandSysrootMarkers(llvm::StringRef Name,
 bool Input::resolvePath(const LinkerConfig &PConfig) {
   if (ResolvedPath)
     return true;
-  if (PConfig.options().hasMappingFile() && !isInternal())
-    return resolvePathMappingFile(PConfig);
+  if (resolveReproducePath(PConfig))
+    return true;
   // Apply --remap-inputs remappings (in order, first match wins).
   if (auto Replacement = PConfig.options().findRemapInput(FileName)) {
     if (PConfig.getPrinter()->isVerbose())

lib/LinkerWrapper/GnuLdDriver.cpp

@@ -1746,13 +1746,20 @@ bool GnuLdDriver::processReproduceOption(
       break;
     case T::l:
     case T::namespec: {
+      bool foundAction = false;
       for (size_t i = lastNamespecId + 1; i < actions.size(); ++i) {
         auto action = actions[i];
         if (action->getInputActionKind() == eld::InputAction::Namespec) {
+          foundAction = true;
           lastNamespecId = i;
           auto ipt = action->getInput();
-          if (!ipt)
-            return false;
+          // Input activation may have failed before this action was fully
+          // resolved. Preserve the original namespec so replay reports the
+          // same failure instead of silently dropping the input.
+          if (!ipt || !ipt->getInputFile()) {
+            os << arg->getSpelling() << arg->getValue() << ' ';
+            break;
+          }
           // Use the mapped path as the rewrite key. For a namespec input
           // e.g. "-l2", use "2" instead of "lib2.so". This will match the
           // form in the mapping file "2=SharedLibrary/2.<hash>".
@@ -1763,6 +1770,8 @@ bool GnuLdDriver::processReproduceOption(
           break;
         }
       }
+      if (!foundAction)
+        os << arg->getSpelling() << arg->getValue() << ' ';
       break;
     }
     case T::INPUT: {
@@ -1796,10 +1805,34 @@ bool GnuLdDriver::processReproduceOption(
          << getRewrittenRemappedPath(arg->getValue()) << ' ';
       break;
     case T::T: {
+      // Capture the script before looking for its activated action. Input
+      // activation can stop at an earlier failing input, leaving this action
+      // without an Input even though the script itself is readable.
+      std::string ScriptPath = Input::expandSysrootMarkers(
+          arg->getValue(), Config.directories(), *Config.getDiagEngine());
+      std::string ResolvedPath;
+      if (llvm::sys::fs::exists(ScriptPath))
+        ResolvedPath = ScriptPath;
+      else if (const eld::sys::fs::Path *Resolved = Config.directories().find(
+                   arg->getValue(), eld::SearchDirs::SearchInputType::Script))
+        ResolvedPath = Resolved->native();
+      if (!ResolvedPath.empty())
+        outputTar->createAndAddScriptFile(arg->getValue(), ResolvedPath);
+
       auto path = getRewrittenActionInputPath(eld::InputAction::Script,
                                               lastScriptId, arg->getValue());
-      if (!path)
-        return false;
+      if (!path) {
+        // A preceding input can fail before this script action is activated.
+        // Capture a script that can still be resolved so replay does not
+        // replace the original input error with a missing-script error.
+        if (!ResolvedPath.empty()) {
+          os << arg->getSpelling() << ' '
+             << outputTar->rewritePath(arg->getValue()) << ' ';
+        } else {
+          os << arg->getAsString(Args) << ' ';
+        }
+        break;
+      }
       os << arg->getSpelling() << ' ' << *path << ' ';
       break;
     }

test/Common/standalone/CommandLine/Reproduce/ReplayFailedInput.test

@@ -0,0 +1,27 @@
+#---ReplayFailedInput.test----------------------------- Executable ------------#
+#BEGIN_COMMENT
+# Verify that --reproduce captures a linker script and preserves an unresolved
+# namespec when an earlier input prevents normal input processing from reaching
+# the script.
+#END_COMMENT
+#START_TEST
+RUN: %rm %t.A %t.repro.tar %t.repro
+RUN: %mkdir %t.A
+RUN: %echo "INPUT(/lib1.so)" > %t.A/script.t
+RUN: %clang %clangopts -c %p/Inputs/1.c -o %t.1.o
+RUN: %clang %clangopts -c %p/Inputs/2.c -o %t.2.o
+RUN: %link %linkopts --no-default-plugins -shared -soname foo %t.1.o -o %t.A/lib1.so
+RUN: %not %link %linkopts --no-default-plugins %t.2.o -l1 -T %t.A/script.t \
+RUN:   -o %t.out --sysroot %t.A --reproduce %t.repro.tar 2>&1 | %filecheck %s --check-prefix=ORIGINAL
+RUN: %mkdir %t.repro
+RUN: cd %t.repro && %tar -xf %t.repro.tar --strip-components=1
+RUN: %filecheck %s --check-prefix=MAPPING < %t.repro/mapping.ini
+RUN: %filecheck %s --check-prefix=RESPONSE < %t.repro/response.txt
+RUN: cd %t.repro && %not bash response.txt 2>&1 | %filecheck %s --check-prefix=REPLAY
+
+ORIGINAL: Fatal: cannot recognize namespec -l1
+MAPPING: [Linker Scripts]
+MAPPING-NEXT: {{.*}}script.t=LinkerScript/
+RESPONSE: -l1
+REPLAY: Fatal: cannot recognize namespec -l1
+#END_TEST