[LLD][ELF] Full support for -n (--nmagic) and -N (--omagic) via -zcommon-page-size

[peter.smith]

Summary

This is an alternative implementation of -n and -N to D61201 as this was suggested as a review comment. Instead of skipping page alignment when -n (--nmagic) and -N (--omagic) are used but leaving the values of the Config->MaxPageSize and Target->PageSize unchanged, we instead:

• Use Config->CommonPageSize to store the appropriate Target->PageSize value
• When -n or -N is used we set the Config->MaxPageSize and Config->PageSize to 1 so all page-alignment does nothing.
• We still have to account for -n and -N meaning -Bstatic.
• We still have to not allocate headers unless explicitly stated in the linker script.

As we now have a modifiable Config->CommonPageSize it becomes trivial to support the -zcommon-page-size command line option so I've done that and added a test case for it. This could be split into a different patch if it makes sense. I've also added a test to show the effect of increasing -zcommon-page-size. Other test cases have been taken from D61201

This approach has the advantage that none of the page alignment statements have to be changed, and any future ones we add won't need guarding. It has the disadvantage that the CONSTANT(MAXPAGESIZE) and CONSTANT(COMMONPAGESIZE) linker script commands will be affected when -n or -N is used. There is at least one linkerscript in Tianocore edk2 that (ab)uses -n -z common-page-size=0x20 to use CONSTANT(COMMONPAGESIZE) as if it were a preprocessor macro set with -D in the compiler. The usual approach to this is to pre-process the linkerscript.

[MaskRay]

So D61688 implements -z common-page-size as a by-product :)
I compared it with D61201. It has a bit more set-up code in Driver.cpp but that part is easy to reason about. In return, it simplifies a few places where D61201 additionally checks Config->Paged, so I am in favor of D61688:

// Writer<ELFT>::finalizeSections()
-  if (!Script->HasSectionsCommand && !Config->Relocatable && Config->Paged)
+  if (!Script->HasSectionsCommand && !Config->Relocatable)
     fixSectionAlignments();

// computeFileOffset
-    uint64_t PageSize = Config->Paged ? Config->MaxPageSize : 1;
-    uint64_t Alignment = std::max<uint64_t>(OS->Alignment, PageSize);
+    uint64_t Alignment = std::max<uint64_t>(OS->Alignment, Config->MaxPageSize);

// Writer<ELFT>::assignFileOffsets()
-    if (LastRX && LastRX->LastSec == Sec && Config->Paged)
-      Off = alignTo(Off, Target->PageSize);
+    if (LastRX && LastRX->LastSec == Sec)
+      Off = alignTo(Off, Config->CommonPageSize);

// Writer<ELFT>::writeTrapInstr()
-  if (Script->HasSectionsCommand || !Config->Paged)
+  if (Script->HasSectionsCommand)

[ruiu]

Sorry for my ignorance, but I don't think I fully understand the difference of "page size" and "common page size". In what situation you want to set different values to these variables? Is there any constraint between them, such as one value is always greater than the other, etc.?

ELF/Options.td

237 ↗

(On Diff #198669)

Please add (default).

240 ↗

(On Diff #198669)

Ditto

[peter.smith]

In D61688#1496262, @ruiu wrote:

Sorry for my ignorance, but I don't think I fully understand the difference of "page size" and "common page size". In what situation you want to set different values to these variables? Is there any constraint between them, such as one value is always greater than the other, etc.?

"page size" as in Target->PageSize and "common page size" as in Config->CommonPageSize that I renamed it to from this patch are synonymous. From memory I think ld.bfd uses page_size for common-page and abi_page_size for "max page size", I preferred to make the CommonPageSize more explicit.

There is a difference between "max page size" and "common page size". The best explanation I've seen is in the review comment https://reviews.llvm.org/D33630#767301 in the patch that introduced it's only use in LLD outside of the linker script CONSTANT(COMMONPAGESIZE). A quick summary is:

• max-page-size or abi-page-size is the largest page size that might be encountered at run-time. For example some AArch64 platforms such as Fedora use 64k page size, others such as Ubuntu use 4k page size. If an executable is to be portable it sets max-page-size to 64k. All significant layout decisions have to use the max-page-size.
• common-page-size or sometimes just page-size is the "most common" page-size that might be encountered at run-time. There are some optimisations that can be done that use this. The best explanation that I've seen is the description DATA_SEGMENT_ALIGN at https://sourceware.org/binutils/docs-2.30/ld/Builtin-Functions.html#Builtin-Functions. As I understand it, LLD only uses common-page-size for D33630 "Fill the empty space in executable segments with instruction padding" and in the linker script CONSTANT(COMMONPAGESIZE).

There is a constraint (enforced by Gold and this patch) that "common page size" can't be greater than "max page size". This constraint is the only requirement for -n and -N, if we lower -zmax-page-size to 1 the Target->PageSize remains at 4k and this produces an incorrect output. It just so happens that implementing that requires implementing all of -zcommon-page-size apart for the command-line option -zcommon-page-size.

Why would anyone want to change the common-page-size with -zcommon-page-size. Good question; the strongest reason I can come up with is backwards compatibility with the small number programs that use it (for example D56205). I don't think that there is a strong enough reason to implement it on its own, but it is just adding a command line option and a test.

[peter.smith]

Update diff to add (default) to the --no-omagic and --no-nmagic options.

[MaskRay]

LGTM

ELF/Driver.cpp

1125 ↗

(On Diff #198829)

IIRC @grimar said this should be moved to case OPT_Bstatic:.

[grimar]

Few minor nits from me.

ELF/Driver.cpp

1125 ↗

(On Diff #198829)

I think that is better, yes (to group "case options" by effect).

1221 ↗

(On Diff #198829)

I think we usually use dashes when mention a option name in error message.

1227 ↗

(On Diff #198829)

Should this case have a warning too?

test/ELF/common-page.s

5 ↗

(On Diff #198829)

This part is copy paste from our very old (if not the oldest :) test case I think.
I believe you do not need this and can use nop, don't you?

[grimar]

ELF/Driver.cpp

1221 ↗

(On Diff #198829)

i.e.

error("--common-page-size......

[ruiu]

LGTM

• max-page-size or abi-page-size is the largest page size that might be encountered at run-time. For example some AArch64 platforms such as Fedora use 64k page size, others such as Ubuntu use 4k page size. If an executable is to be portable it sets max-page-size to 64k. All significant layout decisions have to use the max-page-size.
• common-page-size or sometimes just page-size is the "most common" page-size that might be encountered at run-time. There are some optimisations that can be done that use this. The best explanation that I've seen is the description DATA_SEGMENT_ALIGN at https://sourceware.org/binutils/docs-2.30/ld/Builtin-Functions.html#Builtin-Functions. As I understand it, LLD only uses common-page-size for D33630 "Fill the empty space in executable segments with instruction padding" and in the linker script CONSTANT(COMMONPAGESIZE).

This is an excellent summary of the differences of the two. Could you add this to this patch as a comment?

[peter.smith]

Thanks for the reviews, I'll fix the nits, and will add a comment to describe the difference between max and common page size.

ELF/Driver.cpp

1125 ↗

(On Diff #198829)

Sure, I must have missed the earlier comment, sorry.

1221 ↗

(On Diff #198829)

Sure, in this case it will be -z common-page-size, I'll also do so for -z max-page-size above

1227 ↗

(On Diff #198829)

Possibly, I decided not to as we'd need to distinguish between -z common-page-size being increased too high, and -z max-page-size being lowered to below the Target default common page size to avoid a confusing warning. I can add one in a follow up patch if you'd like?

[grimar]

ELF/Driver.cpp

1227 ↗

(On Diff #198829)

Up to you.

lld/trunk/ELF/Arch/SPARCV9.cpp

SPARCV9::SPARCV9() {
   GotRel = R_SPARC_GLOB_DAT;
   NoneRel = R_SPARC_NONE;
   PltRel = R_SPARC_JMP_SLOT;
   RelativeRel = R_SPARC_RELATIVE;
   GotEntrySize = 8;
   PltEntrySize = 32;
   PltHeaderSize = 4 * PltEntrySize;
 
-  PageSize = 8192;
+  DefaultCommonPageSize = 8192;
   DefaultMaxPageSize = 0x100000;
   DefaultImageBase = 0x100000;
 }
 
 RelExpr SPARCV9::getRelExpr(RelType Type, const Symbol &S,
                             const uint8_t *Loc) const {
   switch (Type) {
   case R_SPARC_32:

lld/trunk/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 PicThunk;
   bool Pie;
   bool PrintGcSections;
struct Configuration {
   UnresolvedPolicy UnresolvedSymbols;
   Target2Policy Target2;
   ARMVFPArgKind ARMVFPArgs = ARMVFPArgKind::Default;
   BuildIdKind BuildId = BuildIdKind::None;
   ELFKind EKind = ELFNoneKind;
   uint16_t DefaultSymbolVersion = llvm::ELF::VER_NDX_GLOBAL;
   uint16_t EMachine = llvm::ELF::EM_NONE;
   llvm::Optional<uint64_t> ImageBase;
+  uint64_t CommonPageSize;
   uint64_t MaxPageSize;
   uint64_t MipsGotSize;
   uint64_t ZStackSize;
   unsigned LTOPartitions;
   unsigned LTOO;
   unsigned Optimize;
   unsigned ThinLTOJobs;
   int32_t SplitStackAdjustSize;

lld/trunk/ELF/Driver.cpp

return S == "combreloc" || S == "copyreloc" || S == "defs" ||
          S == "execstack" || S == "global" || S == "hazardplt" ||
          S == "initfirst" || S == "interpose" ||
          S == "keep-text-section-prefix" || S == "lazy" || S == "muldefs" ||
          S == "nocombreloc" || S == "nocopyreloc" || S == "nodefaultlib" ||
          S == "nodelete" || S == "nodlopen" || S == "noexecstack" ||
          S == "nokeep-text-section-prefix" || S == "norelro" || S == "notext" ||
          S == "now" || S == "origin" || S == "relro" || S == "retpolineplt" ||
          S == "rodynamic" || S == "text" || S == "wxneeded" ||
-         S.startswith("max-page-size=") || S.startswith("stack-size=");
+         S.startswith("common-page-size") || S.startswith("max-page-size=") ||
+         S.startswith("stack-size=");
 }
 
 // Report an error for an unknown -z option.
 static void checkZOptions(opt::InputArgList &Args) {
   for (auto *Arg : Args.filtered(OPT_z))
     if (!isKnownZFlag(Arg->getValue()))
       error("unknown -z value: " + StringRef(Arg->getValue()));
 }
static void 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);
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->Nmagic || Config->Omagic)
     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_as_needed:
       break;
     case OPT_format:
       Config->FormatBinary = isFormatBinary(Arg->getValue());
       break;
     case OPT_no_as_needed:
       Config->AsNeeded = false;
       break;
     case OPT_Bstatic:
+    case OPT_omagic:
+    case OPT_nmagic:
       Config->Static = true;
       break;
     case OPT_Bdynamic:
       Config->Static = false;
       break;
     case OPT_whole_archive:
       InWholeArchive = true;
       break;

 
 // Parse -z max-page-size=<value>. The default value is defined by
 // each target.
 static uint64_t getMaxPageSize(opt::InputArgList &Args) {
   uint64_t Val = args::getZOptionValue(Args, OPT_z, "max-page-size",
                                        Target->DefaultMaxPageSize);
   if (!isPowerOf2_64(Val))
     error("max-page-size: value isn't a power of 2");
+  if (Config->Nmagic || Config->Omagic) {
+    if (Val != Target->DefaultMaxPageSize)
+      warn("-z max-page-size set, but paging disabled by omagic or nmagic");
+    return 1;
+  }
+  return Val;
+}
+
+// Parse -z common-page-size=<value>. The default value is defined by
+// each target.
+static uint64_t getCommonPageSize(opt::InputArgList &Args) {
+  uint64_t Val = args::getZOptionValue(Args, OPT_z, "common-page-size",
+                                       Target->DefaultCommonPageSize);
+  if (!isPowerOf2_64(Val))
+    error("common-page-size: value isn't a power of 2");
+  if (Config->Nmagic || Config->Omagic) {
+    if (Val != Target->DefaultCommonPageSize)
+      warn("-z common-page-size set, but paging disabled by omagic or nmagic");
+    return 1;
+  }
+  // CommonPageSize can't be larger than MaxPageSize.
+  if (Val > Config->MaxPageSize)
+    Val = Config->MaxPageSize;
   return Val;
 }
 
 // Parses -image-base option.
 static Optional<uint64_t> getImageBase(opt::InputArgList &Args) {
   // Because we are using "Config->MaxPageSize" here, this function has to be
   // called after the variable is initialized.
   auto *Arg = Args.getLastArg(OPT_image_base);
for (InputSectionBase *S : F->getSections())
       InputSections.push_back(cast<InputSection>(S));
 
   // We do not want to emit debug sections if --strip-all
   // or -strip-debug are given.
   if (Config->Strip != StripPolicy::None)
     llvm::erase_if(InputSections, [](InputSectionBase *S) { return S->Debug; });
 
   Config->EFlags = Target->calcEFlags();
+  // MaxPageSize (sometimes called abi page size) is the maximum page size that
+  // the output can be run on. For example if the OS can use 4k or 64k page
+  // sizes then MaxPageSize must be 64 for the output to be useable on both.
+  // All important alignment decisions must use this value.
   Config->MaxPageSize = getMaxPageSize(Args);
+  // CommonPageSize is the most common page size that the output will be run on.
+  // For example if an OS can use 4k or 64k page sizes and 4k is more common
+  // than 64k then CommonPageSize is set to 4k. CommonPageSize can be used for
+  // optimizations such as DATA_SEGMENT_ALIGN in linker scripts. LLD's use of it
+  // is limited to writing trap instructions on the last executable segment.
+  Config->CommonPageSize = getCommonPageSize(Args);
+
   Config->ImageBase = getImageBase(Args);
 
   if (Config->EMachine == EM_ARM) {
     // FIXME: These warnings can be removed when lld only uses these features
     // when the input objects have been compiled with an architecture that
     // supports them.
     if (Config->ARMHasBlx == false)
       warn("lld uses blx instruction, no object with architecture supporting "

lld/trunk/ELF/LinkerScript.cpp

void LinkerScript::allocateHeaders(std::vector<PhdrEntry *> &Phdrs) {
   if (It == Phdrs.end())
     return;
   PhdrEntry *FirstPTLoad = *It;
 
   bool HasExplicitHeaders =
       llvm::any_of(PhdrsCommands, [](const PhdrsCommand &Cmd) {
         return Cmd.HasPhdrs || Cmd.HasFilehdr;
       });
+  bool Paged = !Config->Omagic && !Config->Nmagic;
   uint64_t HeaderSize = getHeaderSize();
-  if (HeaderSize <= Min - computeBase(Min, HasExplicitHeaders)) {
+  if ((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)

lld/trunk/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 (default)">;
+
 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 (default)">;
 
 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">;

lld/trunk/ELF/ScriptParser.cpp

Expr ScriptParser::readExpr1(Expr Lhs, int MinPrec) {
   }
   return Lhs;
 }
 
 Expr ScriptParser::getPageSize() {
   std::string Location = getCurrentLocation();
   return [=]() -> uint64_t {
     if (Target)
-      return Target->PageSize;
+      return Config->CommonPageSize;
     error(Location + ": unable to calculate page size");
     return 4096; // Return a dummy value.
   };
 }
 
 Expr ScriptParser::readConstant() {
   StringRef S = readParenLiteral();
   if (S == "COMMONPAGESIZE")

lld/trunk/ELF/Target.h

virtual bool inBranchRange(RelType Type, uint64_t Src,
                              uint64_t Dst) const;
   virtual RelExpr getRelExpr(RelType Type, const Symbol &S,
                              const uint8_t *Loc) const = 0;
 
   virtual void relocateOne(uint8_t *Loc, RelType Type, uint64_t Val) const = 0;
 
   virtual ~TargetInfo();
 
-  unsigned PageSize = 4096;
+  unsigned DefaultCommonPageSize = 4096;
   unsigned DefaultMaxPageSize = 4096;
 
   uint64_t getImageBase() const;
 
   // True if _GLOBAL_OFFSET_TABLE_ is relative to .got.plt, false if .got.
   bool GotBaseSymInGotPlt = true;
 
   RelType CopyRel;

lld/trunk/ELF/Writer.cpp

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)
-      Off = alignTo(Off, Target->PageSize);
+      Off = alignTo(Off, Config->CommonPageSize);
   }
 
   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
   // offset overlaps or overflows. That should never happen with a valid script
for (PhdrEntry *P : Phdrs) {
 
     if (P->p_type == PT_LOAD) {
       P->p_align = std::max<uint64_t>(P->p_align, Config->MaxPageSize);
     } 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);
+      P->p_memsz = alignTo(P->p_memsz, Config->CommonPageSize);
     }
 
     if (P->p_type == PT_TLS && P->p_memsz) {
       if (!Config->Shared &&
           (Config->EMachine == EM_ARM || Config->EMachine == EM_AARCH64)) {
         // On ARM/AArch64, reserve extra space (8 words) between the thread
         // pointer and an executable's TLS segment by overaligning the segment.
         // This reservation is needed for backwards compatibility with Android's

 // overwritten by output sections.
 template <class ELFT> void Writer<ELFT>::writeTrapInstr() {
   if (Script->HasSectionsCommand)
     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),
+      fillTrap(Out::BufferStart + alignDown(P->p_offset + P->p_filesz,
+                                            Config->CommonPageSize),
                Out::BufferStart +
-                   alignTo(P->p_offset + P->p_filesz, Target->PageSize));
+                   alignTo(P->p_offset + P->p_filesz, Config->CommonPageSize));
 
   // Round up the file size of the last segment to the page boundary iff it is
   // an executable segment to ensure that other tools don't accidentally
   // trim the instruction padding (e.g. when stripping the file).
   PhdrEntry *Last = nullptr;
   for (PhdrEntry *P : Phdrs)
     if (P->p_type == PT_LOAD)
       Last = P;
 
   if (Last && (Last->p_flags & PF_X))
-    Last->p_memsz = Last->p_filesz = alignTo(Last->p_filesz, Target->PageSize);
+    Last->p_memsz = Last->p_filesz =
+        alignTo(Last->p_filesz, Config->CommonPageSize);
 }
 
 // Write section contents to a mmap'ed file.
 template <class ELFT> void Writer<ELFT>::writeSections() {
   // In -r or -emit-relocs mode, write the relocation sections first as in
   // ELf_Rel targets we might find out that we need to modify the relocated
   // section while doing it.
   for (OutputSection *Sec : OutputSections)

lld/trunk/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
 Do not use colors in diagnostics.
 .It Fl -no-define-common
 Do not assign space to common symbols.
 .It Fl -no-demangle
 Do not demangle symbol names.
 .It Fl -no-dynamic-linker
 Inhibit output of an
 .Li .interp
 section.
 .It Fl -no-gc-sections
 Disable garbage collection of unused sections.
 .It Fl -no-gnu-unique
 Disable STB_GNU_UNIQUE symbol binding.
 .It Fl -no-merge-exidx-entries
 Disable merging .ARM.exidx entries.
+.It F1 -no-nmagic
+Page align sections.
+.It F1 -no-omagic
+Do not set the text data sections to be writable, page align sections.
 .It Fl -no-rosegment
 Do not put read-only non-executable sections in their own segment.
 .It Fl -no-threads
 Do not run the linker multi-threaded.
 .It Fl -no-undefined-version
 Report version scripts that refer undefined symbols.
 .It Fl -no-undefined
 Report unresolved symbols even if the linker is creating a shared library.

 .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.

lld/trunk/test/ELF/common-page.s

+# REQUIRES: x86
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
+
+# exits with return code 42 on linux
+.globl _start
+_start:
+  nop
+
+# Increase max-page-size to 64k while using the default x86_64 common page size
+# of 4k. If the last loadable segment is executable then lld aligns the next
+# section using the common page size.
+
+# RUN: ld.lld -z max-page-size=0x10000 -z common-page-size=0x1000 %t -o %t2
+# RUN: llvm-readobj --sections -l %t2 | FileCheck --check-prefix=CHECK-MAX %s
+
+# CHECK-MAX:      Sections [
+# CHECK-MAX-NEXT:   Section {
+# CHECK-MAX-NEXT:     Index: 0
+# CHECK-MAX-NEXT:     Name:  (0)
+# CHECK-MAX-NEXT:     Type: SHT_NULL (0x0)
+# CHECK-MAX-NEXT:     Flags [ (0x0)
+# CHECK-MAX-NEXT:     ]
+# CHECK-MAX-NEXT:     Address: 0x0
+# CHECK-MAX-NEXT:     Offset: 0x0
+# CHECK-MAX-NEXT:     Size: 0
+# CHECK-MAX-NEXT:     Link: 0
+# CHECK-MAX-NEXT:     Info: 0
+# CHECK-MAX-NEXT:     AddressAlignment: 0
+# CHECK-MAX-NEXT:     EntrySize: 0
+# CHECK-MAX-NEXT:   }
+# CHECK-MAX-NEXT:   Section {
+# CHECK-MAX-NEXT:     Index: 1
+# CHECK-MAX-NEXT:     Name: .text (1)
+# CHECK-MAX-NEXT:     Type: SHT_PROGBITS (0x1)
+# CHECK-MAX-NEXT:     Flags [ (0x6)
+# CHECK-MAX-NEXT:       SHF_ALLOC (0x2)
+# CHECK-MAX-NEXT:       SHF_EXECINSTR (0x4)
+# CHECK-MAX-NEXT:     ]
+# CHECK-MAX-NEXT:     Address: 0x210000
+# CHECK-MAX-NEXT:     Offset: 0x10000
+# CHECK-MAX-NEXT:     Size: 1
+# CHECK-MAX-NEXT:     Link: 0
+# CHECK-MAX-NEXT:     Info: 0
+# CHECK-MAX-NEXT:     AddressAlignment: 4
+# CHECK-MAX-NEXT:     EntrySize: 0
+# CHECK-MAX-NEXT:   }
+# CHECK-MAX-NEXT:   Section {
+# CHECK-MAX-NEXT:     Index: 2
+# CHECK-MAX-NEXT:     Name: .comment (7)
+# CHECK-MAX-NEXT:     Type: SHT_PROGBITS (0x1)
+# CHECK-MAX-NEXT:     Flags [ (0x30)
+# CHECK-MAX-NEXT:       SHF_MERGE (0x10)
+# CHECK-MAX-NEXT:       SHF_STRINGS (0x20)
+# CHECK-MAX-NEXT:     ]
+# CHECK-MAX-NEXT:     Address: 0x0
+# CHECK-MAX-NEXT:     Offset: 0x11000
+# CHECK-MAX-NEXT:     Size: 8
+# CHECK-MAX-NEXT:     Link: 0
+# CHECK-MAX-NEXT:     Info: 0
+# CHECK-MAX-NEXT:     AddressAlignment: 1
+# CHECK-MAX-NEXT:     EntrySize: 1
+
+# CHECK-MAX: ProgramHeaders [
+# CHECK-MAX-NEXT:   ProgramHeader {
+# CHECK-MAX-NEXT:     Type: PT_PHDR (0x6)
+# CHECK-MAX-NEXT:     Offset: 0x40
+# CHECK-MAX-NEXT:     VirtualAddress: 0x200040
+# CHECK-MAX-NEXT:     PhysicalAddress: 0x200040
+# CHECK-MAX-NEXT:     FileSize: 224
+# CHECK-MAX-NEXT:     MemSize: 224
+# CHECK-MAX-NEXT:     Flags [ (0x4)
+# CHECK-MAX-NEXT:       PF_R (0x4)
+# CHECK-MAX-NEXT:     ]
+# CHECK-MAX-NEXT:     Alignment: 8
+# CHECK-MAX-NEXT:   }
+# CHECK-MAX-NEXT:   ProgramHeader {
+# CHECK-MAX-NEXT:     Type: PT_LOAD (0x1)
+# CHECK-MAX-NEXT:     Offset: 0x0
+# CHECK-MAX-NEXT:     VirtualAddress: 0x200000
+# CHECK-MAX-NEXT:     PhysicalAddress: 0x200000
+# CHECK-MAX-NEXT:     FileSize: 288
+# CHECK-MAX-NEXT:     MemSize: 288
+# CHECK-MAX-NEXT:     Flags [ (0x4)
+# CHECK-MAX-NEXT:       PF_R (0x4)
+# CHECK-MAX-NEXT:     ]
+# CHECK-MAX-NEXT:     Alignment: 65536
+# CHECK-MAX-NEXT:   }
+# CHECK-MAX-NEXT:   ProgramHeader {
+# CHECK-MAX-NEXT:     Type: PT_LOAD (0x1)
+# CHECK-MAX-NEXT:     Offset: 0x10000
+# CHECK-MAX-NEXT:     VirtualAddress: 0x210000
+# CHECK-MAX-NEXT:     PhysicalAddress: 0x210000
+# CHECK-MAX-NEXT:     FileSize: 4096
+# CHECK-MAX-NEXT:     MemSize: 4096
+# CHECK-MAX-NEXT:     Flags [ (0x5)
+# CHECK-MAX-NEXT:       PF_R (0x4)
+# CHECK-MAX-NEXT:       PF_X (0x1)
+# CHECK-MAX-NEXT:     ]
+# CHECK-MAX-NEXT:     Alignment: 65536
+# CHECK-MAX-NEXT:   }
+# CHECK-MAX-NEXT:   ProgramHeader {
+# CHECK-MAX-NEXT:     Type: PT_GNU_STACK (0x6474E551)
+# CHECK-MAX-NEXT:     Offset: 0x0
+# CHECK-MAX-NEXT:     VirtualAddress: 0x0
+# CHECK-MAX-NEXT:     PhysicalAddress: 0x0
+# CHECK-MAX-NEXT:     FileSize: 0
+# CHECK-MAX-NEXT:     MemSize: 0
+# CHECK-MAX-NEXT:     Flags [ (0x6)
+# CHECK-MAX-NEXT:       PF_R (0x4)
+# CHECK-MAX-NEXT:       PF_W (0x2)
+# CHECK-MAX-NEXT:     ]
+# CHECK-MAX-NEXT:     Alignment: 0
+
+# Increase common-page-size to max-page-size. Expect to see a larger offset
+# of the first Section after the executable loadable segment due to the higher
+# alignment requirement.
+
+# RUN: ld.lld -z max-page-size=0x10000 -z common-page-size=0x10000 %t -o %t3
+# RUN: llvm-readobj --sections -l %t3 | FileCheck --check-prefix=CHECK-COMMON %s
+
+# Check that we truncate common-page-size to max-page-size
+
+# RUN: ld.lld -z max-page-size=0x10000 -z common-page-size=0x100000 %t -o %t4
+# RUN: llvm-readobj --sections -l %t4 | FileCheck --check-prefix=CHECK-COMMON %s
+
+# CHECK-COMMON: Sections [
+# CHECK-COMMON-NEXT:   Section {
+# CHECK-COMMON-NEXT:     Index: 0
+# CHECK-COMMON-NEXT:     Name:  (0)
+# CHECK-COMMON-NEXT:     Type: SHT_NULL (0x0)
+# CHECK-COMMON-NEXT:     Flags [ (0x0)
+# CHECK-COMMON-NEXT:     ]
+# CHECK-COMMON-NEXT:     Address: 0x0
+# CHECK-COMMON-NEXT:     Offset: 0x0
+# CHECK-COMMON-NEXT:     Size: 0
+# CHECK-COMMON-NEXT:     Link: 0
+# CHECK-COMMON-NEXT:     Info: 0
+# CHECK-COMMON-NEXT:     AddressAlignment: 0
+# CHECK-COMMON-NEXT:     EntrySize: 0
+# CHECK-COMMON-NEXT:   }
+# CHECK-COMMON-NEXT:   Section {
+# CHECK-COMMON-NEXT:     Index: 1
+# CHECK-COMMON-NEXT:     Name: .text (1)
+# CHECK-COMMON-NEXT:     Type: SHT_PROGBITS (0x1)
+# CHECK-COMMON-NEXT:     Flags [ (0x6)
+# CHECK-COMMON-NEXT:       SHF_ALLOC (0x2)
+# CHECK-COMMON-NEXT:       SHF_EXECINSTR (0x4)
+# CHECK-COMMON-NEXT:     ]
+# CHECK-COMMON-NEXT:     Address: 0x210000
+# CHECK-COMMON-NEXT:     Offset: 0x10000
+# CHECK-COMMON-NEXT:     Size: 1
+# CHECK-COMMON-NEXT:     Link: 0
+# CHECK-COMMON-NEXT:     Info: 0
+# CHECK-COMMON-NEXT:     AddressAlignment: 4
+# CHECK-COMMON-NEXT:     EntrySize: 0
+# CHECK-COMMON-NEXT:   }
+# CHECK-COMMON-NEXT:   Section {
+# CHECK-COMMON-NEXT:     Index: 2
+# CHECK-COMMON-NEXT:     Name: .comment (7)
+# CHECK-COMMON-NEXT:     Type: SHT_PROGBITS (0x1)
+# CHECK-COMMON-NEXT:     Flags [ (0x30)
+# CHECK-COMMON-NEXT:       SHF_MERGE (0x10)
+# CHECK-COMMON-NEXT:       SHF_STRINGS (0x20)
+# CHECK-COMMON-NEXT:     ]
+# CHECK-COMMON-NEXT:     Address: 0x0
+# CHECK-COMMON-NEXT:     Offset: 0x20000
+# CHECK-COMMON-NEXT:     Size: 8
+# CHECK-COMMON-NEXT:     Link: 0
+# CHECK-COMMON-NEXT:     Info: 0
+# CHECK-COMMON-NEXT:     AddressAlignment: 1
+# CHECK-COMMON-NEXT:     EntrySize: 1
+
+# CHECK-COMMON: ProgramHeaders [
+# CHECK-COMMON-NEXT:   ProgramHeader {
+# CHECK-COMMON-NEXT:     Type: PT_PHDR (0x6)
+# CHECK-COMMON-NEXT:     Offset: 0x40
+# CHECK-COMMON-NEXT:     VirtualAddress: 0x200040
+# CHECK-COMMON-NEXT:     PhysicalAddress: 0x200040
+# CHECK-COMMON-NEXT:     FileSize: 224
+# CHECK-COMMON-NEXT:     MemSize: 224
+# CHECK-COMMON-NEXT:     Flags [ (0x4)
+# CHECK-COMMON-NEXT:       PF_R (0x4)
+# CHECK-COMMON-NEXT:     ]
+# CHECK-COMMON-NEXT:     Alignment: 8
+# CHECK-COMMON-NEXT:   }
+# CHECK-COMMON-NEXT:   ProgramHeader {
+# CHECK-COMMON-NEXT:     Type: PT_LOAD (0x1)
+# CHECK-COMMON-NEXT:     Offset: 0x0
+# CHECK-COMMON-NEXT:     VirtualAddress: 0x200000
+# CHECK-COMMON-NEXT:     PhysicalAddress: 0x200000
+# CHECK-COMMON-NEXT:     FileSize: 288
+# CHECK-COMMON-NEXT:     MemSize: 288
+# CHECK-COMMON-NEXT:     Flags [ (0x4)
+# CHECK-COMMON-NEXT:       PF_R (0x4)
+# CHECK-COMMON-NEXT:     ]
+# CHECK-COMMON-NEXT:     Alignment: 65536
+# CHECK-COMMON-NEXT:   }
+# CHECK-COMMON-NEXT:   ProgramHeader {
+# CHECK-COMMON-NEXT:     Type: PT_LOAD (0x1)
+# CHECK-COMMON-NEXT:     Offset: 0x10000
+# CHECK-COMMON-NEXT:     VirtualAddress: 0x210000
+# CHECK-COMMON-NEXT:     PhysicalAddress: 0x210000
+# CHECK-COMMON-NEXT:     FileSize: 65536
+# CHECK-COMMON-NEXT:     MemSize: 65536
+# CHECK-COMMON-NEXT:     Flags [ (0x5)
+# CHECK-COMMON-NEXT:       PF_R (0x4)
+# CHECK-COMMON-NEXT:       PF_X (0x1)
+# CHECK-COMMON-NEXT:     ]
+# CHECK-COMMON-NEXT:     Alignment: 65536
+# CHECK-COMMON-NEXT:   }
+# CHECK-COMMON-NEXT:   ProgramHeader {
+# CHECK-COMMON-NEXT:     Type: PT_GNU_STACK (0x6474E551)
+# CHECK-COMMON-NEXT:     Offset: 0x0
+# CHECK-COMMON-NEXT:     VirtualAddress: 0x0
+# CHECK-COMMON-NEXT:     PhysicalAddress: 0x0
+# CHECK-COMMON-NEXT:     FileSize: 0
+# CHECK-COMMON-NEXT:     MemSize: 0
+# CHECK-COMMON-NEXT:     Flags [ (0x6)
+# CHECK-COMMON-NEXT:       PF_R (0x4)
+# CHECK-COMMON-NEXT:       PF_W (0x2)
+# CHECK-COMMON-NEXT:     ]
+# CHECK-COMMON-NEXT:     Alignment: 0

lld/trunk/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: ]

lld/trunk/test/ELF/magic-page-combo-warn.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
+
+# Test that we warn when a page size is set and paging is disabled by -n or -N.
+
+# RUN: ld.lld -z max-page-size=0x10 -z common-page-size=0x10 -N %t -o %t2 2>&1 | FileCheck --check-prefix=WARN %s
+# RUN: llvm-readobj --program-headers %t2 | FileCheck --check-prefix=OMAGIC %s
+# RUN: ld.lld -z max-page-size=0x10 -z common-page-size=0x10 --omagic %t -o %t2  2>&1 | FileCheck --check-prefix=WARN %s
+# RUN: llvm-readobj --program-headers %t2 | FileCheck --check-prefix=OMAGIC %s
+
+# WARN: ld.lld: warning: -z max-page-size set, but paging disabled by omagic or nmagic
+# WARN-NEXT: ld.lld: warning: -z common-page-size set, but paging disabled by omagic or nmagic
+
+# OMAGIC:     ProgramHeader {
+# OMAGIC:      Type: PT_LOAD
+# 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: 8
+# OMAGIC-NEXT: }
+# OMAGIC-NEXT: ProgramHeader {
+# OMAGIC-NEXT:   Type: PT_GNU_STACK
+
+# RUN: ld.lld -z max-page-size=0x10 -z common-page-size=0x10 -n %t -o %t3  2>&1 | FileCheck --check-prefix=WARN %s
+# RUN: llvm-readobj --program-headers %t3 | FileCheck --check-prefix=NMAGIC %s
+# RUN: ld.lld -z max-page-size=0x10 -z common-page-size=0x10 --nmagic %t -o %t3  2>&1 | FileCheck --check-prefix=WARN %s
+# RUN: llvm-readobj --program-headers %t3 | FileCheck --check-prefix=NMAGIC %s
+
+# 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:   }
+
+.global _start
+_start:
+ nop
+
+.section .ro,"a"
+nop
+
+.section .rw,"aw"
+nop
+
+.section .rx,"ax"
+nop

lld/trunk/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

lld/trunk/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
+
+# 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:   }
+
 .global _start
 _start:
  nop
 
 .section .ro,"a"
 nop
 
 .section .rw,"aw"
 nop
 
 .section .rx,"ax"
 nop