[LLD][ELF] Full support for -n (--nmagic) and -N (--omagic)

[peter.smith]

Summary

The -n (--nmagic) and -N (--omagic) options are used in non-paged environments such as embedded systems. They have the following documented
behavior:
--nmagic disables page alignment of OutputSections and disables linking against dynamic libraries.
--omagic is the same as --nmagic but additionally makes the text and data sections to be readable and writeable.
In addition to the documented behavior:

• We don't generate a PT_RELO as there are no pages.
• Unless explicitly instructed to by PHDRS we do not allocate the headers in the first program segment.
• The linkerscript expressions that refer to the max and common page size are unaffected.

fixes pr40542 https://bugs.llvm.org/show_bug.cgi?id=40542

Our previous implementation of -N in D26888 just made the text and data sections to be readable and writeable as this was sufficient for the use-case needed at the time. This change builds upon that to add the remaining behavior from GNU ld.bfd.

Implementation Notes:
I originally thought that this would be as simple as -n = --max-page-size=1, unfortunately we have both MaxPageSize which is configurable and Target->PageSize (often known as common-page-size) that isn't. It could be possible to make Target->PageSize configurable via implementing -z common-page-size, however while looking into GNU ld, it seems like the linkerscript expressions like COMMONPAGESIZE and MAXPAGESIZE are not affected by --nmagic or --omagic.

It is worth mentioning that it is not clear that LLD -n will give sensible results with the builtin layout which assumes paging. In practice using -n will require a linker script. I've tested against the aarch64 linux vdso which uses -n with its own linker script and it does give the required result.

Considered alternatives:

• Implement -z common-page-size (handle Target->PageSize in the way that we handle Config->MaxPageSize) and set both common and max page sizes to 1. This leaves the page calculations untouched but would also affect COMMONPAGESIZE and MAXPAGESIZE and other linker script expressions. This could break some scripts.
• Make specific versions of alignTo and alignDown for page alignment rather than calling them directly and then test for Config->Paged. I rejected this as we would need at least 4 functions to handle the combination of (To, Down) and (PageSize, MaxPageSize).

[srhines]

I had just a few small suggestions to make things more consistent. Feel free to ignore my fallthrough comment, but I feel like -Wimplicit-fallthrough has been quite valuable in Android.

ELF/Driver.cpp

1119

This should probably make use of LLVM_FALLTHROUGH.

ELF/Options.td

255

Instead of "and link" this should be just ", link" based on the existing usage.

[srhines]

ELF/Driver.cpp

1119

Actually ignore me. I for some reason thought that there was something else happening in the first case. -Wimplicit-fallthrough doesn't warn for this case, since it is obvious that you are handling both cases the same way.

[MaskRay]

ELF/Driver.cpp

826

Since --omagic implies --nmagic, we can probably use:

Config->Nmagic = Config->OMagic || Args.hasFlag(OPT_nmagic, OPT_no_nmagic, false);

and delete Config::Paged.

or

Config->Paged = !(Config->OMagic || Args.hasFlag(OPT_nmagic, OPT_no_nmagic, false));

958–961

Then, this will become if (Config->Nmagic) or if (!Config->Paged)

ELF/Writer.cpp

2082–2083

Do other occurrences of Config->MaxPageSize need similar changes?

i.e, what will happen if we do if (Config->Nmagic) Config->MaxPageSize = 1;

[grimar]

test/ELF/aarch64-script-nmagic.s

1 ↗

(On Diff #196876)

Can it be not AArch64 specific test, but generic, i.e. x86?

21 ↗

(On Diff #196876)

This like does not have any FileCheck.

21 ↗

(On Diff #196876)

like->line

31 ↗

(On Diff #196876)

Should this test live in the linkerscript folder?

Looks like this place could shorter, like:

.text
  ret

If then perhaps this test should be .test, not .s,
like we often do for linker script tests.

[peter.smith]

Thanks all for the comments. I'll upload a new diff with the changes shortly.

ELF/Driver.cpp

826

I've gone for the second option (Config->Paged) as I think that disabling Page Alignment when Config->Paged == false makes much more sense than referring directly to Omagic and Nmagic as these option names aren't self describing.

ELF/Writer.cpp

2082–2083

Do other occurrences of Config->MaxPageSize need similar changes?

I don't think any other occurrences need changing in the current implementation, there are some raw uses of Config->MaxPageSize and Target->PageSize but these are not called unless Config->Paged. For example writeTrapInstr() will early exit unless Config->Paged. I thought of wrapping all calls to Config->MaxPageSize and Target->PageSize with a function that substituted 1 if !Config->Paged, I thought that might hide the intention behind the code too much. I don't have a strong opinion so I'd be happy to do this another way.

i.e, what will happen if we do if (Config->Nmagic) Config->MaxPageSize = 1;

I'm not sure I fully understand here, I think what you mean is that if we make Config->NMagic set Config->MaxPageSize = 1 then will everything work? My first implementation did that but I ran across a couple of problems:

• The Target->PageSize is unaffected which causes problems as there seems to be a working assumption that this is smaller than MaxPageSize
• Use of -n and -N in ld.bfd does not affect the linkerscript commands that refer to Config->MaxPageSize and Target->PageSize such as COMMONPAGESIZE, MAXPAGESIZE, DATA_SEGMENT_RELRO_END. I have my suspicion that these were not supposed to be used in a linker script that uses -N and -n but I prefer consistency where possible.

I think there are some alternative implementations that could work:

• Handle Target->PageSize like Config->MaxPageSize and set them both to 1 (would affect linker scripts as above, but most likely minor).
• Have Config->Paged skip any use of Target->PageSize

Hope I've interpreted that question the right way?

test/ELF/aarch64-script-nmagic.s

1 ↗

(On Diff #196876)

Sure, I've changed it to x86 (just need to change the alignment to 4096).

21 ↗

(On Diff #196876)

Thanks for the spot, now fixed.

[peter.smith]

Updated diff to address review comments. Main changes:

• Removed Config->Nmagic in favour of just using Config->Paged
• Moved test to linkerscript, converted to .test and switched to x86

[grimar]

Generally looks good I think. Few more comments/suggestions from me.

ELF/Config.h

167

Should it be here? I think it is the place for the flags that
are named similar to a command line option. Since there is no --paged option,
should it be below, under the following comment?

(line 232)
 // The following config options do not directly correspond to any
 // particualr command line options.

ELF/Driver.cpp

907

Not sure why Page Alignment of Sections are in upper case here..

1122

Should it be combined with case OPT_Bstatic?
That would be easier to find all the options that affect a particular flag, what is better I think.

ELF/Options.td

222

You should update lld\docs\ld.lld.1 I think after adding an option.
The same for below ones.

[grimar]

test/ELF/linkerscript/nmagic-alignment.test

10

Ah, and here instead of adding an input, I think you can just do:

# RUN: echo ".text; .globl foo; foo: nop" > %t.s
# RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %t.s -o %t.o

(We often use echo in *.test for minor asm pieces)

[peter.smith]

Thanks for the suggestions I'll apply and upload a new diff.

[peter.smith]

Updated diff for review comments. Main changes:

• Move location of Config::Paged
• Update captitalisation in comments
• Add documentation
• Use echo in linkerscript test

[grimar]

LGTM with a nit.

docs/ld.lld.1

258

You also need to document at least --no-nmagic, since it is added by this patch.

(ideally we want to document --no-omagic too)

[MaskRay]

ELF/Writer.cpp

2082–2083

I think what you mean is that if we make Config->NMagic set Config->MaxPageSize = 1 then will everything work?

That was my question. Thank you for the explanation.

I also asked this in the binutils-gdb bugzilla https://sourceware.org/bugzilla/show_bug.cgi?id=24505
I will forward their responses.

[peter.smith]

Thanks for the review, I'll update the docs for --no-omagic and --no-nmagic and will wait for the response to MaskRay's question before committing just in case it changes anything significant.

[MaskRay]

https://sourceware.org/bugzilla/show_bug.cgi?id=24505 doesn't get a response, but I researched the users of CONSTANT(...):

CONSTANT(COMMONPAGESIZE): 2 users: edk2, u-boot
CONSTANT(MAXPAGESIZE): 1 user: fuchsia zircon, but they don't use -n or -N

u-boot and fuchsia zircon don't seem to use -n or -N. edk2 is probably the only project that uses both -n/-N and CONSTANT(...). It has DEFINE GCC44_IA32_X64_DLINK_COMMON = -nostdlib -Wl,-n,-q,--gc-sections -z common-page-size=0x20

We probably shouldn't be constrained by ld.bfd's behavior for this single user,
if making MaxPageSize and PageSize to 1 makes our implementation simpler.

The potential users can make straightforward changes to adapt to lld's behavior: change CONSTANT(COMMONPAGESIZE) to a literal constant.

[peter.smith]

In D61201#1491977, @MaskRay wrote:

https://sourceware.org/bugzilla/show_bug.cgi?id=24505 doesn't get a response, but I researched the users of CONSTANT(...):

CONSTANT(COMMONPAGESIZE): 2 users: edk2, u-boot
CONSTANT(MAXPAGESIZE): 1 user: fuchsia zircon, but they don't use -n or -N

u-boot and fuchsia zircon don't seem to use -n or -N. edk2 is probably the only project that uses both -n/-N and CONSTANT(...). It has DEFINE GCC44_IA32_X64_DLINK_COMMON = -nostdlib -Wl,-n,-q,--gc-sections -z common-page-size=0x20

We probably shouldn't be constrained by ld.bfd's behavior for this single user,
if making MaxPageSize and PageSize to 1 makes our implementation simpler.

The potential users can make straightforward changes to adapt to lld's behavior: change CONSTANT(COMMONPAGESIZE) to a literal constant.

I'll make an alternative implementation that in effect implements -z common-page, and have -n/-N set it to 1 and will post as a separate review. It will probably be of similar complexity to this. In the example above it does look to be using -z common-page-size and CONSTANT(COMMONPAGESIZE) as a way of passing a parameter to the linker script.

[peter.smith]

In D61201#1493631, @peter.smith wrote:

In D61201#1491977, @MaskRay wrote:

https://sourceware.org/bugzilla/show_bug.cgi?id=24505 doesn't get a response, but I researched the users of CONSTANT(...):

CONSTANT(COMMONPAGESIZE): 2 users: edk2, u-boot
CONSTANT(MAXPAGESIZE): 1 user: fuchsia zircon, but they don't use -n or -N

u-boot and fuchsia zircon don't seem to use -n or -N. edk2 is probably the only project that uses both -n/-N and CONSTANT(...). It has DEFINE GCC44_IA32_X64_DLINK_COMMON = -nostdlib -Wl,-n,-q,--gc-sections -z common-page-size=0x20

We probably shouldn't be constrained by ld.bfd's behavior for this single user,
if making MaxPageSize and PageSize to 1 makes our implementation simpler.

The potential users can make straightforward changes to adapt to lld's behavior: change CONSTANT(COMMONPAGESIZE) to a literal constant.

I'll make an alternative implementation that in effect implements -z common-page, and have -n/-N set it to 1 and will post as a separate review. It will probably be of similar complexity to this. In the example above it does look to be using -z common-page-size and CONSTANT(COMMONPAGESIZE) as a way of passing a parameter to the linker script.

I've implemented the alternative with the max and common page size set to 1 in D61688 . I'll leave this open as I think the complexity of the implementation is similar.

[peter.smith]

Abandoned in favour of a different approach D61688

ELF/Config.h

struct Configuration {
   bool LTONewPassManager;
   bool MergeArmExidx;
   bool MipsN32Abi = false;
   bool NoinhibitExec;
   bool Nostdlib;
   bool OFormatBinary;
   bool Omagic;
   bool OptRemarksWithHotness;
   bool PicThunk;
   bool Pie;
   bool PrintGcSections;
   bool PrintIcfSections;
   bool Relocatable;
   bool RelrPackDynRelocs;
   bool SaveTemps;
   bool SingleRoRx;
   bool Shared;
struct Configuration {
   // been easier to write code to process relocations, but it's too late
   // to change the spec.)
   //
   // Each ABI defines its relocation type. IsRela is true if target
   // uses RELA. As far as we know, all 64-bit ABIs are using RELA. A
   // few 32-bit ABIs are using RELA too.
   bool IsRela;
 
+  // True if we are page aligning sections.
+  bool Paged;
+  
   // True if we are creating position-independent code.
   bool Pic;
 
   // 4 for ELF32, 8 for ELF64.
   int Wordsize;
 };
 
 // The only instance of Configuration struct.

ELF/Driver.cpp

void LinkerDriver::readConfigs(opt::InputArgList &Args) {
   Config->LTOO = args::getInteger(Args, OPT_lto_O, 2);
   Config->LTOObjPath = Args.getLastArgValue(OPT_plugin_opt_obj_path_eq);
   Config->LTOPartitions = args::getInteger(Args, OPT_lto_partitions, 1);
   Config->LTOSampleProfile = Args.getLastArgValue(OPT_lto_sample_profile);
   Config->MapFile = Args.getLastArgValue(OPT_Map);
   Config->MipsGotSize = args::getInteger(Args, OPT_mips_got_size, 0xfff0);
   Config->MergeArmExidx =
       Args.hasFlag(OPT_merge_exidx_entries, OPT_no_merge_exidx_entries, true);
   Config->NoinhibitExec = Args.hasArg(OPT_noinhibit_exec);
   Config->Nostdlib = Args.hasArg(OPT_nostdlib);
   Config->OFormatBinary = isOutputFormatBinary(Args);
   Config->Omagic = Args.hasFlag(OPT_omagic, OPT_no_omagic, false);
   Config->OptRemarksFilename = Args.getLastArgValue(OPT_opt_remarks_filename);
   Config->OptRemarksPasses = Args.getLastArgValue(OPT_opt_remarks_passes);
   Config->OptRemarksWithHotness = Args.hasArg(OPT_opt_remarks_with_hotness);
   Config->Optimize = args::getInteger(Args, OPT_O, 1);
   Config->OrphanHandling = getOrphanHandling(Args);
void LinkerDriver::readConfigs(opt::InputArgList &Args) {
   Config->ZOrigin = hasZOption(Args, "origin");
   Config->ZRelro = getZFlag(Args, "relro", "norelro", true);
   Config->ZRetpolineplt = hasZOption(Args, "retpolineplt");
   Config->ZRodynamic = hasZOption(Args, "rodynamic");
   Config->ZStackSize = args::getZOptionValue(Args, OPT_z, "stack-size", 0);
   Config->ZText = getZFlag(Args, "text", "notext", true);
   Config->ZWxneeded = hasZOption(Args, "wxneeded");
 
+  // -n (--nmagic) and -N (--omagic) disable page alignment of sections.
+  Config->Paged = !(Config->Omagic ||
+                    Args.hasFlag(OPT_nmagic, OPT_no_nmagic, false));
+
   // Parse LTO options.
   if (auto *Arg = Args.getLastArg(OPT_plugin_opt_mcpu_eq))
     parseClangOption(Saver.save("-mcpu=" + StringRef(Arg->getValue())),
                      Arg->getSpelling());
 
   for (auto *Arg : Args.filtered(OPT_plugin_opt))
     parseClangOption(Arg->getValue(), Arg->getSpelling());
 
else if (S == "both")
       Config->SysvHash = Config->GnuHash = true;
     else
       error("unknown -hash-style: " + S);
   }
 
   if (Args.hasArg(OPT_print_map))
     Config->MapFile = "-";
 
-  // --omagic is an option to create old-fashioned executables in which
-  // .text segments are writable. Today, the option is still in use to
-  // create special-purpose programs such as boot loaders. It doesn't
-  // make sense to create PT_GNU_RELRO for such executables.
-  if (Config->Omagic)
+  // Page alignment can be disabled by the -n (--nmagic) and -N (--omagic).
+  // As PT_GNU_RELRO relies on Paging, do not create it when we have disabled
+  // it.
+  if (!Config->Paged)
     Config->ZRelro = false;
 
   std::tie(Config->BuildId, Config->BuildIdVector) = getBuildId(Args);
 
   std::tie(Config->AndroidPackDynRelocs, Config->RelrPackDynRelocs) =
       getPackDynRelocs(Args);
 
   if (auto *Arg = Args.getLastArg(OPT_symbol_ordering_file))
case OPT_no_as_needed:
       Config->AsNeeded = false;
       break;
     case OPT_Bstatic:
       Config->Static = true;
       break;
     case OPT_Bdynamic:
       Config->Static = false;
       break;
+    case OPT_omagic:
+    case OPT_nmagic:
+      Config->Static = true;
+      break;
     case OPT_whole_archive:
       InWholeArchive = true;
       break;
     case OPT_no_whole_archive:
       InWholeArchive = false;
       break;
     case OPT_just_symbols:
       if (Optional<MemoryBufferRef> MB = readFile(Arg->getValue())) {

ELF/LinkerScript.cpp

if (It == Phdrs.end())
     return;
   PhdrEntry *FirstPTLoad = *It;
 
   bool HasExplicitHeaders =
       llvm::any_of(PhdrsCommands, [](const PhdrsCommand &Cmd) {
         return Cmd.HasPhdrs || Cmd.HasFilehdr;
       });
   uint64_t HeaderSize = getHeaderSize();
-  if (HeaderSize <= Min - computeBase(Min, HasExplicitHeaders)) {
+  if ((Config->Paged || HasExplicitHeaders) &&
+      HeaderSize <= Min - computeBase(Min, HasExplicitHeaders)) {
     Min = alignDown(Min - HeaderSize, Config->MaxPageSize);
     Out::ElfHeader->Addr = Min;
     Out::ProgramHeaders->Addr = Min + Out::ElfHeader->Size;
     return;
   }
 
   // Error if we were explicitly asked to allocate headers.
   if (HasExplicitHeaders)

ELF/Options.td

 def m: JoinedOrSeparate<["-"], "m">, HelpText<"Set target emulation">;
 
 defm Map: Eq<"Map", "Print a link map to the specified file">;
 
 defm merge_exidx_entries: B<"merge-exidx-entries",
     "Enable merging .ARM.exidx entries (default)",
     "Disable merging .ARM.exidx entries">;
 
+def nmagic: F<"nmagic">, MetaVarName<"<magic>">,
+  HelpText<"Do not page align sections, link against static libraries.">;
+
 def nostdlib: F<"nostdlib">,
   HelpText<"Only search directories specified on the command line">;
 
 def no_color_diagnostics: F<"no-color-diagnostics">,
   HelpText<"Do not use colors in diagnostics">;
 
 def no_dynamic_linker: F<"no-dynamic-linker">,
   HelpText<"Inhibit output of .interp section">;
 
 def noinhibit_exec: F<"noinhibit-exec">,
   HelpText<"Retain the executable output file whenever it is still usable">;
 
+def no_nmagic: F<"no-nmagic">, MetaVarName<"<magic>">,
+  HelpText<"Page align sections.">;
+
 def no_omagic: F<"no-omagic">, MetaVarName<"<magic>">,
-  HelpText<"Do not set the text data sections to be writable">;
+  HelpText<"Do not set the text data sections to be writable, page align sections">;
 
 def no_rosegment: F<"no-rosegment">,
   HelpText<"Do not put read-only non-executable sections in their own segment">;
 
 def no_undefined: F<"no-undefined">,
   HelpText<"Report unresolved symbols even if the linker is creating a shared library">;
 
 def o: JoinedOrSeparate<["-"], "o">, MetaVarName<"<path>">,
   HelpText<"Path to file to write output">;
 
 def oformat: Separate<["--"], "oformat">, MetaVarName<"<format>">,
   HelpText<"Specify the binary format for the output object file">;
 
 def omagic: Flag<["--"], "omagic">, MetaVarName<"<magic>">,
-  HelpText<"Set the text and data sections to be readable and writable">;
+  HelpText<"Set the text and data sections to be readable and writable, do not page align sections, link against static libraries">;
 
 defm orphan_handling:
   Eq<"orphan-handling", "Control how orphan sections are handled when linker script used">;
 
 defm pack_dyn_relocs:
   Eq<"pack-dyn-relocs", "Pack dynamic relocations in the given format">,
   MetaVarName<"[none,android,relr,android+relr]">;
 

 def: Flag<["-"], ")">, Alias<end_group>, HelpText<"Alias for --end-group">;
 def: JoinedOrSeparate<["-"], "e">, Alias<entry>, HelpText<"Alias for --entry">;
 def: Flag<["-"], "E">, Alias<export_dynamic>, HelpText<"Alias for --export-dynamic">;
 def: Separate<["-"], "F">, Alias<filter>, HelpText<"Alias for --filter">;
 def: Separate<["-"], "b">, Alias<format>, HelpText<"Alias for --format">;
 def: JoinedOrSeparate<["-"], "l">, Alias<library>, HelpText<"Alias for --library">;
 def: JoinedOrSeparate<["-"], "L">, Alias<library_path>, HelpText<"Alias for --library-path">;
 def: F<"no-pic-executable">, Alias<no_pie>, HelpText<"Alias for --no-pie">;
+def: Flag<["-"], "n">, Alias<nmagic>, HelpText<"Alias for --nmagic">;
 def: Flag<["-"], "N">, Alias<omagic>, HelpText<"Alias for --omagic">;
 def: Joined<["--"], "output=">, Alias<o>, HelpText<"Alias for -o">;
 def: Separate<["--"], "output">, Alias<o>, HelpText<"Alias for -o">;
 def: F<"pic-executable">, Alias<pie>, HelpText<"Alias for --pie">;
 def: Flag<["-"], "M">, Alias<print_map>, HelpText<"Alias for --print-map">;
 def: Flag<["-"], "r">, Alias<relocatable>, HelpText<"Alias for --relocatable">;
 def: JoinedOrSeparate<["-"], "R">, Alias<rpath>, HelpText<"Alias for --rpath">;
 def: JoinedOrSeparate<["-"], "T">, Alias<script>, HelpText<"Alias for --script">;

ELF/Writer.cpp

template <class ELFT> void Writer<ELFT>::finalizeSections() {
   finalizeSynthetic(In.RelaPlt);
   finalizeSynthetic(In.Plt);
   finalizeSynthetic(In.Iplt);
   finalizeSynthetic(In.EhFrameHdr);
   finalizeSynthetic(In.VerSym);
   finalizeSynthetic(In.VerNeed);
   finalizeSynthetic(In.Dynamic);
 
-  if (!Script->HasSectionsCommand && !Config->Relocatable)
+  if (!Script->HasSectionsCommand && !Config->Relocatable && Config->Paged)
     fixSectionAlignments();
 
   // SHFLinkOrder processing must be processed after relative section placements are
   // known but before addresses are allocated.
   resolveShfLinkOrder();
 
   // This is used to:
   // 1) Create "thunks":
static uint64_t computeFileOffset(OutputSection *OS, uint64_t Off) {
   // If the section is not in a PT_LOAD, we just have to align it.
   if (!OS->PtLoad)
     return alignTo(Off, OS->Alignment);
 
   // The first section in a PT_LOAD has to have congruent offset and address
   // module the page size.
   OutputSection *First = OS->PtLoad->FirstSec;
   if (OS == First) {
-    uint64_t Alignment = std::max<uint64_t>(OS->Alignment, Config->MaxPageSize);
+    uint64_t PageSize = Config->Paged ? Config->MaxPageSize : 1;
+    uint64_t Alignment = std::max<uint64_t>(OS->Alignment, PageSize);
     return alignTo(Off, Alignment, OS->Addr);
   }
 
   // If two sections share the same PT_LOAD the file offset is calculated
   // using this formula: Off2 = Off1 + (VA2 - VA1).
   return First->Offset + OS->Addr - First->Addr;
 }
 
template <class ELFT> void Writer<ELFT>::assignFileOffsets() {
   for (OutputSection *Sec : OutputSections) {
     Off = setFileOffset(Sec, Off);
     if (Script->HasSectionsCommand)
       continue;
 
     // If this is a last section of the last executable segment and that
     // segment is the last loadable segment, align the offset of the
     // following section to avoid loading non-segments parts of the file.
-    if (LastRX && LastRX->LastSec == Sec)
+    if (LastRX && LastRX->LastSec == Sec && Config->Paged)
       Off = alignTo(Off, Target->PageSize);
   }
 
   SectionHeaderOff = alignTo(Off, Config->Wordsize);
   FileSize = SectionHeaderOff + (OutputSections.size() + 1) * sizeof(Elf_Shdr);
 
   // Our logic assumes that sections have rising VA within the same segment.
   // With use of linker scripts it is possible to violate this rule and get file
if (First) {
       P->p_offset = First->Offset;
       P->p_vaddr = First->Addr;
 
       if (!P->HasLMA)
         P->p_paddr = First->getLMA();
     }
 
     if (P->p_type == PT_LOAD) {
-      P->p_align = std::max<uint64_t>(P->p_align, Config->MaxPageSize);
+      uint64_t Alignment = Config->Paged ? Config->MaxPageSize : 1;
+      P->p_align = std::max<uint64_t>(P->p_align, Alignment);
     } else if (P->p_type == PT_GNU_RELRO) {
       P->p_align = 1;
       // The glibc dynamic loader rounds the size down, so we need to round up
       // to protect the last page. This is a no-op on FreeBSD which always
       // rounds up.
       P->p_memsz = alignTo(P->p_memsz, Target->PageSize);
     }
 

 
 // Fill the last page of executable segments with trap instructions
 // instead of leaving them as zero. Even though it is not required by any
 // standard, it is in general a good thing to do for security reasons.
 //
 // We'll leave other pages in segments as-is because the rest will be
 // overwritten by output sections.
 template <class ELFT> void Writer<ELFT>::writeTrapInstr() {
-  if (Script->HasSectionsCommand)
+  if (Script->HasSectionsCommand || !Config->Paged)
     return;
 
   // Fill the last page.
   for (PhdrEntry *P : Phdrs)
     if (P->p_type == PT_LOAD && (P->p_flags & PF_X))
       fillTrap(Out::BufferStart +
                    alignDown(P->p_offset + P->p_filesz, Target->PageSize),
                Out::BufferStart +

docs/ld.lld.1

 Optimization level for LTO.
 .It Fl -lto-partitions Ns = Ns Ar value
 Number of LTO codegen partitions.
 .It Fl m Ar value
 Set target emulation.
 .It Fl -Map Ns = Ns Ar file , Fl M Ar file
 Print a link map to
 .Ar file .
+.It Fl -nmagic , Fl n
+Do not page align sections, link against static libraries.
 .It Fl -no-allow-shlib-undefined
 Do not allow unresolved references in shared libraries.
 This option is enabled by default when linking an executable.
 .It Fl -no-as-needed
 Always set
 .Dv DT_NEEDED
 for shared libraries.
 .It Fl -no-color-diagnostics

 .It Fl -oformat Ns = Ns Ar format
 Specify the format for the output object file.
 The only supported
 .Ar format
 is
 .Cm binary ,
 which produces output with no ELF header.
 .It Fl -omagic , Fl N
-Set the text and data sections to be readable and writable.
+Set the text and data sections to be readable and writable, do not page align sections, link against static libraries.
 .It Fl -opt-remarks-filename Ar file
 Write optimization remarks in YAML format to
 .Ar file .
 .It Fl -opt-remarks-passes Ar pass-regex
 Filter optimization remarks by only allowing the passes matching
 .Ar pass-regex .
 .It Fl -opt-remarks-with-hotness
 Include hotness information in the optimization remarks file.

test/ELF/linkerscript/nmagic-alignment.test

+# REQUIRES: x86
+
+# Test that mimics a use case of -n to produce a kernel mapped shared-object
+# in a non paged context. We specifically want to test:
+# - We can allocate the headers into the first program header (via PHDRS)
+# typically -n does not allocate headers.
+# - The alignment of the .text section is not page aligned.
+
+# RUN: echo ".text; .globl foo; foo: nop" > %t.s
+# RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %t.s -o %t.o
+# RUN: ld.lld %t.o -o %t.so --shared --hash-style=sysv --script %s
+# RUN: llvm-readobj --program-headers %t.so | FileCheck %s
+# RUN: ld.lld %t.o -o %t2.so --shared --hash-style=sysv -n --script %s
+# RUN: llvm-readobj --program-headers %t2.so | FileCheck %s --check-prefix=CHECK-N
+
+SECTIONS {
+ . = 0x0 + SIZEOF_HEADERS;
+ .hash : { *(.hash) } :text
+ .dynsym : { *(.dynsym) }
+ .dynstr : { *(.dynstr) }
+ . = ALIGN(4);
+ .text : { *(.text*) }
+ .dynamic : { *(.dynamic) } :text :dynamic
+}
+
+PHDRS {
+ text PT_LOAD FLAGS(5) FILEHDR PHDRS;
+ dynamic PT_DYNAMIC FLAGS(4);
+}
+
+# CHECK: ProgramHeaders [
+# CHECK-NEXT:   ProgramHeader {
+# CHECK-NEXT:     Type: PT_LOAD
+# CHECK-NEXT:     Offset: 0x0
+# CHECK-NEXT:     VirtualAddress: 0x0
+# CHECK-NEXT:     PhysicalAddress: 0x0
+# CHECK-NEXT:     FileSize:
+# CHECK-NEXT:     MemSize:
+# CHECK-NEXT:     Flags [
+# CHECK-NEXT:       PF_R
+# CHECK-NEXT:       PF_X
+# CHECK-NEXT:     ]
+# CHECK-NEXT:     Alignment: 4096
+# CHECK-NEXT:   }
+# CHECK-NEXT:   ProgramHeader {
+# CHECK-NEXT:     Type: PT_DYNAMIC
+# CHECK-NEXT:     Offset: 0x108
+# CHECK-NEXT:     VirtualAddress: 0x108
+# CHECK-NEXT:     PhysicalAddress: 0x108
+# CHECK-NEXT:     FileSize:
+# CHECK-NEXT:     MemSize:
+# CHECK-NEXT:     Flags [
+# CHECK-NEXT:       PF_R
+# CHECK-NEXT:     ]
+# CHECK-NEXT:     Alignment: 8
+# CHECK-NEXT:   }
+# CHECK-NEXT: ]
+
+# CHECK-N: ProgramHeaders [
+# CHECK-N-NEXT:   ProgramHeader {
+# CHECK-N-NEXT:     Type: PT_LOAD
+# CHECK-N-NEXT:     Offset: 0x0
+# CHECK-N-NEXT:     VirtualAddress: 0x0
+# CHECK-N-NEXT:     PhysicalAddress: 0x0
+# CHECK-N-NEXT:     FileSize: 360
+# CHECK-N-NEXT:     MemSize: 360
+# CHECK-N-NEXT:     Flags [
+# CHECK-N-NEXT:       PF_R
+# CHECK-N-NEXT:       PF_X
+# CHECK-N-NEXT:     ]
+# CHECK-N-NEXT:     Alignment: 8
+# CHECK-N-NEXT:   }
+# CHECK-N-NEXT:   ProgramHeader {
+# CHECK-N-NEXT:     Type: PT_DYNAMIC
+# CHECK-N-NEXT:     Offset: 0x108
+# CHECK-N-NEXT:     VirtualAddress: 0x108
+# CHECK-N-NEXT:     PhysicalAddress: 0x108
+# CHECK-N-NEXT:     FileSize:
+# CHECK-N-NEXT:     MemSize:
+# CHECK-N-NEXT:     Flags [
+# CHECK-N-NEXT:       PF_R
+# CHECK-N-NEXT:     ]
+# CHECK-N-NEXT:     Alignment: 8
+# CHECK-N-NEXT:   }
+# CHECK-N-NEXT: ]

test/ELF/relro-omagic.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/shared.s -o %t2.o
 # RUN: ld.lld -shared %t2.o -o %t2.so -soname relro-omagic.s.tmp2.so
-# RUN: ld.lld --hash-style=sysv -N %t.o %t2.so -o %t
+# RUN: ld.lld --hash-style=sysv -N %t.o -Bdynamic %t2.so -o %t
 # RUN: llvm-objdump -section-headers %t | FileCheck --check-prefix=NORELRO %s
 # RUN: llvm-readobj --program-headers %t | FileCheck --check-prefix=NOPHDRS %s
 
 # NORELRO:      Sections:
 # NORELRO-NEXT: Idx Name          Size     VMA              Type
 # NORELRO-NEXT:   0               00000000 0000000000000000
 # NORELRO-NEXT:   1 .dynsym       00000048 0000000000200120
 # NORELRO-NEXT:   2 .hash         00000020 0000000000200168

test/ELF/segments.s

 
 # RUN: ld.lld -N %t -o %t3
 # RUN: llvm-readobj --program-headers %t3 | FileCheck --check-prefix=OMAGIC %s
 # RUN: ld.lld --omagic %t -o %t3
 # RUN: llvm-readobj --program-headers %t3 | FileCheck --check-prefix=OMAGIC %s
 
 # OMAGIC:     ProgramHeader {
 # OMAGIC:      Type: PT_LOAD
-# OMAGIC-NEXT:   Offset: 0x0
+# OMAGIC-NEXT:   Offset: 0xE8
 # OMAGIC-NEXT:   VirtualAddress:
 # OMAGIC-NEXT:   PhysicalAddress:
 # OMAGIC-NEXT:   FileSize:
 # OMAGIC-NEXT:   MemSize:
 # OMAGIC-NEXT:   Flags [
 # OMAGIC-NEXT:     PF_R
 # OMAGIC-NEXT:     PF_W
 # OMAGIC-NEXT:     PF_X
 # OMAGIC-NEXT:   ]
-# OMAGIC-NEXT:   Alignment: 4096
+# OMAGIC-NEXT:   Alignment: 8
 # OMAGIC-NEXT: }
 # OMAGIC-NEXT: ProgramHeader {
 # OMAGIC-NEXT:   Type: PT_GNU_STACK
 
+# RUN: ld.lld -n %t -o %t4
+# RUN: llvm-readobj --program-headers %t4 | FileCheck --check-prefix=NMAGIC %s
+# RUN: ld.lld --nmagic %t -o %t4
+# RUN: llvm-readobj --program-headers %t4 | FileCheck --check-prefix=NMAGIC %s
+
+
 .global _start
 _start:
  nop
 
 .section .ro,"a"
 nop
 
 .section .rw,"aw"
 nop
 
 .section .rx,"ax"
 nop
+
+# NMAGIC:   ProgramHeader {
+# NMAGIC-NEXT:     Type: PT_LOAD
+# NMAGIC-NEXT:     Offset: 0x158
+# NMAGIC-NEXT:     VirtualAddress:
+# NMAGIC-NEXT:     PhysicalAddress:
+# NMAGIC-NEXT:     FileSize: 1
+# NMAGIC-NEXT:     MemSize: 1
+# NMAGIC-NEXT:     Flags [
+# NMAGIC-NEXT:       PF_R
+# NMAGIC-NEXT:     ]
+# NMAGIC-NEXT:     Alignment: 8
+# NMAGIC-NEXT:   }
+# NMAGIC-NEXT:   ProgramHeader {
+# NMAGIC-NEXT:     Type: PT_LOAD
+# NMAGIC-NEXT:     Offset: 0x15C
+# NMAGIC-NEXT:     VirtualAddress:
+# NMAGIC-NEXT:     PhysicalAddress:
+# NMAGIC-NEXT:     FileSize: 2
+# NMAGIC-NEXT:     MemSize: 2
+# NMAGIC-NEXT:     Flags [
+# NMAGIC-NEXT:       PF_R
+# NMAGIC-NEXT:       PF_X
+# NMAGIC-NEXT:     ]
+# NMAGIC-NEXT:     Alignment: 4
+# NMAGIC-NEXT:   }
+# NMAGIC-NEXT:   ProgramHeader {
+# NMAGIC-NEXT:     Type: PT_LOAD (0x1)
+# NMAGIC-NEXT:     Offset: 0x15E
+# NMAGIC-NEXT:     VirtualAddress:
+# NMAGIC-NEXT:     PhysicalAddress:
+# NMAGIC-NEXT:     FileSize: 1
+# NMAGIC-NEXT:     MemSize: 1
+# NMAGIC-NEXT:     Flags [
+# NMAGIC-NEXT:       PF_R
+# NMAGIC-NEXT:       PF_W
+# NMAGIC-NEXT:     ]
+# NMAGIC-NEXT:     Alignment: 1
+# NMAGIC-NEXT:   }