[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

1118

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

1118

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));

959

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

ELF/Writer.cpp

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

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

21

This like does not have any FileCheck.

21

like->line

31

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

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

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

21

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

168

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

908

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

1121

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

9 ↗

(On Diff #197082)

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 ↗

(On Diff #197339)

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

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 HasDynSymTab;
   bool IgnoreDataAddressEquality;
   bool IgnoreFunctionAddressEquality;
   bool LTOCSProfileGenerate;
   bool LTODebugPassManager;
   bool LTONewPassManager;
   bool MergeArmExidx;
   bool MipsN32Abi = false;
+  bool Nmagic;
   bool NoinhibitExec;
   bool Nostdlib;
   bool OFormatBinary;
   bool Omagic;
   bool OptRemarksWithHotness;
+  bool Paged;
   bool PicThunk;
   bool Pie;
   bool PrintGcSections;
   bool PrintIcfSections;
   bool Relocatable;
   bool RelrPackDynRelocs;
   bool SaveTemps;
   bool SingleRoRx;

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->Nmagic = Args.hasFlag(OPT_nmagic, OPT_no_nmagic, false);
   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);
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");
 
   // 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());
 
   // Parse -mllvm options.
void LinkerDriver::readConfigs(opt::InputArgList &Args) {
 
   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)
+  if (Config->Omagic || Config->Nmagic)
     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))
static void setConfigs(opt::InputArgList &Args) {
   uint16_t M = Config->EMachine;
 
   Config->CopyRelocs = (Config->Relocatable || Config->EmitRelocs);
   Config->Is64 = (K == ELF64LEKind || K == ELF64BEKind);
   Config->IsLE = (K == ELF32LEKind || K == ELF64LEKind);
   Config->Endianness = Config->IsLE ? endianness::little : endianness::big;
   Config->IsMips64EL = (K == ELF64LEKind && M == EM_MIPS);
   Config->Pic = Config->Pie || Config->Shared;
+  Config->Paged = !Config->Omagic && !Config->Nmagic;
   Config->PicThunk = Args.hasArg(OPT_pic_veneer, Config->Pic);
   Config->Wordsize = Config->Is64 ? 8 : 4;
 
   // ELF defines two different ways to store relocation addends as shown below:
   //
   //  Rel:  Addends are stored to the location where relocations are applied.
   //  Rela: Addends are stored as part of relocation entry.
   //
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 and 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 +

test/ELF/aarch64-script-nmagic.s

+// REQUIRES: aarch64
+// RUN: llvm-mc -filetype=obj -triple=aarch64-linux-gnu %s -o %t.o
+// RUN: echo "SECTIONS \
+// RUN: { \
+// RUN:  . = 0x0 + SIZEOF_HEADERS; \
+// RUN:  .hash : { *(.hash) } :text \
+// RUN:  .dynsym : { *(.dynsym) } \
+// RUN:  .dynstr : { *(.dynstr) } \
+// RUN:  . = ALIGN(4); \
+// RUN:  .text : { *(.text*) } \
+// RUN:  .dynamic : { *(.dynamic) } :text :dynamic \
+// RUN: } \
+// RUN: PHDRS \
+// RUN: { \
+// RUN:  text PT_LOAD FLAGS(5) FILEHDR PHDRS; \
+// RUN:  dynamic PT_DYNAMIC FLAGS(4); \
+// RUN: }  " > %t.script
+// RUN: ld.lld %t.o -o %t.so --shared --hash-style=sysv --script %t.script
+// RUN: llvm-readobj --program-headers %t.so | FileCheck %s
+// RUN: ld.lld %t.o -o %t2.so --shared --hash-style=sysv -n --script %t.script
+// RUN: llvm-readobj --program-headers %t2.so
+
+// 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.
+        .text
+        .globl foo
+        .type foo, %function
+foo:    ret
+
+// 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: 65536
+// 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:   }