linkerscript: fix ENTRY() last-wins and honour -e

EntryCmd::activate() guarded with hasEntry(), making the first ENTRY()
win over later ones and allowing script ENTRY() to overwrite a -e value
set on the command line.

Similar to GNU ld, replace the guard with !isEntryFromCmdLine() so
each ENTRY() overwrites the previous (last wins), while -e is always
preserved regardless of script processing order.

Add EntryCmdPrecedence.test covering: last-wins within one script,
-e override, last -e wins, raw-address -e 0, cross-script last-wins,
and -e placed before -T.

Resolves #1538

Signed-off-by: Rachit Mehta <rachmeht@qti.qualcomm.com>

Author: rachitmeht

include/eld/Config/GeneralOptions.h

@@ -759,6 +759,10 @@ class GeneralOptions {
 
   bool hasEntry() const;
 
+  void setEntryFromCmdLine();
+
+  bool isEntryFromCmdLine() const;
+
   llvm::ArrayRef<std::string> mapStyle() const { return MapStyles; }
 
   bool setMapStyle(llvm::StringRef MapStyle);
@@ -1395,6 +1399,7 @@ class GeneralOptions {
   std::vector<std::string> LTOOutputFile;
   std::optional<uint64_t> ImageBase; // --image-base=value
   std::string Entry;
+  bool EntryFromCmdLine = false;
   SymbolRenameMap SymbolRenames;
   AddressMapType AddressMap;
   std::vector<const char *> CommandLineArgs;

lib/Config/GeneralOptions.cpp

@@ -127,6 +127,10 @@ void GeneralOptions::setEntry(const std::string &PEntry) { Entry = PEntry; }
 
 bool GeneralOptions::hasEntry() const { return !Entry.empty(); }
 
+bool GeneralOptions::isEntryFromCmdLine() const { return EntryFromCmdLine; }
+
+void GeneralOptions::setEntryFromCmdLine() { EntryFromCmdLine = true; }
+
 void GeneralOptions::setTrace(bool EnableTrace) {
   DiagEngine->getPrinter()->setTrace(DiagEngine->getPrinter()->TraceFiles);
 }

lib/LinkerWrapper/GnuLdDriver.cpp

@@ -722,6 +722,7 @@ bool GnuLdDriver::processOptions(llvm::opt::InputArgList &Args) {
   // set up entry point from -e
   if (llvm::opt::Arg *arg = Args.getLastArg(T::entrypoint)) {
     Config.options().setEntry(arg->getValue());
+    Config.options().setEntryFromCmdLine();
     Config.addCommandLine(Table->getOptionName(T::entrypoint), arg->getValue());
   }
 

lib/Script/EntryCmd.cpp

@@ -32,7 +32,8 @@ void EntryCmd::dump(llvm::raw_ostream &Outs) const {
 }
 
 eld::Expected<void> EntryCmd::activate(Module &CurModule) {
-  if ((!EntrySymbol.empty()) && (!(CurModule.getConfig().options().hasEntry())))
-    CurModule.getConfig().options().setEntry(EntrySymbol);
+  GeneralOptions &Options = CurModule.getConfig().options();
+  if (!EntrySymbol.empty() && !Options.isEntryFromCmdLine())
+    Options.setEntry(EntrySymbol);
   return eld::Expected<void>();
 }

test/Common/standalone/linkerscript/EntryCmd/EntryCmdPrecedence.test

@@ -0,0 +1,50 @@
+#---EntryCmdPrecedence.test-------------- Executable,LS ----------------------#
+#BEGIN_COMMENT
+# Tests GNU ld entry point precedence rules:
+#   Case 1: Last ENTRY() in a single script wins over earlier ENTRY() commands.
+#   Case 2: Command-line -e always overrides any script ENTRY().
+#   Case 3: Last -e on command line wins over earlier -e.
+#   Case 4: -e with a raw address overrides script ENTRY().
+#   Case 5: Across multiple -T scripts, the last ENTRY() activated wins.
+#   Case 6: -e overrides script ENTRY() regardless of command-line order
+#           (i.e. -e placed before -T still wins).
+#
+# Input scripts fix symbol addresses so entry points can be verified with
+# literal address checks (same style as EntryCmd.test):
+#   two_entries.t  : bar=0x1000, foo=0x2000
+#   script.t       : foo=0x1000, bar=0x2000
+#   entry_foo.t    : bar=0x1000, foo=0x2000  (SECTIONS; entry_bar.t is ENTRY only)
+#END_COMMENT
+#START_TEST
+RUN: %clang %clangopts -c %p/Inputs/1.c -o %t1.o -ffunction-sections
+
+# Case 1: ENTRY(bar) then ENTRY(foo) in one script -- foo must win (last wins).
+RUN: %link %linkopts %t1.o -T %p/Inputs/two_entries.t -o %t.lastwins.out
+RUN: %readelf -h %t.lastwins.out | %filecheck %s --check-prefix=LASTWINS
+#LASTWINS: Entry point address: 0x2000
+
+# Case 2: -e bar overrides the script ENTRY(foo) -- command line always wins.
+RUN: %link %linkopts %t1.o -T %p/Inputs/two_entries.t -e bar -o %t.cmdline.out
+RUN: %readelf -h %t.cmdline.out | %filecheck %s --check-prefix=CMDLINE
+#CMDLINE: Entry point address: 0x1000
+
+# Case 3: -e foo -e bar -- bar must win (last -e wins).
+RUN: %link %linkopts %t1.o -T %p/Inputs/script.t -e foo -e bar -o %t.lastcmd.out
+RUN: %readelf -h %t.lastcmd.out | %filecheck %s --check-prefix=LASTCMD
+#LASTCMD: Entry point address: 0x2000
+
+# Case 4: -e 0 overrides script ENTRY(foo) -- entry must be 0x0.
+RUN: %link %linkopts %t1.o -T %p/Inputs/script.t -e 0 -o %t.rawaddr.out
+RUN: %readelf -h %t.rawaddr.out | %filecheck %s --check-prefix=RAWADDR
+#RAWADDR: Entry point address: 0x0
+
+# Case 5: Two separate scripts, ENTRY(bar) then ENTRY(foo) -- last script wins.
+RUN: %link %linkopts %t1.o -T %p/Inputs/entry_bar.t -T %p/Inputs/entry_foo.t -o %t.crossscript.out
+RUN: %readelf -h %t.crossscript.out | %filecheck %s --check-prefix=CROSSSCRIPT
+#CROSSSCRIPT: Entry point address: 0x2000
+
+# Case 6: -e bar placed BEFORE -T -- command line still wins over script ENTRY(foo).
+RUN: %link %linkopts %t1.o -e bar -T %p/Inputs/two_entries.t -o %t.eorder.out
+RUN: %readelf -h %t.eorder.out | %filecheck %s --check-prefix=EORDER
+#EORDER: Entry point address: 0x1000
+#END_TEST

test/Common/standalone/linkerscript/EntryCmd/Inputs/entry_bar.t

@@ -0,0 +1 @@
+ENTRY(bar)

test/Common/standalone/linkerscript/EntryCmd/Inputs/entry_foo.t

@@ -0,0 +1,7 @@
+ENTRY(foo)
+SECTIONS {
+  . = 0x1000;
+  .bar : { *(.text.bar) }
+  . = 0x2000;
+  .foo : { *(.text.foo) }
+}

test/Common/standalone/linkerscript/EntryCmd/Inputs/script.t

@@ -2,4 +2,6 @@ ENTRY(foo)
 SECTIONS {
   . = 0x1000;
   .foo : { *(.text.foo) }
+  . = 0x2000;
+  .bar : { *(.text.bar) }
 }

test/Common/standalone/linkerscript/EntryCmd/Inputs/two_entries.t

@@ -0,0 +1,8 @@
+ENTRY(bar)
+ENTRY(foo)
+SECTIONS {
+  . = 0x1000;
+  .bar : { *(.text.bar) }
+  . = 0x2000;
+  .foo : { *(.text.foo) }
+}