beenull/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-23 08:00:20 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6
ladybird/Kernel/Prekernel/CMakeLists.txt

76 lines
2.9 KiB
Text
Raw Normal View History

Kernel: Introduce basic pre-kernel environment This implements a simple bootloader that is capable of loading ELF64 kernel images. It does this by using QEMU/GRUB to load the kernel image from disk and pass it to our bootloader as a Multiboot module. The bootloader then parses the ELF image and sets it up appropriately. The kernel's entry point is a C++ function with architecture-native code. Co-authored-by: Liav A <liavalb@gmail.com>
2021-07-18 12:47:32 +00:00
set(SOURCES
Kernel: Build UBSanitizer.cpp in aarch64 builds All these symbols will be needed once we build MiniStdLib.cpp.
2021-09-07 01:01:13 +00:00
UBSanitizer.cpp
Kernel: Build MiniStdLib.cpp in aarch64 builds
2021-09-07 00:49:38 +00:00
../MiniStdLib.cpp
Kernel: Introduce basic pre-kernel environment This implements a simple bootloader that is capable of loading ELF64 kernel images. It does this by using QEMU/GRUB to load the kernel image from disk and pass it to our bootloader as a Multiboot module. The bootloader then parses the ELF image and sets it up appropriately. The kernel's entry point is a C++ function with architecture-native code. Co-authored-by: Liav A <liavalb@gmail.com>
2021-07-18 12:47:32 +00:00
)
Prekernel: Make build on aarch64 Add a dummy Arch/aarch64/boot.S that for now does nothing but let all processor cores sleep. For now, none of the actual Prekernel code is built for aarch64.
2021-08-28 17:41:14 +00:00
if ("${SERENITY_ARCH}" STREQUAL "aarch64")
set(SOURCES
Kernel: Put boot.S first in aarch64 Prekernel source list The better fix is to have a linker script. We'll need this to set the entry point to 0x80000 for bare-metal builds anyways. But I'd like to get some UART output in qemu before I add this (otherwise I can't check if the bare-metal version does anything), so put in this temporary kludge for now.
2021-09-12 13:39:27 +00:00
# This has to be first, so that the entry point is at the start of the image.
# Needed because:
# - execution starts at the start of the image
# - the stack pointer currently starts before the start symbol, so if the start symbol isn't the first symbol, the stack will clobber arbitrary code
# FIXME: Use an aarch64-specific linker script instead.
Arch/aarch64/boot.S
Prekernel: Make build on aarch64 Add a dummy Arch/aarch64/boot.S that for now does nothing but let all processor cores sleep. For now, none of the actual Prekernel code is built for aarch64.
2021-08-28 17:41:14 +00:00
${SOURCES}
Kernel: Add a GPIO class for aarch64 This allows configuring the alternate pin functions and pin pull up/down states, which is needed for using the UART.
2021-09-25 21:53:42 +00:00
Arch/aarch64/GPIO.cpp
Kernel: Add a Mailbox class for aarch64 As a demo, query the firmware version. `Meta/serenity.sh gdb aarch64` can be used to observe that qemu puts 0x548E1 in x0 in response to this mailbox message.
2021-09-19 01:41:39 +00:00
Arch/aarch64/Mailbox.cpp
Kernel: Add a class to wrap aarch64 MIDR_EL1 We'll need part_num() to determine the MMIO address base. It's 0x3F000000 on rpi3 but 0xFE000000 on rpi4.
2021-09-12 13:42:27 +00:00
Arch/aarch64/MainIdRegister.cpp
Kernel: Add a MMIO class for aarch64 It doesn't do anything yet except figure out the peripheral base address. Very likely belongs in Kernel, not Prekernel, eventually.
2021-09-17 15:00:46 +00:00
Arch/aarch64/MMIO.cpp
Kernel: Add UART class for aarch64
2021-09-26 18:10:10 +00:00
Arch/aarch64/UART.cpp
Kernel: Let aarch64 port call into C++ Put all but the first core into a loop, make room for some stack, and call init().
2021-09-06 17:11:16 +00:00
Arch/aarch64/init.cpp
Prekernel: Make build on aarch64 Add a dummy Arch/aarch64/boot.S that for now does nothing but let all processor cores sleep. For now, none of the actual Prekernel code is built for aarch64.
2021-08-28 17:41:14 +00:00
)
else()
set(SOURCES
${SOURCES}
Arch/x86/boot.S
Arch/x86/multiboot.S
# FIXME: Eventually, some of these should build on aarch64 too.
init.cpp
../../Userland/Libraries/LibELF/Relocation.cpp
)
endif()
Kernel: Introduce basic pre-kernel environment This implements a simple bootloader that is capable of loading ELF64 kernel images. It does this by using QEMU/GRUB to load the kernel image from disk and pass it to our bootloader as a Multiboot module. The bootloader then parses the ELF image and sets it up appropriately. The kernel's entry point is a C++ function with architecture-native code. Co-authored-by: Liav A <liavalb@gmail.com>
2021-07-18 12:47:32 +00:00
if ("${SERENITY_ARCH}" STREQUAL "i686")
set(PREKERNEL_TARGET Prekernel32)
Prekernel: Make build on aarch64 Add a dummy Arch/aarch64/boot.S that for now does nothing but let all processor cores sleep. For now, none of the actual Prekernel code is built for aarch64.
2021-08-28 17:41:14 +00:00
elseif ("${SERENITY_ARCH}" STREQUAL "x86_64")
Kernel: Introduce basic pre-kernel environment This implements a simple bootloader that is capable of loading ELF64 kernel images. It does this by using QEMU/GRUB to load the kernel image from disk and pass it to our bootloader as a Multiboot module. The bootloader then parses the ELF image and sets it up appropriately. The kernel's entry point is a C++ function with architecture-native code. Co-authored-by: Liav A <liavalb@gmail.com>
2021-07-18 12:47:32 +00:00
set(PREKERNEL_TARGET Prekernel64)
Prekernel: Make build on aarch64 Add a dummy Arch/aarch64/boot.S that for now does nothing but let all processor cores sleep. For now, none of the actual Prekernel code is built for aarch64.
2021-08-28 17:41:14 +00:00
else()
set(PREKERNEL_TARGET Prekernel)
Kernel: Introduce basic pre-kernel environment This implements a simple bootloader that is capable of loading ELF64 kernel images. It does this by using QEMU/GRUB to load the kernel image from disk and pass it to our bootloader as a Multiboot module. The bootloader then parses the ELF image and sets it up appropriately. The kernel's entry point is a C++ function with architecture-native code. Co-authored-by: Liav A <liavalb@gmail.com>
2021-07-18 12:47:32 +00:00
endif()
Kernel: Support loading the kernel at almost arbitrary virtual addresses This enables further work on implementing KASLR by adding relocation support to the pre-kernel and updating the kernel to be less dependent on specific virtual memory layouts.
2021-07-26 13:10:51 +00:00
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -static")
Kernel: Introduce basic pre-kernel environment This implements a simple bootloader that is capable of loading ELF64 kernel images. It does this by using QEMU/GRUB to load the kernel image from disk and pass it to our bootloader as a Multiboot module. The bootloader then parses the ELF image and sets it up appropriately. The kernel's entry point is a C++ function with architecture-native code. Co-authored-by: Liav A <liavalb@gmail.com>
2021-07-18 12:47:32 +00:00
add_executable(${PREKERNEL_TARGET} ${SOURCES})
Kernel: Build Prekernel with -fno-threadsafe-statics Else, function-local statics create calls to __cxa_guard_acquire / __cxa_guard_release on aarch64, which we don't (yet?) implement. Since Prekernel is single-threaded, just sidestep that for now.
2021-09-12 13:09:36 +00:00
target_compile_options(${PREKERNEL_TARGET} PRIVATE -no-pie -fno-pic -fno-threadsafe-statics)
Kernel: Introduce basic pre-kernel environment This implements a simple bootloader that is capable of loading ELF64 kernel images. It does this by using QEMU/GRUB to load the kernel image from disk and pass it to our bootloader as a Multiboot module. The bootloader then parses the ELF image and sets it up appropriately. The kernel's entry point is a C++ function with architecture-native code. Co-authored-by: Liav A <liavalb@gmail.com>
2021-07-18 12:47:32 +00:00
Kernel: Move prekernel linker.ld into Arch subdirectories This moves Kernel/Prekernel/linker.ld unchanged to Kernel/Prekernel/Arch/aarch64 and Kernel/Prekernel/Arch/x86. The aarch64 will change in a future commit. No behavior change.
2021-09-27 00:16:46 +00:00
if ("${SERENITY_ARCH}" STREQUAL "aarch64")
set(PREKERNEL_LINKER_SCRIPT "${CMAKE_CURRENT_SOURCE_DIR}/Arch/aarch64/linker.ld")
else()
set(PREKERNEL_LINKER_SCRIPT "${CMAKE_CURRENT_SOURCE_DIR}/Arch/x86/linker.ld")
endif()
target_link_options(${PREKERNEL_TARGET} PRIVATE LINKER:-T ${PREKERNEL_LINKER_SCRIPT} -nostdlib LINKER:--no-pie)
set_target_properties(${PREKERNEL_TARGET} PROPERTIES LINK_DEPENDS ${PREKERNEL_LINKER_SCRIPT})
Kernel: Introduce basic pre-kernel environment This implements a simple bootloader that is capable of loading ELF64 kernel images. It does this by using QEMU/GRUB to load the kernel image from disk and pass it to our bootloader as a Multiboot module. The bootloader then parses the ELF image and sets it up appropriately. The kernel's entry point is a C++ function with architecture-native code. Co-authored-by: Liav A <liavalb@gmail.com>
2021-07-18 12:47:32 +00:00
Meta: Switch to a SuperBuild that splits host and target builds Replace the old logic where we would start with a host build, and swap all the CMake compiler and target variables underneath it to trick CMake into building for Serenity after we configured and built the Lagom code generators. The SuperBuild creates two ExternalProjects, one for Lagom and one for Serenity. The Serenity project depends on the install stage for the Lagom build. The SuperBuild also generates a CMakeToolchain file for the Serenity build to use that replaces the old toolchain file that was only used for Ports. To ensure that code generators are rebuilt when core libraries such as AK and LibCore are modified, developers will need to direct their manual `ninja` invocations to the SuperBuild's binary directory instead of the Serenity binary directory. This commit includes warning coalescing and option style cleanup for the affected CMakeLists in the Kernel, top level, and runtime support libraries. A large part of the cleanup is replacing USE_CLANG_TOOLCHAIN with the proper CMAKE_CXX_COMPILER_ID variable, which will no longer be confused by a host clang compiler.
2021-09-07 08:21:36 +00:00
if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
Kernel: Don't link Prekernel against kernel_heap This was added in b5c98ede084e5d29, but it looks like a copy-paste mistake from Kernel/CMakeLists.txt. Unbreaks building for aarch64.
2021-09-17 14:01:46 +00:00
target_link_libraries(${PREKERNEL_TARGET} PRIVATE gcc)
Meta: Switch to a SuperBuild that splits host and target builds Replace the old logic where we would start with a host build, and swap all the CMake compiler and target variables underneath it to trick CMake into building for Serenity after we configured and built the Lagom code generators. The SuperBuild creates two ExternalProjects, one for Lagom and one for Serenity. The Serenity project depends on the install stage for the Lagom build. The SuperBuild also generates a CMakeToolchain file for the Serenity build to use that replaces the old toolchain file that was only used for Ports. To ensure that code generators are rebuilt when core libraries such as AK and LibCore are modified, developers will need to direct their manual `ninja` invocations to the SuperBuild's binary directory instead of the Serenity binary directory. This commit includes warning coalescing and option style cleanup for the affected CMakeLists in the Kernel, top level, and runtime support libraries. A large part of the cleanup is replacing USE_CLANG_TOOLCHAIN with the proper CMAKE_CXX_COMPILER_ID variable, which will no longer be confused by a host clang compiler.
2021-09-07 08:21:36 +00:00
elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang$")
Kernel: Don't link Prekernel against kernel_heap This was added in b5c98ede084e5d29, but it looks like a copy-paste mistake from Kernel/CMakeLists.txt. Unbreaks building for aarch64.
2021-09-17 14:01:46 +00:00
target_link_libraries(${PREKERNEL_TARGET} PRIVATE "clang_rt.builtins-${SERENITY_CLANG_ARCH}" c++abi)
Meta: Add Clang support to the CMake build scripts
2021-07-13 14:43:45 +00:00
endif()
Kernel: Introduce basic pre-kernel environment This implements a simple bootloader that is capable of loading ELF64 kernel images. It does this by using QEMU/GRUB to load the kernel image from disk and pass it to our bootloader as a Multiboot module. The bootloader then parses the ELF image and sets it up appropriately. The kernel's entry point is a C++ function with architecture-native code. Co-authored-by: Liav A <liavalb@gmail.com>
2021-07-18 12:47:32 +00:00
Prekernel: Make build on aarch64 Add a dummy Arch/aarch64/boot.S that for now does nothing but let all processor cores sleep. For now, none of the actual Prekernel code is built for aarch64.
2021-08-28 17:41:14 +00:00
if ("${SERENITY_ARCH}" STREQUAL "i686" OR "${SERENITY_ARCH}" STREQUAL "x86_64")
add_custom_command(
TARGET ${PREKERNEL_TARGET} POST_BUILD
COMMAND ${CMAKE_OBJCOPY} -O elf32-i386 ${CMAKE_CURRENT_BINARY_DIR}/${PREKERNEL_TARGET} ${CMAKE_CURRENT_BINARY_DIR}/Prekernel
BYPRODUCTS ${CMAKE_CURRENT_BINARY_DIR}/Prekernel
)
endif()
Kernel: Introduce basic pre-kernel environment This implements a simple bootloader that is capable of loading ELF64 kernel images. It does this by using QEMU/GRUB to load the kernel image from disk and pass it to our bootloader as a Multiboot module. The bootloader then parses the ELF image and sets it up appropriately. The kernel's entry point is a C++ function with architecture-native code. Co-authored-by: Liav A <liavalb@gmail.com>
2021-07-18 12:47:32 +00:00
install(FILES "${CMAKE_CURRENT_BINARY_DIR}/Prekernel" DESTINATION boot)
CMake: Remove Prekernel incompatible options instead of overriding The pattern of having Prekernel inherit all of the build flags of the Kernel, and then disabling some flags by adding `-fno-<flag>` options to then disable those options doesn't work in all scenarios. For example the ASAN flag `-fasan-shadow-offset=<offset>` has no option to disable it once it's been passed, so in a future change where this flag is added we need to be able to disable it cleanly. The cleaner way is to just allow the Prekernel CMake logic to filter out the COMPILE_OPTIONS specified for that specific target. This allows us to remove individual options without trashing all inherited options.
2021-08-25 03:28:51 +00:00
# Remove options which the Prekernel environment doesn't support.
get_target_property(PREKERNEL_TARGET_OPTIONS ${PREKERNEL_TARGET} COMPILE_OPTIONS)
list(REMOVE_ITEM PREKERNEL_TARGET_OPTIONS "-fsanitize-coverage=trace-pc")
list(REMOVE_ITEM PREKERNEL_TARGET_OPTIONS "-fsanitize=kernel-address")
set_target_properties(${PREKERNEL_TARGET} PROPERTIES COMPILE_OPTIONS "${PREKERNEL_TARGET_OPTIONS}")
Reference in a new issue Copy permalink