[lld][ELF] Implement –print-memory-usage

[phosek]

Summary

This option was introduced in GNU ld in
https://sourceware.org/legacy-ml/binutils/2015-06/msg00086.html and is
often used in embedded development. This change implements this option
in LLD matching the GNU ld output verbatim.

[peter.smith]

Looks like a useful feature to add, and I agree that keeping the same syntax as GNU is worthwhile.

lld/ELF/LinkerScript.cpp

1450

Wondering whether it is worth making length() and usedLength() member functions of MemoryRegion. I think the (m->length)().getValue() is used at least once in LinkerScript.cpp.

Not got a strong opinion here, it would just hide a bit of the code needed to access the expression.

lld/test/ELF/linkerscript/print-memory-usage1.s

3 ↗

(On Diff #522462)

More recent tests have used the split-file command to have the linker script and the assembler in the same file without needing a large echo command. This makes a bit easier to edit.

Will be worth checking with MaskRay to see his preference is though.

[phosek]

lld/test/ELF/linkerscript/print-memory-usage1.s

3 ↗

(On Diff #522462)

I was following the existing memory*.s test cases for consistency but I'm fine changing these to use split-file if that's @MaskRay's preference?

[MaskRay]

lld/test/ELF/linkerscript/print-memory-usage1.s

3 ↗

(On Diff #522462)

The linker script seems too long. Using split-file should be clearer for this test.

And consider combining print-memory-usage1.s and print-memory-usage2.s and print-memory-usage3.s into one file.

[peter.smith]

Thanks very much for the updates. LGTM

[phosek]

@MaskRay does this look good to you as well?

[MaskRay]

Some nits.

lld/ELF/LinkerScript.h

340

lld/test/ELF/linkerscript/print-memory-usage.s

5

14

When testing whitespace formatting, we should use --match-full-lines --strict-whitespace. See why-extract.s

[MaskRay]

lld/ELF/LinkerScript.cpp

1456

lld/test/ELF/linkerscript/print-memory-usage.s

18

If you want to test that there is not output after the header, use CHECK2-NOT: {{.}}

lld/ELF/Config.h

struct Config {
   bool optEB = false;
   bool optEL = false;
   bool optimizeBBJumps;
   bool optRemarksWithHotness;
   bool picThunk;
   bool pie;
   bool printGcSections;
   bool printIcfSections;
+  bool printMemoryUsage;
   bool relax;
   bool relaxGP;
   bool relocatable;
   bool relrGlibc = false;
   bool relrPackDynRelocs = false;
   llvm::DenseSet<llvm::StringRef> saveTempsArgs;
   llvm::SmallVector<std::pair<llvm::GlobPattern, uint32_t>, 0> shuffleSections;
   bool singleRoRx;

lld/ELF/Driver.cpp

static void readConfigs(opt::InputArgList &args) {
   config->orphanHandling = getOrphanHandling(args);
   config->outputFile = args.getLastArgValue(OPT_o);
   config->packageMetadata = args.getLastArgValue(OPT_package_metadata);
   config->pie = args.hasFlag(OPT_pie, OPT_no_pie, false);
   config->printIcfSections =
       args.hasFlag(OPT_print_icf_sections, OPT_no_print_icf_sections, false);
   config->printGcSections =
       args.hasFlag(OPT_print_gc_sections, OPT_no_print_gc_sections, false);
+  config->printMemoryUsage = args.hasArg(OPT_print_memory_usage);
   config->printArchiveStats = args.getLastArgValue(OPT_print_archive_stats);
   config->printSymbolOrder =
       args.getLastArgValue(OPT_print_symbol_order);
   config->relax = args.hasFlag(OPT_relax, OPT_no_relax, true);
   config->relaxGP = args.hasFlag(OPT_relax_gp, OPT_no_relax_gp, false);
   config->rpath = getRpath(args);
   config->relocatable = args.hasArg(OPT_relocatable);
 

lld/ELF/LinkerScript.h

struct MemoryRegion {
   // A section cannot be assigned to the region if any of these ELF section
   // flags are set...
   uint32_t negFlags;
   // ... or any of these flags are not set.
   // For example, the memory region attribute "!r" maps to SHF_WRITE.
   uint32_t negInvFlags;
   uint64_t curPos = 0;
 
+  uint64_t getOrigin() const { return origin().getValue(); }
+  uint64_t getLength() const { return length().getValue(); }
+
   bool compatibleWith(uint32_t secFlags) const {
     if ((secFlags & negFlags) || (~secFlags & negInvFlags))
       return false;
     return (secFlags & flags) || (~secFlags & invFlags);
   }
 };
 
 // This struct represents one section match pattern in SECTIONS() command.
public:
   void processSymbolAssignments();
   void declareSymbols();
 
   bool isDiscarded(const OutputSection *sec) const;
 
   // Used to handle INSERT AFTER statements.
   void processInsertCommands();
 
+  // Describe memory region usage.
+  void printMemoryUsage(raw_ostream &os);
+
   // SECTIONS command list.
   SmallVector<SectionCommand *, 0> sectionCommands;
 
   // PHDRS command list.
   SmallVector<PhdrsCommand, 0> phdrsCommands;
 
   bool hasSectionsCommand = false;
   bool errorOnMissingSection = false;

lld/ELF/LinkerScript.cpp

if (!cmdRef)
     cmdRef = make<OutputDesc>(name, SHT_PROGBITS, 0);
   return cmdRef;
 }
 
 // Expands the memory region by the specified size.
 static void expandMemoryRegion(MemoryRegion *memRegion, uint64_t size,
                                StringRef secName) {
   memRegion->curPos += size;
-  uint64_t newSize = memRegion->curPos - (memRegion->origin)().getValue();
-  uint64_t length = (memRegion->length)().getValue();
+  uint64_t newSize = memRegion->curPos - memRegion->getOrigin();
+  uint64_t length = memRegion->getLength();
   if (newSize > length)
     error("section '" + secName + "' will not fit in region '" +
           memRegion->name + "': overflowed by " + Twine(newSize - length) +
           " bytes");
 }
 
 void LinkerScript::expandMemoryRegions(uint64_t size) {
   if (state->memRegion)
for (StringRef s : cmd->phdrs) {
     if (std::optional<size_t> idx = getPhdrIndex(phdrsCommands, s))
       ret.push_back(*idx);
     else if (s != "NONE")
       error(cmd->location + ": program header '" + s +
             "' is not listed in PHDRS");
   }
   return ret;
 }
+
+void LinkerScript::printMemoryUsage(raw_ostream& os) {
+  auto printSize = [&](uint64_t size) {
+    if ((size & 0x3fffffff) == 0)
+      os << format_decimal(size >> 30, 10) << " GB";
+    else if ((size & 0xfffff) == 0)
+      os << format_decimal(size >> 20, 10) << " MB";
+    else if ((size & 0x3ff) == 0)
+      os << format_decimal(size >> 10, 10) << " KB";
+    else
+      os << " " << format_decimal(size, 10) << " B";
+  };
+  os << "Memory region         Used Size  Region Size  %age Used\n";
+  for (auto &pair : memoryRegions) {
+    MemoryRegion *m = pair.second;
+    uint64_t usedLength = m->curPos - m->getOrigin();
+    os << right_justify(m->name, 16) << ": ";
+    printSize(usedLength);
+    uint64_t length = m->getLength();
+    if (length != 0) {
+      printSize(length);
+      double percent = usedLength * 100.0 / length;
+      os << "    " << format("%6.2f%%", percent);
+    }
+    os << '\n';
+  }
+}

lld/ELF/Options.td

def pop_state: F<"pop-state">,
   HelpText<"Restore the states saved by --push-state">;
 
 def push_state: F<"push-state">,
   HelpText<"Save the current state of --as-needed, -static and --whole-archive">;
 
 def print_map: F<"print-map">,
   HelpText<"Print a link map to the standard output">;
 
+def print_memory_usage: F<"print-memory-usage">,
+  HelpText<"Report target memory usage">;
+
 defm relax: BB<"relax",
   "Enable target-specific relaxations if supported (default)",
   "Disable target-specific relaxations">;
 
 defm relax_gp: BB<"relax-gp",
   "Enable global pointer relaxation",
   "Disable global pointer relaxation (default)">;
 

lld/ELF/Writer.cpp

template <class ELFT> void Writer<ELFT>::run() {
   for (Partition &part : partitions)
     setPhdrs(part);
 
   // Handle --print-map(-M)/--Map and --cref. Dump them before checkSections()
   // because the files may be useful in case checkSections() or openFile()
   // fails, for example, due to an erroneous file size.
   writeMapAndCref();
 
+  // Handle --print-memory-usage option.
+  if (config->printMemoryUsage)
+    script->printMemoryUsage(lld::outs());
+
   if (config->checkSections)
     checkSections();
 
   // It does not make sense try to open the file if we have error already.
   if (errorCount())
     return;
 
   {

lld/test/ELF/linkerscript/print-memory-usage.s

+# REQUIRES: x86
+
+# RUN: rm -rf %t && split-file %s %t
+# RUN: llvm-mc -filetype=obj -triple=x86_64 %t/a1.s -o %t/a1.o
+# RUN: ld.lld -T %t/1.t %t/a1.o -o %t/a1 --print-memory-usage \
+# RUN:     | FileCheck %s --check-prefix=CHECK1 --match-full-lines --strict-whitespace
+# RUN: ld.lld -T %t/2.t %t/a1.o -o %t/a2 --print-memory-usage \
+# RUN:     | FileCheck %s --check-prefix=CHECK2 --match-full-lines --strict-whitespace
+# RUN: llvm-mc -filetype=obj -triple=x86_64 %t/a2.s -o %t/a2.o
+# RUN: ld.lld -T %t/3.t %t/a2.o -o %t/a3 --print-memory-usage \
+# RUN:     | FileCheck %s --check-prefix=CHECK3 --match-full-lines --strict-whitespace
+
+# CHECK1:Memory region         Used Size  Region Size  %age Used
+# CHECK1:             ROM:           4 B         1 KB      0.39%
+# CHECK1:             RAM:           4 B       256 KB      0.00%
+
+# CHECK2:Memory region         Used Size  Region Size  %age Used
+# CHECK2-NOT:{{.}}
+
+# CHECK3:Memory region         Used Size  Region Size  %age Used
+# CHECK3:             ROM:        256 KB         1 MB     25.00%
+# CHECK3:             RAM:          32 B         2 GB      0.00%
+
+#--- a1.s
+.text
+.globl _start
+_start:
+  .long 1
+
+.data
+.globl b
+b:
+  .long 2
+
+#--- a2.s
+.text
+.globl _start
+_start:
+  .space 256*1024
+
+.data
+.globl b
+b:
+  .space 32
+
+#--- 1.t
+MEMORY {
+  ROM (RX) : ORIGIN = 0x0, LENGTH = 1K
+  RAM (W)  : ORIGIN = 0x100000, LENGTH = 256K
+}
+SECTIONS {
+  . = 0;
+  .text : { *(.text) }
+  .data : { *(.data) }
+}
+
+#--- 2.t
+SECTIONS {
+  . = 0;
+  .text : { *(.text) }
+  .data : { *(.data) }
+}
+
+#--- 3.t
+MEMORY {
+  ROM (RX) : ORIGIN = 0x0, LENGTH = 1M
+  RAM (W)  : ORIGIN = 0x1000000, LENGTH = 2048M
+}
+SECTIONS {
+  . = 0;
+  .text : { *(.text) }
+  .data : { *(.data) }
+}