cdde20622b
* For details, see the release notes:
- https://releases.llvm.org/19.1.0/docs/ReleaseNotes.html
- https://releases.llvm.org/19.1.0/tools/clang/docs/ReleaseNotes.html
- https://releases.llvm.org/19.1.0/tools/clang/tools/extra/docs/ReleaseNotes.html
- https://releases.llvm.org/19.1.0/projects/libcxx/docs/ReleaseNotes.html
- https://releases.llvm.org/19.1.0/tools/lld/docs/ReleaseNotes.html
* New LLVM tool: reduce-chunk-list to help find bugs using debug
counters. See the Programmer's Manual for usage.
* New Clang tools: clang-installapi for Apple-related package
management, clang-nvlink-wrapper as a wrapper around `nvlink`.
- No longer include OpenMP offload libraries.
- Rebase patches:
* clang-fix-openmp-test.patch
* libcxx-test-library-path.patch
* llvm-do-not-install-static-libraries.patch
* llvm_build_tablegen_component_as_shared_library.patch
- Remove obsolete patches:
* lld-default-sha1.patch because upstream switched to sha1.
* llvm-remove-clang-only-flags.patch because warning flags are no
longer autodetected.
* openmp-dont-run-gpu-arch.patch because we're excluding the
offload project for now.
- Add llvm-fix-build-failure-on-ppc64le.patch to fix ppc64le build.
- Require Python 3.11 on Leap because we need Python >= 3.8 now.
OBS-URL: https://build.opensuse.org/package/show/devel:tools:compiler/llvm19?expand=0&rev=1
478 lines
19 KiB
C
478 lines
19 KiB
C
//===----------------------------------------------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//
|
|
// Darwin's alternative to DWARF based unwind encodings.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
#ifndef __COMPACT_UNWIND_ENCODING__
|
|
#define __COMPACT_UNWIND_ENCODING__
|
|
|
|
#include <stdint.h>
|
|
|
|
//
|
|
// Compilers can emit standard DWARF FDEs in the __TEXT,__eh_frame section
|
|
// of object files. Or compilers can emit compact unwind information in
|
|
// the __LD,__compact_unwind section.
|
|
//
|
|
// When the linker creates a final linked image, it will create a
|
|
// __TEXT,__unwind_info section. This section is a small and fast way for the
|
|
// runtime to access unwind info for any given function. If the compiler
|
|
// emitted compact unwind info for the function, that compact unwind info will
|
|
// be encoded in the __TEXT,__unwind_info section. If the compiler emitted
|
|
// DWARF unwind info, the __TEXT,__unwind_info section will contain the offset
|
|
// of the FDE in the __TEXT,__eh_frame section in the final linked image.
|
|
//
|
|
// Note: Previously, the linker would transform some DWARF unwind infos into
|
|
// compact unwind info. But that is fragile and no longer done.
|
|
|
|
|
|
//
|
|
// The compact unwind encoding is a 32-bit value which encoded in an
|
|
// architecture specific way, which registers to restore from where, and how
|
|
// to unwind out of the function.
|
|
//
|
|
typedef uint32_t compact_unwind_encoding_t;
|
|
|
|
|
|
// architecture independent bits
|
|
enum {
|
|
UNWIND_IS_NOT_FUNCTION_START = 0x80000000,
|
|
UNWIND_HAS_LSDA = 0x40000000,
|
|
UNWIND_PERSONALITY_MASK = 0x30000000,
|
|
};
|
|
|
|
|
|
|
|
|
|
//
|
|
// x86
|
|
//
|
|
// 1-bit: start
|
|
// 1-bit: has lsda
|
|
// 2-bit: personality index
|
|
//
|
|
// 4-bits: 0=old, 1=ebp based, 2=stack-imm, 3=stack-ind, 4=DWARF
|
|
// ebp based:
|
|
// 15-bits (5*3-bits per reg) register permutation
|
|
// 8-bits for stack offset
|
|
// frameless:
|
|
// 8-bits stack size
|
|
// 3-bits stack adjust
|
|
// 3-bits register count
|
|
// 10-bits register permutation
|
|
//
|
|
enum {
|
|
UNWIND_X86_MODE_MASK = 0x0F000000,
|
|
UNWIND_X86_MODE_EBP_FRAME = 0x01000000,
|
|
UNWIND_X86_MODE_STACK_IMMD = 0x02000000,
|
|
UNWIND_X86_MODE_STACK_IND = 0x03000000,
|
|
UNWIND_X86_MODE_DWARF = 0x04000000,
|
|
|
|
UNWIND_X86_EBP_FRAME_REGISTERS = 0x00007FFF,
|
|
UNWIND_X86_EBP_FRAME_OFFSET = 0x00FF0000,
|
|
|
|
UNWIND_X86_FRAMELESS_STACK_SIZE = 0x00FF0000,
|
|
UNWIND_X86_FRAMELESS_STACK_ADJUST = 0x0000E000,
|
|
UNWIND_X86_FRAMELESS_STACK_REG_COUNT = 0x00001C00,
|
|
UNWIND_X86_FRAMELESS_STACK_REG_PERMUTATION = 0x000003FF,
|
|
|
|
UNWIND_X86_DWARF_SECTION_OFFSET = 0x00FFFFFF,
|
|
};
|
|
|
|
enum {
|
|
UNWIND_X86_REG_NONE = 0,
|
|
UNWIND_X86_REG_EBX = 1,
|
|
UNWIND_X86_REG_ECX = 2,
|
|
UNWIND_X86_REG_EDX = 3,
|
|
UNWIND_X86_REG_EDI = 4,
|
|
UNWIND_X86_REG_ESI = 5,
|
|
UNWIND_X86_REG_EBP = 6,
|
|
};
|
|
|
|
//
|
|
// For x86 there are four modes for the compact unwind encoding:
|
|
// UNWIND_X86_MODE_EBP_FRAME:
|
|
// EBP based frame where EBP is push on stack immediately after return address,
|
|
// then ESP is moved to EBP. Thus, to unwind ESP is restored with the current
|
|
// EPB value, then EBP is restored by popping off the stack, and the return
|
|
// is done by popping the stack once more into the pc.
|
|
// All non-volatile registers that need to be restored must have been saved
|
|
// in a small range in the stack that starts EBP-4 to EBP-1020. The offset/4
|
|
// is encoded in the UNWIND_X86_EBP_FRAME_OFFSET bits. The registers saved
|
|
// are encoded in the UNWIND_X86_EBP_FRAME_REGISTERS bits as five 3-bit entries.
|
|
// Each entry contains which register to restore.
|
|
// UNWIND_X86_MODE_STACK_IMMD:
|
|
// A "frameless" (EBP not used as frame pointer) function with a small
|
|
// constant stack size. To return, a constant (encoded in the compact
|
|
// unwind encoding) is added to the ESP. Then the return is done by
|
|
// popping the stack into the pc.
|
|
// All non-volatile registers that need to be restored must have been saved
|
|
// on the stack immediately after the return address. The stack_size/4 is
|
|
// encoded in the UNWIND_X86_FRAMELESS_STACK_SIZE (max stack size is 1024).
|
|
// The number of registers saved is encoded in UNWIND_X86_FRAMELESS_STACK_REG_COUNT.
|
|
// UNWIND_X86_FRAMELESS_STACK_REG_PERMUTATION contains which registers were
|
|
// saved and their order.
|
|
// UNWIND_X86_MODE_STACK_IND:
|
|
// A "frameless" (EBP not used as frame pointer) function large constant
|
|
// stack size. This case is like the previous, except the stack size is too
|
|
// large to encode in the compact unwind encoding. Instead it requires that
|
|
// the function contains "subl $nnnnnnnn,ESP" in its prolog. The compact
|
|
// encoding contains the offset to the nnnnnnnn value in the function in
|
|
// UNWIND_X86_FRAMELESS_STACK_SIZE.
|
|
// UNWIND_X86_MODE_DWARF:
|
|
// No compact unwind encoding is available. Instead the low 24-bits of the
|
|
// compact encoding is the offset of the DWARF FDE in the __eh_frame section.
|
|
// This mode is never used in object files. It is only generated by the
|
|
// linker in final linked images which have only DWARF unwind info for a
|
|
// function.
|
|
//
|
|
// The permutation encoding is a Lehmer code sequence encoded into a
|
|
// single variable-base number so we can encode the ordering of up to
|
|
// six registers in a 10-bit space.
|
|
//
|
|
// The following is the algorithm used to create the permutation encoding used
|
|
// with frameless stacks. It is passed the number of registers to be saved and
|
|
// an array of the register numbers saved.
|
|
//
|
|
//uint32_t permute_encode(uint32_t registerCount, const uint32_t registers[6])
|
|
//{
|
|
// uint32_t renumregs[6];
|
|
// for (int i=6-registerCount; i < 6; ++i) {
|
|
// int countless = 0;
|
|
// for (int j=6-registerCount; j < i; ++j) {
|
|
// if ( registers[j] < registers[i] )
|
|
// ++countless;
|
|
// }
|
|
// renumregs[i] = registers[i] - countless -1;
|
|
// }
|
|
// uint32_t permutationEncoding = 0;
|
|
// switch ( registerCount ) {
|
|
// case 6:
|
|
// permutationEncoding |= (120*renumregs[0] + 24*renumregs[1]
|
|
// + 6*renumregs[2] + 2*renumregs[3]
|
|
// + renumregs[4]);
|
|
// break;
|
|
// case 5:
|
|
// permutationEncoding |= (120*renumregs[1] + 24*renumregs[2]
|
|
// + 6*renumregs[3] + 2*renumregs[4]
|
|
// + renumregs[5]);
|
|
// break;
|
|
// case 4:
|
|
// permutationEncoding |= (60*renumregs[2] + 12*renumregs[3]
|
|
// + 3*renumregs[4] + renumregs[5]);
|
|
// break;
|
|
// case 3:
|
|
// permutationEncoding |= (20*renumregs[3] + 4*renumregs[4]
|
|
// + renumregs[5]);
|
|
// break;
|
|
// case 2:
|
|
// permutationEncoding |= (5*renumregs[4] + renumregs[5]);
|
|
// break;
|
|
// case 1:
|
|
// permutationEncoding |= (renumregs[5]);
|
|
// break;
|
|
// }
|
|
// return permutationEncoding;
|
|
//}
|
|
//
|
|
|
|
|
|
|
|
|
|
//
|
|
// x86_64
|
|
//
|
|
// 1-bit: start
|
|
// 1-bit: has lsda
|
|
// 2-bit: personality index
|
|
//
|
|
// 4-bits: 0=old, 1=rbp based, 2=stack-imm, 3=stack-ind, 4=DWARF
|
|
// rbp based:
|
|
// 15-bits (5*3-bits per reg) register permutation
|
|
// 8-bits for stack offset
|
|
// frameless:
|
|
// 8-bits stack size
|
|
// 3-bits stack adjust
|
|
// 3-bits register count
|
|
// 10-bits register permutation
|
|
//
|
|
enum {
|
|
UNWIND_X86_64_MODE_MASK = 0x0F000000,
|
|
UNWIND_X86_64_MODE_RBP_FRAME = 0x01000000,
|
|
UNWIND_X86_64_MODE_STACK_IMMD = 0x02000000,
|
|
UNWIND_X86_64_MODE_STACK_IND = 0x03000000,
|
|
UNWIND_X86_64_MODE_DWARF = 0x04000000,
|
|
|
|
UNWIND_X86_64_RBP_FRAME_REGISTERS = 0x00007FFF,
|
|
UNWIND_X86_64_RBP_FRAME_OFFSET = 0x00FF0000,
|
|
|
|
UNWIND_X86_64_FRAMELESS_STACK_SIZE = 0x00FF0000,
|
|
UNWIND_X86_64_FRAMELESS_STACK_ADJUST = 0x0000E000,
|
|
UNWIND_X86_64_FRAMELESS_STACK_REG_COUNT = 0x00001C00,
|
|
UNWIND_X86_64_FRAMELESS_STACK_REG_PERMUTATION = 0x000003FF,
|
|
|
|
UNWIND_X86_64_DWARF_SECTION_OFFSET = 0x00FFFFFF,
|
|
};
|
|
|
|
enum {
|
|
UNWIND_X86_64_REG_NONE = 0,
|
|
UNWIND_X86_64_REG_RBX = 1,
|
|
UNWIND_X86_64_REG_R12 = 2,
|
|
UNWIND_X86_64_REG_R13 = 3,
|
|
UNWIND_X86_64_REG_R14 = 4,
|
|
UNWIND_X86_64_REG_R15 = 5,
|
|
UNWIND_X86_64_REG_RBP = 6,
|
|
};
|
|
//
|
|
// For x86_64 there are four modes for the compact unwind encoding:
|
|
// UNWIND_X86_64_MODE_RBP_FRAME:
|
|
// RBP based frame where RBP is push on stack immediately after return address,
|
|
// then RSP is moved to RBP. Thus, to unwind RSP is restored with the current
|
|
// EPB value, then RBP is restored by popping off the stack, and the return
|
|
// is done by popping the stack once more into the pc.
|
|
// All non-volatile registers that need to be restored must have been saved
|
|
// in a small range in the stack that starts RBP-8 to RBP-2040. The offset/8
|
|
// is encoded in the UNWIND_X86_64_RBP_FRAME_OFFSET bits. The registers saved
|
|
// are encoded in the UNWIND_X86_64_RBP_FRAME_REGISTERS bits as five 3-bit entries.
|
|
// Each entry contains which register to restore.
|
|
// UNWIND_X86_64_MODE_STACK_IMMD:
|
|
// A "frameless" (RBP not used as frame pointer) function with a small
|
|
// constant stack size. To return, a constant (encoded in the compact
|
|
// unwind encoding) is added to the RSP. Then the return is done by
|
|
// popping the stack into the pc.
|
|
// All non-volatile registers that need to be restored must have been saved
|
|
// on the stack immediately after the return address. The stack_size/8 is
|
|
// encoded in the UNWIND_X86_64_FRAMELESS_STACK_SIZE (max stack size is 2048).
|
|
// The number of registers saved is encoded in UNWIND_X86_64_FRAMELESS_STACK_REG_COUNT.
|
|
// UNWIND_X86_64_FRAMELESS_STACK_REG_PERMUTATION contains which registers were
|
|
// saved and their order.
|
|
// UNWIND_X86_64_MODE_STACK_IND:
|
|
// A "frameless" (RBP not used as frame pointer) function large constant
|
|
// stack size. This case is like the previous, except the stack size is too
|
|
// large to encode in the compact unwind encoding. Instead it requires that
|
|
// the function contains "subq $nnnnnnnn,RSP" in its prolog. The compact
|
|
// encoding contains the offset to the nnnnnnnn value in the function in
|
|
// UNWIND_X86_64_FRAMELESS_STACK_SIZE.
|
|
// UNWIND_X86_64_MODE_DWARF:
|
|
// No compact unwind encoding is available. Instead the low 24-bits of the
|
|
// compact encoding is the offset of the DWARF FDE in the __eh_frame section.
|
|
// This mode is never used in object files. It is only generated by the
|
|
// linker in final linked images which have only DWARF unwind info for a
|
|
// function.
|
|
//
|
|
|
|
|
|
// ARM64
|
|
//
|
|
// 1-bit: start
|
|
// 1-bit: has lsda
|
|
// 2-bit: personality index
|
|
//
|
|
// 4-bits: 4=frame-based, 3=DWARF, 2=frameless
|
|
// frameless:
|
|
// 12-bits of stack size
|
|
// frame-based:
|
|
// 4-bits D reg pairs saved
|
|
// 5-bits X reg pairs saved
|
|
// DWARF:
|
|
// 24-bits offset of DWARF FDE in __eh_frame section
|
|
//
|
|
enum {
|
|
UNWIND_ARM64_MODE_MASK = 0x0F000000,
|
|
UNWIND_ARM64_MODE_FRAMELESS = 0x02000000,
|
|
UNWIND_ARM64_MODE_DWARF = 0x03000000,
|
|
UNWIND_ARM64_MODE_FRAME = 0x04000000,
|
|
|
|
UNWIND_ARM64_FRAME_X19_X20_PAIR = 0x00000001,
|
|
UNWIND_ARM64_FRAME_X21_X22_PAIR = 0x00000002,
|
|
UNWIND_ARM64_FRAME_X23_X24_PAIR = 0x00000004,
|
|
UNWIND_ARM64_FRAME_X25_X26_PAIR = 0x00000008,
|
|
UNWIND_ARM64_FRAME_X27_X28_PAIR = 0x00000010,
|
|
UNWIND_ARM64_FRAME_D8_D9_PAIR = 0x00000100,
|
|
UNWIND_ARM64_FRAME_D10_D11_PAIR = 0x00000200,
|
|
UNWIND_ARM64_FRAME_D12_D13_PAIR = 0x00000400,
|
|
UNWIND_ARM64_FRAME_D14_D15_PAIR = 0x00000800,
|
|
|
|
UNWIND_ARM64_FRAMELESS_STACK_SIZE_MASK = 0x00FFF000,
|
|
UNWIND_ARM64_DWARF_SECTION_OFFSET = 0x00FFFFFF,
|
|
};
|
|
// For arm64 there are three modes for the compact unwind encoding:
|
|
// UNWIND_ARM64_MODE_FRAME:
|
|
// This is a standard arm64 prolog where FP/LR are immediately pushed on the
|
|
// stack, then SP is copied to FP. If there are any non-volatile registers
|
|
// saved, then are copied into the stack frame in pairs in a contiguous
|
|
// range right below the saved FP/LR pair. Any subset of the five X pairs
|
|
// and four D pairs can be saved, but the memory layout must be in register
|
|
// number order.
|
|
// UNWIND_ARM64_MODE_FRAMELESS:
|
|
// A "frameless" leaf function, where FP/LR are not saved. The return address
|
|
// remains in LR throughout the function. If any non-volatile registers
|
|
// are saved, they must be pushed onto the stack before any stack space is
|
|
// allocated for local variables. The stack sized (including any saved
|
|
// non-volatile registers) divided by 16 is encoded in the bits
|
|
// UNWIND_ARM64_FRAMELESS_STACK_SIZE_MASK.
|
|
// UNWIND_ARM64_MODE_DWARF:
|
|
// No compact unwind encoding is available. Instead the low 24-bits of the
|
|
// compact encoding is the offset of the DWARF FDE in the __eh_frame section.
|
|
// This mode is never used in object files. It is only generated by the
|
|
// linker in final linked images which have only DWARF unwind info for a
|
|
// function.
|
|
//
|
|
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Relocatable Object Files: __LD,__compact_unwind
|
|
//
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
// A compiler can generated compact unwind information for a function by adding
|
|
// a "row" to the __LD,__compact_unwind section. This section has the
|
|
// S_ATTR_DEBUG bit set, so the section will be ignored by older linkers.
|
|
// It is removed by the new linker, so never ends up in final executables.
|
|
// This section is a table, initially with one row per function (that needs
|
|
// unwind info). The table columns and some conceptual entries are:
|
|
//
|
|
// range-start pointer to start of function/range
|
|
// range-length
|
|
// compact-unwind-encoding 32-bit encoding
|
|
// personality-function or zero if no personality function
|
|
// lsda or zero if no LSDA data
|
|
//
|
|
// The length and encoding fields are 32-bits. The other are all pointer sized.
|
|
//
|
|
// In x86_64 assembly, these entry would look like:
|
|
//
|
|
// .section __LD,__compact_unwind,regular,debug
|
|
//
|
|
// #compact unwind for _foo
|
|
// .quad _foo
|
|
// .set L1,LfooEnd-_foo
|
|
// .long L1
|
|
// .long 0x01010001
|
|
// .quad 0
|
|
// .quad 0
|
|
//
|
|
// #compact unwind for _bar
|
|
// .quad _bar
|
|
// .set L2,LbarEnd-_bar
|
|
// .long L2
|
|
// .long 0x01020011
|
|
// .quad __gxx_personality
|
|
// .quad except_tab1
|
|
//
|
|
//
|
|
// Notes: There is no need for any labels in the __compact_unwind section.
|
|
// The use of the .set directive is to force the evaluation of the
|
|
// range-length at assembly time, instead of generating relocations.
|
|
//
|
|
// To support future compiler optimizations where which non-volatile registers
|
|
// are saved changes within a function (e.g. delay saving non-volatiles until
|
|
// necessary), there can by multiple lines in the __compact_unwind table for one
|
|
// function, each with a different (non-overlapping) range and each with
|
|
// different compact unwind encodings that correspond to the non-volatiles
|
|
// saved at that range of the function.
|
|
//
|
|
// If a particular function is so wacky that there is no compact unwind way
|
|
// to encode it, then the compiler can emit traditional DWARF unwind info.
|
|
// The runtime will use which ever is available.
|
|
//
|
|
// Runtime support for compact unwind encodings are only available on 10.6
|
|
// and later. So, the compiler should not generate it when targeting pre-10.6.
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Final Linked Images: __TEXT,__unwind_info
|
|
//
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
// The __TEXT,__unwind_info section is laid out for an efficient two level lookup.
|
|
// The header of the section contains a coarse index that maps function address
|
|
// to the page (4096 byte block) containing the unwind info for that function.
|
|
//
|
|
|
|
#define UNWIND_SECTION_VERSION 1
|
|
struct unwind_info_section_header
|
|
{
|
|
uint32_t version; // UNWIND_SECTION_VERSION
|
|
uint32_t commonEncodingsArraySectionOffset;
|
|
uint32_t commonEncodingsArrayCount;
|
|
uint32_t personalityArraySectionOffset;
|
|
uint32_t personalityArrayCount;
|
|
uint32_t indexSectionOffset;
|
|
uint32_t indexCount;
|
|
// compact_unwind_encoding_t[]
|
|
// uint32_t personalities[]
|
|
// unwind_info_section_header_index_entry[]
|
|
// unwind_info_section_header_lsda_index_entry[]
|
|
};
|
|
|
|
struct unwind_info_section_header_index_entry
|
|
{
|
|
uint32_t functionOffset;
|
|
uint32_t secondLevelPagesSectionOffset; // section offset to start of regular or compress page
|
|
uint32_t lsdaIndexArraySectionOffset; // section offset to start of lsda_index array for this range
|
|
};
|
|
|
|
struct unwind_info_section_header_lsda_index_entry
|
|
{
|
|
uint32_t functionOffset;
|
|
uint32_t lsdaOffset;
|
|
};
|
|
|
|
//
|
|
// There are two kinds of second level index pages: regular and compressed.
|
|
// A compressed page can hold up to 1021 entries, but it cannot be used
|
|
// if too many different encoding types are used. The regular page holds
|
|
// 511 entries.
|
|
//
|
|
|
|
struct unwind_info_regular_second_level_entry
|
|
{
|
|
uint32_t functionOffset;
|
|
compact_unwind_encoding_t encoding;
|
|
};
|
|
|
|
#define UNWIND_SECOND_LEVEL_REGULAR 2
|
|
struct unwind_info_regular_second_level_page_header
|
|
{
|
|
uint32_t kind; // UNWIND_SECOND_LEVEL_REGULAR
|
|
uint16_t entryPageOffset;
|
|
uint16_t entryCount;
|
|
// entry array
|
|
};
|
|
|
|
#define UNWIND_SECOND_LEVEL_COMPRESSED 3
|
|
struct unwind_info_compressed_second_level_page_header
|
|
{
|
|
uint32_t kind; // UNWIND_SECOND_LEVEL_COMPRESSED
|
|
uint16_t entryPageOffset;
|
|
uint16_t entryCount;
|
|
uint16_t encodingsPageOffset;
|
|
uint16_t encodingsCount;
|
|
// 32-bit entry array
|
|
// encodings array
|
|
};
|
|
|
|
#define UNWIND_INFO_COMPRESSED_ENTRY_FUNC_OFFSET(entry) (entry & 0x00FFFFFF)
|
|
#define UNWIND_INFO_COMPRESSED_ENTRY_ENCODING_INDEX(entry) ((entry >> 24) & 0xFF)
|
|
|
|
|
|
|
|
#endif
|
|
|