| From 43dfe54ce017c8d37eaec480a2f13a492bbc4203 Mon Sep 17 00:00:00 2001 |
| From: serge-sans-paille <sguelton@redhat.com> |
| Date: Thu, 25 Feb 2021 14:24:14 +0100 |
| Subject: [PATCH 2/2] [PATCH][lld] Import compact_unwind_encoding.h from |
| libunwind |
| |
| This avoids an implicit cross package dependency |
| |
| lld/include/mach-o/compact_unwind_encoding.h | 477 +++++++++++++++++++++++++++ |
| 1 file changed, 477 insertions(+) |
| create mode 100644 lld/include/mach-o/compact_unwind_encoding.h |
| |
| diff --git a/lld/include/mach-o/compact_unwind_encoding.h b/lld/include/mach-o/compact_unwind_encoding.h |
| new file mode 100644 |
| index 0000000..5301b10 |
| |
| |
| @@ -0,0 +1,477 @@ |
| +//===------------------ mach-o/compact_unwind_encoding.h ------------------===// |
| +// |
| +// 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 endoding 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 constains 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 constains 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 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 |
| + |
| -- |
| 1.8.3.1 |
| |