[lld-macho] Add -pagezero_size

[Link1J]

Summary

Adds -pagezero_size. -pagezero_size commonly used for kernel development.
-pagezero_size changes the __PAGEZERO size, removing that segment if it is set to zero.

One of the four flags from D118570: [lld-macho] Add support for -image_base, -static, -pagezero_size, and -version_load_command
Now with error messages and tests.

[oontvoo]

lld/MachO/Target.h

38–39 ↗

(On Diff #405042)

lld/test/MachO/pagesize-zero.s

1 ↗

(On Diff #405042)

could you group all three of these files into the one test file?

[int3]

lld/MachO/Driver.cpp

656–657

Hm, this seems like an ld64 implementation error. Personally I think it makes more sense to round it to the page size...

658

nit: would be nice to use the isAligned helper for a bit more explicitness -- isAligned(Align(target->getPageSize()), pagezeroSize)

lld/test/MachO/pagesize-zero.s

1 ↗

(On Diff #405042)

+1

lld/test/MachO/pagezero-misaligned.s

3 ↗

(On Diff #405042)

we should test the 32-bit case here too (regardless of whether we use 4KiB or the actual page size to round down).

the only 32-bit target we properly support is arm64_32, so that's what I would use here. (You can use %lld-watchos instead of %lld to link for that target.)

[Link1J]

lld/MachO/Target.h

38–39 ↗

(On Diff #405042)

I know that is how it should be, but it doesn't seem to build correctly on Linux.
Here is the error message that appears

ld.lld: error: undefined symbol: lld::macho::ILP32::pageZeroSize
>>> referenced by Optional.h:0 (/var/lib/buildkite-agent/builds/llvm-project/llvm/include/llvm/ADT/Optional.h:0)
>>>               ARM.cpp.o:(lld::macho::createARMTargetInfo(unsigned int)) in archive lib/liblldMachO.a
>>> referenced by Optional.h:0 (/var/lib/buildkite-agent/builds/llvm-project/llvm/include/llvm/ADT/Optional.h:0)
>>>               ARM64_32.cpp.o:(lld::macho::createARM64_32TargetInfo()) in archive lib/liblldMachO.a
 
ld.lld: error: undefined symbol: lld::macho::LP64::pageZeroSize
>>> referenced by Optional.h:0 (/var/lib/buildkite-agent/builds/llvm-project/llvm/include/llvm/ADT/Optional.h:0)
>>>               ARM64.cpp.o:(lld::macho::createARM64TargetInfo()) in archive lib/liblldMachO.a
>>> referenced by Optional.h:0 (/var/lib/buildkite-agent/builds/llvm-project/llvm/include/llvm/ADT/Optional.h:0)
>>>               X86_64.cpp.o:(lld::macho::createX86_64TargetInfo()) in archive lib/liblldMachO.a

Gotten from https://buildkite.com/llvm-project/premerge-checks/builds/76612#af4b783f-6fe5-4a09-a98e-9b180f113190/467-3299

[int3]

lld/MachO/Target.h

136 ↗

(On Diff #405042)

re the compilation bug above: what if you changed this from a constexpr to a const?

[Link1J]

lld/MachO/Target.h

136 ↗

(On Diff #405042)

Changing constexpr to const doesn't work. But adding inline does work.
It seems the C++14 spec doesn't like doing what we want to do, because it fails on gcc with -std=c++14.
MSVC is the only one that doesn't care about the C++ version, and so it always works with MSVC and clang-cl.

[Link1J]

lld/MachO/Driver.cpp

656–657

Well, ld64 has some interesting behavior because of what it does.
If you are to set -pagezero_size to 0x1000 on ARM64, but round up to page size (16KB).
If you are to set -pagezero_size to 0x1001 on ARM64, it will report the rounding down, but round up to page size.

I am going to make it operate on page size, over whatever ld64 does, so that it makes a lot more sense. So it will round down to page size, and never make it larger then expected.

[int3]

Nice, almost there!

Could you add a description of what -pagezero_size does to the commit message? I know you linked to your original diff, but it would be nice to avoid having people click through to find it :)

lld/MachO/Driver.cpp

1142

some ld64 engineers may read this, let's not say 'dumb' :)... 'weird' is fine

1145–1146

how about printing out the new value? like instead of rounding down to realign, we could have rounding down to 0x10000000 or something

(we can print out the size int easily using Twine::utohexstr)

lld/test/MachO/pagezero.s

11

IMO it would make the test clearer if we used llvm-readobj --macho-segment instead. Then we could test the segment size directly as follows:

# CHECK:        Name: __PAGEZERO
# CHECK-NEXT:   Size:
# CHECK-NEXT:   vmaddr: 0x0

also, we can reuse the same check lines if we use FileCheck's numeric substitutions (https://llvm.org/docs/CommandGuide/FileCheck.html#filecheck-numeric-substitution-blocks):

# RUN: llvm-readobj --macho-segment %t/arm64_32 | FileCheck %s -D#SIZE=0x0
# CHECK:        Name: __PAGEZERO
# CHECK-NEXT:   Size:
# CHECK-NEXT:   vmaddr: 0x[[#%x,SIZE]]

13

nit: use - instead of _ for CHECK- lines

29

nit: most other tests use this naming scheme

[int3]

lld/MachO/Driver.cpp

656–657

lol that's pretty funny behavior. yeah I agree with your choice here

[int3]

lgtm. Do you need me to commit it for you? If so, let me know what name and email I should use :)

lld/MachO/Driver.cpp

1142

[Link1J]

Can you please commit it for me.
Name: Jared Irwin
Email: [e-mail]

lld/MachO/Driver.cpp

static TargetInfo *createTargetInfo(InputArgList &args) {
   if (archName.empty()) {
     error("must specify -arch");
     return nullptr;
   }
 
   PlatformType platform = parsePlatformVersion(args);
   config->platformInfo.target =
       MachO::Target(getArchitectureFromName(archName), platform);
 
   uint32_t cpuType;
   uint32_t cpuSubtype;
   std::tie(cpuType, cpuSubtype) = getCPUTypeFromArchitecture(config->arch());
 
   switch (cpuType) {
   case CPU_TYPE_X86_64:
     return createX86_64TargetInfo();
   case CPU_TYPE_ARM64:
     return createARM64TargetInfo();
   case CPU_TYPE_ARM64_32:
bool macho::link(ArrayRef<const char *> argsArr, llvm::raw_ostream &stdoutOS,
   config = std::make_unique<Configuration>();
   symtab = std::make_unique<SymbolTable>();
   target = createTargetInfo(args);
   depTracker = std::make_unique<DependencyTracker>(
       args.getLastArgValue(OPT_dependency_info));
   if (errorCount())
     return false;
 
+  if (args.hasArg(OPT_pagezero_size)) {
+    uint64_t pagezeroSize = args::getHex(args, OPT_pagezero_size, 0);
+
+    // ld64 does something really weird. It attempts to realign the value to the
+    // page size, but assumes the the page size is 4K. This doesn't work with
+    // most of Apple's ARM64 devices, which use a page size of 16K. This means
+    // that it will first 4K align it by rounding down, then round up to 16K.
+    // This probably only happened because no one using this arg with anything
+    // other then 0, so no one checked if it did what is what it says it does.
+
+    // So we are not copying this weird behavior and doing the it in a logical
+    // way, by always rounding down to page size.
+    if (!isAligned(Align(target->getPageSize()), pagezeroSize)) {
+      pagezeroSize -= pagezeroSize % target->getPageSize();
+      warn("__PAGEZERO size is not page aligned, rounding down to 0x" +
+           Twine::utohexstr(pagezeroSize));
+    }
+
+    target->pageZeroSize = pagezeroSize;
+  }
+
   config->osoPrefix = args.getLastArgValue(OPT_oso_prefix);
   if (!config->osoPrefix.empty()) {
     // Expand special characters, such as ".", "..", or  "~", if present.
     // Note: LD64 only expands "." and not other special characters.
     // That seems silly to imitate so we will not try to follow it, but rather
     // just use real_path() to do it.
 
     // The max path length is 4096, in theory. However that seems quite long

lld/MachO/Options.td

def pie : Flag<["-"], "pie">,
     HelpText<"Build a position independent executable (default)">,
     Group<grp_main>;
 def no_pie : Flag<["-"], "no_pie">,
     HelpText<"Do not build a position independent executable">,
     Group<grp_main>;
 def pagezero_size : Separate<["-"], "pagezero_size">,
     MetaVarName<"<size>">,
     HelpText<"Size of unreadable segment at address zero is hex <size> (default is 4KB on 32-bit and 4GB on 64-bit)">,
-    Flags<[HelpHidden]>,
     Group<grp_main>;
 def stack_size : Separate<["-"], "stack_size">,
     MetaVarName<"<size>">,
     HelpText<"Maximum hex stack size for the main thread in a program. (default is 8MB)">,
     Flags<[HelpHidden]>,
     Group<grp_main>;
 def allow_stack_execute : Flag<["-"], "allow_stack_execute">,
     HelpText<"Mark stack segment as executable">,

lld/MachO/SyntheticSections.h

 };
 
 // A hidden section that exists solely for the purpose of creating the
 // __PAGEZERO segment, which is used to catch null pointer dereferences.
 class PageZeroSection final : public SyntheticSection {
 public:
   PageZeroSection();
   bool isHidden() const override { return true; }
+  bool isNeeded() const override { return target->pageZeroSize != 0; }
   uint64_t getSize() const override { return target->pageZeroSize; }
   uint64_t getFileSize() const override { return 0; }
   void writeTo(uint8_t *buf) const override {}
 };
 
 // This is the base class for the GOT and TLVPointer sections, which are nearly
 // functionally identical -- they will both be populated by dyld with addresses
 // to non-lazily-loaded dylib symbols. The main difference is that the

lld/test/MachO/lit.local.cfg

 # -*- Python -*-
 
 import os
 
 # We specify the most commonly-used archs and platform versions in our tests
 # here. Tests which need different settings can just append to this, as only
 # the last value will be used.
 #
 # Note however that this does not apply to `-syslibroot`: each instance of that
 # flag will append to the set of library roots. As such, we define a separate
 # alias for each platform.
 
-config.substitutions.append(('%lld-watchos',
-    'ld64.lld -fatal_warnings -arch arm64_32 -platform_version watchos 7.0 8.0 -syslibroot ' +
-    os.path.join(config.test_source_root, "MachO", "Inputs", "WatchOS.sdk")))
+lld_watchos = ('ld64.lld -arch arm64_32 -platform_version watchos 7.0 8.0 -syslibroot ' +
+    os.path.join(config.test_source_root, "MachO", "Inputs", "WatchOS.sdk"))
+config.substitutions.append(('%lld-watchos', lld_watchos + ' -fatal_warnings'))
+config.substitutions.append(('%no_fatal_warnings_lld-watchos', lld_watchos))
 
 # Since most of our tests are written around x86_64, we give this platform the
 # shortest substitution of "%lld".
 lld = ('ld64.lld -arch x86_64 -platform_version macos 10.15 11.0 -syslibroot ' +
     os.path.join(config.test_source_root, "MachO", "Inputs", "MacOSX.sdk"))
 config.substitutions.append(('%lld', lld + ' -fatal_warnings'))
 config.substitutions.append(('%no_fatal_warnings_lld', lld))

lld/test/MachO/pagezero.s

+# REQUIRES: x86, aarch64
+# RUN: rm -rf %t; mkdir %t
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %s -o %t/x86_64.o
+# RUN: llvm-mc -filetype=obj -triple=arm64_32-apple-darwin %s -o %t/arm64_32.o
+
+# RUN: %lld -lSystem -arch x86_64 -o %t/x86_64 %t/x86_64.o -pagezero_size 100000
+# RUN: llvm-readobj --macho-segment %t/x86_64 | FileCheck %s -D#VMSIZE=0x100000 -D#SIZE=72
+
+# RUN: %lld-watchos -lSystem -arch arm64_32 -o %t/arm64_32 %t/arm64_32.o -pagezero_size 100000
+# RUN: llvm-readobj --macho-segment %t/arm64_32 | FileCheck %s -D#VMSIZE=0x100000 -D#SIZE=56
+
+# RUN: %lld -lSystem -arch x86_64 -o %t/zero %t/x86_64.o -pagezero_size 0
+# RUN: llvm-readobj --macho-segment %t/zero | FileCheck %s --check-prefix=CHECK-ZERO -D#VMSIZE=0x1000 -D#SIZE=152
+
+# RUN: %no_fatal_warnings_lld -lSystem -arch x86_64 -o %t/x86_64-misalign %t/x86_64.o -pagezero_size 1001 2>&1 | FileCheck %s --check-prefix=LINK -D#SIZE=0x1000
+# RUN: llvm-readobj --macho-segment %t/x86_64-misalign | FileCheck %s -D#VMSIZE=0x1000 -D#SIZE=72
+
+# RUN: %no_fatal_warnings_lld-watchos -lSystem -arch arm64_32 -o %t/arm64_32-misalign-4K %t/arm64_32.o -pagezero_size 1001 2>&1 | FileCheck %s --check-prefix=LINK -D#SIZE=0x0
+# RUN: llvm-readobj --macho-segment %t/arm64_32-misalign-4K | FileCheck %s --check-prefix=CHECK-ZERO -D#VMSIZE=0x4000 -D#SIZE=124
+
+# RUN: %no_fatal_warnings_lld-watchos -lSystem -arch arm64_32 -o %t/arm64_32-misalign-16K %t/arm64_32.o -pagezero_size 4001 2>&1 | FileCheck %s --check-prefix=LINK -D#SIZE=0x4000
+# RUN: llvm-readobj --macho-segment %t/arm64_32-misalign-16K | FileCheck %s -D#VMSIZE=0x4000 -D#SIZE=56
+
+# LINK: warning: __PAGEZERO size is not page aligned, rounding down to 0x[[#%x,SIZE]]
+
+# CHECK:        Name: __PAGEZERO
+# CHECK-NEXT:   Size: [[#%d,SIZE]]
+# CHECK-NEXT:   vmaddr: 0x0
+# CHECK-NEXT:   vmsize: 0x[[#%x,VMSIZE]]
+
+# CHECK-ZERO:        Name: __TEXT
+# CHECK-ZERO-NEXT:   Size: [[#%d,SIZE]]
+# CHECK-ZERO-NEXT:   vmaddr: 0x0
+# CHECK-ZERO-NEXT:   vmsize: 0x[[#%x,VMSIZE]]
+
+.globl _main
+_main: