This is an archive of the discontinued LLVM Phabricator instance.

Differential D70949

[DWARFDebugLoclists] Add support for other DW_LLE encodings
ClosedPublic

Authored by labath on Dec 3 2019, 2:57 AM.

Details

Reviewers
dblaikie
JDevlieghere
aprantl
SouraVX
Commits
rGa3af3ac39301: [DWARFDebugLoclists] Add support for other DW_LLE encodings
Summary

lldb's loclists parser has support for DW_LLE_start_end(x) encodings. To
avoid regressing when switching the implementation to llvm's, I add
parsing support for all previously unsupported location list encodings.

Diff Detail

Event Timeline

labath created this revision.Dec 3 2019, 2:57 AM
Herald added a project: Restricted Project. · View Herald TranscriptDec 3 2019, 2:57 AM
Herald added a subscriber: hiraditya. · View Herald Transcript
Harbormaster completed remote builds in B41777: Diff 231856.Dec 3 2019, 2:59 AM
dblaikie accepted this revision.Dec 3 2019, 6:39 AM

Looks good!

This revision is now accepted and ready to land.Dec 3 2019, 6:39 AM
Closed by commit rGa3af3ac39301: [DWARFDebugLoclists] Add support for other DW_LLE encodings (authored by labath). · Explain WhyDec 4 2019, 1:40 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
llvm/
lib/
DebugInfo/
DWARF/
46 lines
test/
tools/
llvm-dwarfdump/
X86/
113 lines

Diff 232055

llvm/lib/DebugInfo/DWARF/DWARFDebugLoc.cpp

Show First 20 Lines • Show All 51 Lines • ▼ Show 20 LinesDWARFLocationInterpreter::Interpret(const DWARFLocationEntry &E) {
case dwarf::DW_LLE_end_of_list: case dwarf::DW_LLE_end_of_list:
return None; return None;
case dwarf::DW_LLE_base_addressx: { case dwarf::DW_LLE_base_addressx: {
Base = LookupAddr(E.Value0); Base = LookupAddr(E.Value0);
if (!Base) if (!Base)
return createResolverError(E.Value0, E.Kind); return createResolverError(E.Value0, E.Kind);
return None; return None;
} }
case dwarf::DW_LLE_startx_endx: {
Optional<SectionedAddress> LowPC = LookupAddr(E.Value0);
if (!LowPC)
return createResolverError(E.Value0, E.Kind);
Optional<SectionedAddress> HighPC = LookupAddr(E.Value1);
if (!HighPC)
return createResolverError(E.Value1, E.Kind);
return DWARFLocationExpression{
DWARFAddressRange{LowPC->Address, HighPC->Address, LowPC->SectionIndex},
E.Loc};
}
case dwarf::DW_LLE_startx_length: { case dwarf::DW_LLE_startx_length: {
Optional<SectionedAddress> LowPC = LookupAddr(E.Value0); Optional<SectionedAddress> LowPC = LookupAddr(E.Value0);
if (!LowPC) if (!LowPC)
return createResolverError(E.Value0, E.Kind); return createResolverError(E.Value0, E.Kind);
return DWARFLocationExpression{DWARFAddressRange{LowPC->Address, return DWARFLocationExpression{DWARFAddressRange{LowPC->Address,
LowPC->Address + E.Value1, LowPC->Address + E.Value1,
LowPC->SectionIndex}, LowPC->SectionIndex},
E.Loc}; E.Loc};
} }
case dwarf::DW_LLE_offset_pair: { case dwarf::DW_LLE_offset_pair: {
if (!Base) { if (!Base) {
return createStringError( return createStringError(
inconvertibleErrorCode(), inconvertibleErrorCode(),
"Unable to resolve DW_LLE_offset_pair: base address unknown"); "Unable to resolve DW_LLE_offset_pair: base address unknown");
} }
DWARFAddressRange Range{Base->Address + E.Value0, Base->Address + E.Value1, DWARFAddressRange Range{Base->Address + E.Value0, Base->Address + E.Value1,
Base->SectionIndex}; Base->SectionIndex};
if (Range.SectionIndex == SectionedAddress::UndefSection) if (Range.SectionIndex == SectionedAddress::UndefSection)
Range.SectionIndex = E.SectionIndex; Range.SectionIndex = E.SectionIndex;
return DWARFLocationExpression{Range, E.Loc}; return DWARFLocationExpression{Range, E.Loc};
} }
case dwarf::DW_LLE_default_location:
return DWARFLocationExpression{None, E.Loc};
case dwarf::DW_LLE_base_address: case dwarf::DW_LLE_base_address:
Base = SectionedAddress{E.Value0, E.SectionIndex}; Base = SectionedAddress{E.Value0, E.SectionIndex};
return None; return None;
case dwarf::DW_LLE_start_end:
return DWARFLocationExpression{
DWARFAddressRange{E.Value0, E.Value1, E.SectionIndex}, E.Loc};
case dwarf::DW_LLE_start_length: case dwarf::DW_LLE_start_length:
return DWARFLocationExpression{ return DWARFLocationExpression{
DWARFAddressRange{E.Value0, E.Value0 + E.Value1, E.SectionIndex}, DWARFAddressRange{E.Value0, E.Value0 + E.Value1, E.SectionIndex},
E.Loc}; E.Loc};
default: default:
llvm_unreachable("unreachable locations list kind"); llvm_unreachable("unreachable locations list kind");
} }
} }
Show All 30 Lines Error E = visitLocationList(Offset, [&](const DWARFLocationEntry &E) {
if (Loc && *Loc) { if (Loc && *Loc) {
OS << "\n"; OS << "\n";
OS.indent(Indent); OS.indent(Indent);
if (DumpOpts.DisplayRawContents) if (DumpOpts.DisplayRawContents)
OS << " => "; OS << " => ";
DIDumpOptions RangeDumpOpts(DumpOpts); DIDumpOptions RangeDumpOpts(DumpOpts);
RangeDumpOpts.DisplayRawContents = false; RangeDumpOpts.DisplayRawContents = false;
if (Loc.get()->Range)
Loc.get()->Range->dump(OS, Data.getAddressSize(), RangeDumpOpts, &Obj); Loc.get()->Range->dump(OS, Data.getAddressSize(), RangeDumpOpts, &Obj);
else
OS << "<default>";
} }
if (!Loc) if (!Loc)
consumeError(Loc.takeError()); consumeError(Loc.takeError());
if (E.Kind != dwarf::DW_LLE_base_address && if (E.Kind != dwarf::DW_LLE_base_address &&
E.Kind != dwarf::DW_LLE_base_addressx && E.Kind != dwarf::DW_LLE_base_addressx &&
E.Kind != dwarf::DW_LLE_end_of_list) { E.Kind != dwarf::DW_LLE_end_of_list) {
OS << ": "; OS << ": ";
▲ Show 20 Lines • Show All 125 Lines • ▼ Show 20 Lines while (Continue) {
DWARFLocationEntry E; DWARFLocationEntry E;
E.Kind = Data.getU8(C); E.Kind = Data.getU8(C);
switch (E.Kind) { switch (E.Kind) {
case dwarf::DW_LLE_end_of_list: case dwarf::DW_LLE_end_of_list:
break; break;
case dwarf::DW_LLE_base_addressx: case dwarf::DW_LLE_base_addressx:
E.Value0 = Data.getULEB128(C); E.Value0 = Data.getULEB128(C);
break; break;
case dwarf::DW_LLE_startx_endx:
E.Value0 = Data.getULEB128(C);
E.Value1 = Data.getULEB128(C);
break;
case dwarf::DW_LLE_startx_length: case dwarf::DW_LLE_startx_length:
E.Value0 = Data.getULEB128(C); E.Value0 = Data.getULEB128(C);
// Pre-DWARF 5 has different interpretation of the length field. We have // Pre-DWARF 5 has different interpretation of the length field. We have
// to support both pre- and standartized styles for the compatibility. // to support both pre- and standartized styles for the compatibility.
if (Version < 5) if (Version < 5)
E.Value1 = Data.getU32(C); E.Value1 = Data.getU32(C);
else else
E.Value1 = Data.getULEB128(C); E.Value1 = Data.getULEB128(C);
break; break;
case dwarf::DW_LLE_offset_pair: case dwarf::DW_LLE_offset_pair:
E.Value0 = Data.getULEB128(C); E.Value0 = Data.getULEB128(C);
E.Value1 = Data.getULEB128(C); E.Value1 = Data.getULEB128(C);
E.SectionIndex = SectionedAddress::UndefSection; E.SectionIndex = SectionedAddress::UndefSection;
break; break;
case dwarf::DW_LLE_default_location:
break;
case dwarf::DW_LLE_base_address: case dwarf::DW_LLE_base_address:
E.Value0 = Data.getRelocatedAddress(C, &E.SectionIndex); E.Value0 = Data.getRelocatedAddress(C, &E.SectionIndex);
break; break;
case dwarf::DW_LLE_start_end:
E.Value0 = Data.getRelocatedAddress(C, &E.SectionIndex);
E.Value1 = Data.getRelocatedAddress(C);
break;
case dwarf::DW_LLE_start_length: case dwarf::DW_LLE_start_length:
E.Value0 = Data.getRelocatedAddress(C, &E.SectionIndex); E.Value0 = Data.getRelocatedAddress(C, &E.SectionIndex);
E.Value1 = Data.getULEB128(C); E.Value1 = Data.getULEB128(C);
break; break;
case dwarf::DW_LLE_startx_endx:
case dwarf::DW_LLE_default_location:
case dwarf::DW_LLE_start_end:
default: default:
cantFail(C.takeError()); cantFail(C.takeError());
return createStringError(errc::illegal_byte_sequence, return createStringError(errc::illegal_byte_sequence,
"LLE of kind %x not supported", (int)E.Kind); "LLE of kind %x not supported", (int)E.Kind);
} }
if (E.Kind != dwarf::DW_LLE_base_address && if (E.Kind != dwarf::DW_LLE_base_address &&
E.Kind != dwarf::DW_LLE_base_addressx && E.Kind != dwarf::DW_LLE_base_addressx &&
Show All 24 Lines#include "llvm/BinaryFormat/Dwarf.def"
OS << "\n"; OS << "\n";
OS.indent(Indent); OS.indent(Indent);
StringRef EncodingString = dwarf::LocListEncodingString(Entry.Kind); StringRef EncodingString = dwarf::LocListEncodingString(Entry.Kind);
// Unsupported encodings should have been reported during parsing. // Unsupported encodings should have been reported during parsing.
assert(!EncodingString.empty() && "Unknown loclist entry encoding"); assert(!EncodingString.empty() && "Unknown loclist entry encoding");
OS << format("%-*s(", MaxEncodingStringLength, EncodingString.data()); OS << format("%-*s(", MaxEncodingStringLength, EncodingString.data());
unsigned FieldSize = 2 + 2 * Data.getAddressSize(); unsigned FieldSize = 2 + 2 * Data.getAddressSize();
switch (Entry.Kind) { switch (Entry.Kind) {
case dwarf::DW_LLE_end_of_list:
case dwarf::DW_LLE_default_location:
break;
case dwarf::DW_LLE_startx_endx:
case dwarf::DW_LLE_startx_length: case dwarf::DW_LLE_startx_length:
case dwarf::DW_LLE_start_length:
case dwarf::DW_LLE_offset_pair: case dwarf::DW_LLE_offset_pair:
case dwarf::DW_LLE_start_end:
case dwarf::DW_LLE_start_length:
OS << format_hex(Entry.Value0, FieldSize) << ", " OS << format_hex(Entry.Value0, FieldSize) << ", "
<< format_hex(Entry.Value1, FieldSize); << format_hex(Entry.Value1, FieldSize);
break; break;
case dwarf::DW_LLE_base_addressx: case dwarf::DW_LLE_base_addressx:
case dwarf::DW_LLE_base_address: case dwarf::DW_LLE_base_address:
OS << format_hex(Entry.Value0, FieldSize); OS << format_hex(Entry.Value0, FieldSize);
break; break;
case dwarf::DW_LLE_end_of_list:
break;
} }
OS << ')'; OS << ')';
switch (Entry.Kind) { switch (Entry.Kind) {
case dwarf::DW_LLE_start_length:
case dwarf::DW_LLE_base_address: case dwarf::DW_LLE_base_address:
case dwarf::DW_LLE_start_end:
case dwarf::DW_LLE_start_length:
DWARFFormValue::dumpAddressSection(Obj, OS, DumpOpts, Entry.SectionIndex); DWARFFormValue::dumpAddressSection(Obj, OS, DumpOpts, Entry.SectionIndex);
break; break;
default: default:
break; break;
} }
} }
void DWARFDebugLoclists::dumpRange(uint64_t StartOffset, uint64_t Size, void DWARFDebugLoclists::dumpRange(uint64_t StartOffset, uint64_t Size,
Show All 19 Lines

llvm/test/tools/llvm-dwarfdump/X86/debug_loclists.s

Show All 10 Lines
# VERBOSE-NEXT: [0x0000000000000000, 0x0000000000000001) ".text": DW_OP_reg0 RAX # VERBOSE-NEXT: [0x0000000000000000, 0x0000000000000001) ".text": DW_OP_reg0 RAX
# REGULAR-NEXT: [0x0000000000000001, 0x0000000000000002): DW_OP_reg1 RDX # REGULAR-NEXT: [0x0000000000000001, 0x0000000000000002): DW_OP_reg1 RDX
# VERBOSE-NEXT: [0x0000000000000001, 0x0000000000000002) ".text": DW_OP_reg1 RDX # VERBOSE-NEXT: [0x0000000000000001, 0x0000000000000002) ".text": DW_OP_reg1 RDX
# REGULAR-NEXT: [0x0000000000000002, 0x0000000000000003): DW_OP_reg2 RCX # REGULAR-NEXT: [0x0000000000000002, 0x0000000000000003): DW_OP_reg2 RCX
# VERBOSE-NEXT: [0x0000000000000002, 0x0000000000000003) ".text": DW_OP_reg2 RCX # VERBOSE-NEXT: [0x0000000000000002, 0x0000000000000003) ".text": DW_OP_reg2 RCX
# REGULAR-NEXT: [0x0000000000000003, 0x0000000000000004): DW_OP_reg3 RBX # BOTH-NEXT: <default>: DW_OP_reg3 RBX
# VERBOSE-NEXT: [0x0000000000000003, 0x0000000000000004) ".text": DW_OP_reg3 RBX
# REGULAR-NEXT: [0x0000000000000004, 0x0000000000000005): DW_OP_reg4 RSI
# VERBOSE-NEXT: [0x0000000000000004, 0x0000000000000005) ".text": DW_OP_reg4 RSI
# REGULAR-NEXT: [0x0000000000000005, 0x0000000000000006): DW_OP_reg5 RDI
# VERBOSE-NEXT: [0x0000000000000005, 0x0000000000000006) ".text": DW_OP_reg5 RDI
# REGULAR-NEXT: [0x0000000000000006, 0x0000000000000007): DW_OP_reg6 RBP
# VERBOSE-NEXT: [0x0000000000000006, 0x0000000000000007) ".text": DW_OP_reg6 RBP
# REGULAR-NEXT: [0x0000000000000007, 0x0000000000000008): DW_OP_reg7 RSP
# VERBOSE-NEXT: [0x0000000000000007, 0x0000000000000008) ".text": DW_OP_reg7 RSP
# BOTH-NEXT: DW_LLE_startx_length (0x000000000000dead, 0x0000000000000001): DW_OP_reg4 RSI) # BOTH-NEXT: DW_LLE_startx_length (0x000000000000dead, 0x0000000000000001): DW_OP_reg4 RSI)
# BOTH: locations list header: length = 0x00000034, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000 # BOTH: locations list header: length = 0x00000056, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
# BOTH-NEXT: 0x0000000c: # BOTH-NEXT: 0x0000000c:
# BOTH-NEXT: DW_LLE_startx_length (0x0000000000000000, 0x0000000000000001): DW_OP_reg0 RAX # BOTH-NEXT: DW_LLE_startx_endx (0x0000000000000000, 0x0000000000000001): DW_OP_reg0 RAX
# BOTH-NEXT: DW_LLE_offset_pair (0x0000000000000001, 0x0000000000000002): DW_OP_reg1 RDX # BOTH-NEXT: DW_LLE_startx_length (0x0000000000000001, 0x0000000000000001): DW_OP_reg1 RDX
# BOTH-NEXT: DW_LLE_offset_pair (0x0000000000000002, 0x0000000000000003): DW_OP_reg2 RCX
# REGULAR-NEXT: [0x0000000000000002, 0x0000000000000003): DW_OP_reg2 RCX # REGULAR-NEXT: <default>: DW_OP_reg3 RBX
# VERBOSE-NEXT: DW_LLE_start_length (0x0000000000000002, 0x0000000000000001) ".text" # VERBOSE-NEXT: DW_LLE_default_location()
# VERBOSE-NEXT: => [0x0000000000000002, 0x0000000000000003) ".text": DW_OP_reg2 RCX # VERBOSE-NEXT: => <default>: DW_OP_reg3 RBX
# VERBOSE-NEXT: DW_LLE_base_address (0x0000000000000003) ".text" # REGULAR-NEXT: [0x0000000000000004, 0x0000000000000005): DW_OP_reg4 RSI
# VERBOSE-NEXT: DW_LLE_start_end (0x0000000000000004, 0x0000000000000005) ".text"
# VERBOSE-NEXT: => [0x0000000000000004, 0x0000000000000005) ".text": DW_OP_reg4 RSI
# REGULAR-NEXT: [0x0000000000000003, 0x0000000000000004): DW_OP_reg3 RBX # REGULAR-NEXT: [0x0000000000000005, 0x0000000000000006): DW_OP_reg5 RDI
# VERBOSE-NEXT: DW_LLE_start_length (0x0000000000000005, 0x0000000000000001) ".text"
# VERBOSE-NEXT: => [0x0000000000000005, 0x0000000000000006) ".text": DW_OP_reg5 RDI
# BOTH-NEXT: DW_LLE_base_addressx (0x0000000000000002)
# BOTH-NEXT: DW_LLE_offset_pair (0x0000000000000000, 0x0000000000000001): DW_OP_reg6 RBP
# VERBOSE-NEXT: DW_LLE_base_address (0x0000000000000007) ".text"
# REGULAR-NEXT: [0x0000000000000007, 0x0000000000000008): DW_OP_reg7 RSP
# VERBOSE-NEXT: DW_LLE_offset_pair (0x0000000000000000, 0x0000000000000001) # VERBOSE-NEXT: DW_LLE_offset_pair (0x0000000000000000, 0x0000000000000001)
# VERBOSE-NEXT: => [0x0000000000000003, 0x0000000000000004) ".text": DW_OP_reg3 RBX # VERBOSE-NEXT: => [0x0000000000000007, 0x0000000000000008) ".text": DW_OP_reg7 RSP
# BOTH-NEXT: DW_LLE_startx_length (0x000000000000dead, 0x0000000000000001): DW_OP_reg4 RSI # BOTH-NEXT: DW_LLE_startx_length (0x000000000000dead, 0x0000000000000001): DW_OP_reg4 RSI
# VERBOSE-NEXT: DW_LLE_end_of_list () # VERBOSE-NEXT: DW_LLE_end_of_list ()
.text .text
f: # @f f: # @f
.Lf0: .Lf0:
nop nop
.Lf1: .Lf1:
nop nop
.Lf2: .Lf2:
nop nop
.Lf3: .Lf3:
nop nop
.Lf4: .Lf4:
nop
.Lf5:
nop
.Lf6:
nop
.Lf7:
nop
.Lf8:
.Lfend: .Lfend:
# -- End function # -- End function
.section .debug_loclists,"",@progbits .section .debug_loclists,"",@progbits
.long .Ldebug_loclist_table_end0-.Ldebug_loclist_table_start0 # Length .long .Ldebug_loclist_table_end0-.Ldebug_loclist_table_start0 # Length
.Ldebug_loclist_table_start0: .Ldebug_loclist_table_start0:
.short 5 # Version .short 5 # Version
.byte 8 # Address size .byte 8 # Address size
.byte 0 # Segment selector size .byte 0 # Segment selector size
.long 0 # Offset entry count .long 0 # Offset entry count
.Lloclists_table_base0: .Lloclists_table_base0:
.Ldebug_loc0: .Ldebug_loc0:
.byte 3 # DW_LLE_startx_length .byte 2 # DW_LLE_startx_endx
.uleb128 0 # start idx .uleb128 0 # start idx
.uleb128 .Lf1-.Lf0 # length .uleb128 1 # end idx
.byte 1 # Loc expr size .byte 1 # Loc expr size
.byte 80 # super-register DW_OP_reg0 .byte 80 # super-register DW_OP_reg0
.byte 4 # DW_LLE_offset_pair
.uleb128 .Lf1-.Lf0 # starting offset .byte 3 # DW_LLE_startx_length
.uleb128 .Lf2-.Lf0 # ending offset .uleb128 1 # start idx
.uleb128 .Lf2-.Lf1 # length
.byte 1 # Loc expr size .byte 1 # Loc expr size
.byte 81 # super-register DW_OP_reg1 .byte 81 # super-register DW_OP_reg1
.byte 8 # DW_LLE_start_length
.quad .Lf2 # starting offset .byte 4 # DW_LLE_offset_pair
.uleb128 .Lf3-.Lf2 # length .uleb128 .Lf2-.Lf0 # starting offset
.uleb128 .Lf3-.Lf0 # ending offset
.byte 1 # Loc expr size .byte 1 # Loc expr size
.byte 82 # super-register DW_OP_reg2 .byte 82 # super-register DW_OP_reg2
.byte 5 # DW_LLE_default_location
.byte 1 # Loc expr size
.byte 83 # super-register DW_OP_reg3
.byte 7 # DW_LLE_start_end
.quad .Lf4 # starting offset
.quad .Lf5 # ending offset
.byte 1 # Loc expr size
.byte 84 # super-register DW_OP_reg4
.byte 8 # DW_LLE_start_length
.quad .Lf5 # starting offset
.uleb128 .Lf6-.Lf5 # length
.byte 1 # Loc expr size
.byte 85 # super-register DW_OP_reg5
.byte 1 # DW_LLE_base_addressx
.uleb128 2 # base address
.byte 4 # DW_LLE_offset_pair
.uleb128 .Lf6-.Lf6 # starting offset
.uleb128 .Lf7-.Lf6 # ending offset
.byte 1 # Loc expr size
.byte 86 # super-register DW_OP_reg6
.byte 6 # DW_LLE_base_address .byte 6 # DW_LLE_base_address
.quad .Lf3 # base address .quad .Lf7 # base address
.byte 4 # DW_LLE_offset_pair .byte 4 # DW_LLE_offset_pair
.uleb128 .Lf3-.Lf3 # starting offset .uleb128 .Lf7-.Lf7 # starting offset
.uleb128 .Lf4-.Lf3 # ending offset .uleb128 .Lf8-.Lf7 # ending offset
.byte 1 # Loc expr size .byte 1 # Loc expr size
.byte 83 # super-register DW_OP_reg3 .byte 87 # super-register DW_OP_reg7
.byte 3 # DW_LLE_startx_length .byte 3 # DW_LLE_startx_length
.uleb128 0xdead # start idx .uleb128 0xdead # start idx
.uleb128 .Lf1-.Lf0 # length .uleb128 .Lf1-.Lf0 # length
.byte 1 # Loc expr size .byte 1 # Loc expr size
.byte 84 # super-register DW_OP_reg4 .byte 84 # super-register DW_OP_reg4
.byte 0 # DW_LLE_end_of_list .byte 0 # DW_LLE_end_of_list
.Ldebug_loclist_table_end0: .Ldebug_loclist_table_end0:
.section .debug_abbrev,"",@progbits .section .debug_abbrev,"",@progbits
.byte 1 # Abbreviation Code .byte 1 # Abbreviation Code
.byte 17 # DW_TAG_compile_unit .byte 17 # DW_TAG_compile_unit
.byte 1 # DW_CHILDREN_yes .byte 1 # DW_CHILDREN_yes
.byte 115 # DW_AT_addr_base .byte 115 # DW_AT_addr_base
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Lines.Ldebug_info_end0:
.section .debug_addr,"",@progbits .section .debug_addr,"",@progbits
.long .Ldebug_addr_end0-.Ldebug_addr_start0 # Length of contribution .long .Ldebug_addr_end0-.Ldebug_addr_start0 # Length of contribution
.Ldebug_addr_start0: .Ldebug_addr_start0:
.short 5 # DWARF version number .short 5 # DWARF version number
.byte 8 # Address size .byte 8 # Address size
.byte 0 # Segment selector size .byte 0 # Segment selector size
.Laddr_table_base0: .Laddr_table_base0:
.quad .Lf0 .quad .Lf0
.quad .Lf1
.quad .Lf6
.Ldebug_addr_end0: .Ldebug_addr_end0: