Expand =/$SYSROOT for INPUT/GROUP script commands

This commit improves the script parser to expand
the = and $SYSROOT prefix in INPUT/GROUP inputs.

Resolves #927

Signed-off-by: Parth Arora <partaror@qti.qualcomm.com>

Author: parth-07

docs/userguide/CommandLineOptionsSupplements/sysroot.rst.in

@@ -6,6 +6,15 @@ The files specified using the INPUT and GROUP command are searched inside the sy
   - The file begins with the ``/`` character, and
   - The script containing the INPUT/GROUP command is located within the sysroot directory.
 
+Additionally, paths in INPUT/GROUP commands or on the command line can explicitly
+force sysroot expansion by using the ``=`` or ``$SYSROOT`` prefix:
+
+  - ``=/path/to/file`` expands to ``<sysroot>/path/to/file``
+  - ``$SYSROOT/path/to/file`` expands to ``<sysroot>/path/to/file``
+
+This works for both linker script commands and command-line input files.
+If no sysroot is configured, the prefix is stripped and the remaining path is used.
+
 :option:`-L` ``<search_directory>``
 
 When ``<search_directory>`` is prefixed with ``=``, then ``=`` is expanded to the sysroot.

include/eld/Diagnostics/DiagVerbose.inc

@@ -168,3 +168,5 @@ DIAG(verbose_loaded_plugin_config, DiagnosticEngine::Verbose,
 DIAG(verbose_infer_target, DiagnosticEngine::Verbose,
      "Inferred target : %0")
 DIAG(verbose_sframe_log, DiagnosticEngine::Verbose, "SFrame Handling : %0")
+DIAG(verbose_sysroot_expansion, DiagnosticEngine::Verbose,
+     "Expanded sysroot marker in path. '%0' -> '%1'")

include/eld/Input/Input.h

@@ -62,6 +62,14 @@ class Input {
   /// Return a user-facing text representation of input type.
   static llvm::StringRef toString(InputType);
 
+  /// Expand '=' or '$SYSROOT' prefix in the path using the configured sysroot.
+  /// Returns the expanded path, or the original if no marker is present.
+  /// If a marker is present but no sysroot is configured, the marker is
+  /// stripped. Emits verbose_sysroot_expansion diagnostic when expansion occurs.
+  static std::string expandSysrootMarkers(llvm::StringRef Name,
+                                          const SearchDirs &PSearchDirs,
+                                          DiagnosticEngine &DiagEngine);
+
   /// getFileName returns the FileName passed to the driver otherwise.
   const std::string getFileName() const { return FileName; }
 

lib/Input/Input.cpp

@@ -85,16 +85,40 @@ bool Input::isPathValid(const std::string &Path) const {
   return true;
 }
 
+std::string Input::expandSysrootMarkers(llvm::StringRef Name,
+                                        const SearchDirs &PSearchDirs,
+                                        DiagnosticEngine &DiagEngine) {
+  llvm::StringRef Suffix;
+  if (Name.starts_with("="))
+    Suffix = Name.substr(1);
+  else if (Name.starts_with("$SYSROOT"))
+    Suffix = Name.substr(strlen("$SYSROOT"));
+  else
+    return Name.str();
+
+  std::string ExpandedPath = Suffix.str();
+  if (PSearchDirs.hasSysRoot())
+    ExpandedPath = (PSearchDirs.sysroot().native() + Suffix).str();
+
+  DiagEngine.raise(Diag::verbose_sysroot_expansion) << Name << ExpandedPath;
+  return ExpandedPath;
+}
+
 /// \return True if path able to be resolved, otherwise false
 bool Input::resolvePath(const LinkerConfig &PConfig) {
   if (ResolvedPath)
     return true;
   if (PConfig.options().hasMappingFile() && !isInternal())
     return resolvePathMappingFile(PConfig);
   auto &PSearchDirs = PConfig.directories();
+
+  std::string ExpandedFileName = FileName;
+  if (Type == Input::InputType::Script || Type == Input::InputType::Default)
+    ExpandedFileName = expandSysrootMarkers(FileName, PSearchDirs, *DiagEngine);
+
   switch (Type) {
   default:
-    ResolvedPath = eld::sys::fs::Path(FileName);
+    ResolvedPath = eld::sys::fs::Path(ExpandedFileName);
     break;
   case Input::Internal:
     ResolvedPath = eld::sys::fs::Path(FileName);
@@ -103,10 +127,11 @@ bool Input::resolvePath(const LinkerConfig &PConfig) {
   if (Type == Input::Script) {
     if (shouldPrependSysrootToScriptInput(PConfig)) {
       ResolvedPath = PSearchDirs.sysroot();
-      ResolvedPath->append(FileName);
+      ResolvedPath->append(ExpandedFileName);
     }
     if (!llvm::sys::fs::exists(ResolvedPath->native())) {
-      const sys::fs::Path *P = PSearchDirs.find(FileName, Input::Script);
+      const sys::fs::Path *P =
+          PSearchDirs.find(ExpandedFileName, Input::InputType::Script);
       if (P != nullptr)
         ResolvedPath = *P;
     }

lib/Input/InputAction.cpp

@@ -44,10 +44,15 @@ InputFileAction::InputFileAction(std::string Name,
     : InputAction(K, Printer), Name(Name), I(nullptr) {}
 
 bool InputFileAction::activate(InputBuilder &PBuilder) {
+  const LinkerConfig &Config = PBuilder.getLinkerConfig();
+  std::string ExpandedName = Input::expandSysrootMarkers(
+      Name, Config.directories(), *Config.getDiagEngine());
+
   std::ifstream Is;
-  Is.open(Name.c_str(), std::ifstream::in);
+  Is.open(ExpandedName.c_str(), std::ifstream::in);
   if (!Is.good()) {
-    PBuilder.getDiagEngine()->raise(Diag::fatal_cannot_read_input) << Name;
+    PBuilder.getDiagEngine()->raise(Diag::fatal_cannot_read_input)
+        << ExpandedName;
     return false;
   }
   Is.close();

lib/ScriptParser/ScriptParser.cpp

@@ -744,9 +744,10 @@ void ScriptParser::addFile(StringRef Name) {
   if (Name.consume_front("-l"))
     InputStrTok = ThisScriptFile.createNameSpecToken(Name.str(),
                                                      ThisScriptFile.asNeeded());
-  else
+  else {
     InputStrTok =
         ThisScriptFile.createFileToken(Name.str(), ThisScriptFile.asNeeded());
+  }
   ThisScriptFile.getCurrentStringList()->pushBack(InputStrTok);
 }
 

test/Common/standalone/linkerscript/SysrootExpansion/Inputs/1.c

@@ -0,0 +1 @@
+int foo() { return 1; }

test/Common/standalone/linkerscript/SysrootExpansion/Inputs/group_equals.t

@@ -0,0 +1 @@
+GROUP(=/lib64/lib1.so)

test/Common/standalone/linkerscript/SysrootExpansion/Inputs/group_sysroot.t

@@ -0,0 +1 @@
+GROUP($SYSROOT/lib64/lib1.so)

test/Common/standalone/linkerscript/SysrootExpansion/Inputs/main.c

@@ -0,0 +1 @@
+int main() { return 0; }