[vm/aot] Delay relocated address calculation for static symbols.

Since we no longer add the symbol for a given code object to the Elf
object when writing the contents of the text segment, we don't need to
calculate the relocated address that early. Instead, just store which
text segment the instructions payload belongs to as well as its offset
into the segment contents and let Elf::Finalize() calculate the
relocated address when creating the symbol.

This removes one need for knowing the segment base address when writing
the segment contents. The remaining needs are related to BSS usage:

* Calculating the BSS offset from the text segment for the Image header.
* Fixing up BSS relocations in instructions payloads.

Cq-Include-Trybots: luci.dart.try:vm-kernel-precomp-linux-release-x64-try,vm-kernel-precomp-linux-product-x64-try,vm-kernel-precomp-linux-debug-x64-try,vm-kernel-precomp-linux-release-simarm_x64-try
Change-Id: I8be860a7a7111721e6f546154a0814f4d16ac634
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/150929
Commit-Queue: Tess Strickland <[email protected]>
Reviewed-by: Clement Skau <[email protected]>

Author: sstrickl

runtime/vm/dwarf.cc

@@ -101,36 +101,53 @@ Dwarf::Dwarf(Zone* zone)
       script_to_index_(zone),
       temp_(0) {}
 
-intptr_t Dwarf::AddCode(const Code& non_zone_code, intptr_t relocated_address) {
-  ASSERT(!non_zone_code.IsNull());
-  ASSERT(relocated_address == kNoCodeAddress || relocated_address > 0);
-  const auto& code = Code::ZoneHandle(zone_, non_zone_code.raw());
+SegmentRelativeOffset Dwarf::CodeAddress(const Code& code) const {
+  const auto& pair = code_to_address_.LookupValue(&code);
+  // This is only used by Elf::Finalize(), and the image writers always give a
+  // text offset when calling AddCode() for an Elf object's Dwarf object. Thus,
+  // we should have known code offsets for each code object in the map.
+  ASSERT(pair.offset != SegmentRelativeOffset::kUnknownOffset);
+  return pair;
+}
+
+intptr_t Dwarf::AddCode(const Code& orig_code,
+                        const SegmentRelativeOffset& offset) {
+  ASSERT(!orig_code.IsNull());
+  // We should never get the no-argument constructed version here.
+  ASSERT(offset.offset != SegmentRelativeOffset::kInvalidOffset);
+  // Generate an appropriately zoned ZoneHandle for storing.
+  const auto& code = Code::ZoneHandle(zone_, orig_code.raw());
 
   // For now, we assume one of two flows for a given code object:
-  // ELF: Calls to AddCode(code, address), address is the same over all calls.
-  // Assembly: An initial call to AddCode(code) (assembly), possibly
-  //     followed by a later call to AddCode(code, address)
+  // ELF: Calls to AddCode(code, vm, offset), vm and offset are the same over
+  //      all calls.
+  // Assembly: An initial call to AddCode(code, vm) (assembly), possibly
+  //     followed by a later call to AddCode(code, vm, offset)
   //     (separate debugging info ELF)
-  if (relocated_address == kNoCodeAddress) {
+  if (offset.offset == SegmentRelativeOffset::kUnknownOffset) {
     // A call without an address should always come before any calls with
     // addresses.
     ASSERT(code_to_address_.Lookup(&code) == nullptr);
     // Insert a marker so on later calls, we know we've already added to codes_.
-    code_to_address_.Insert(CodeAddressPair(&code, kNoCodeAddress));
+    code_to_address_.Insert(CodeAddressPair(&code, offset));
   } else {
-    auto const old_value = code_to_address_.LookupValue(&code);
+    const auto& old_value = code_to_address_.LookupValue(&code);
     // ELF does not need to know the index. If we've already added this Code
     // object to codes_ in a previous call, don't bother scanning codes_ to find
     // the corresponding index, just return -1 instead.
-    switch (old_value) {
-      case CodeAddressPair::kNoValue:
-        code_to_address_.Insert(CodeAddressPair(&code, relocated_address));
+    switch (old_value.offset) {
+      case SegmentRelativeOffset::kInvalidOffset:
+        code_to_address_.Insert(CodeAddressPair(&code, offset));
         break;  // Still need to add to codes_.
-      case kNoCodeAddress:
-        code_to_address_.Update(CodeAddressPair(&code, relocated_address));
+      case SegmentRelativeOffset::kUnknownOffset:
+        // Code objects should only be associated with either the VM or isolate.
+        ASSERT_EQUAL(old_value.vm, offset.vm);
+        code_to_address_.Update(CodeAddressPair(&code, offset));
         return -1;
       default:
-        ASSERT_EQUAL(old_value, relocated_address);
+        // The information for the code object shouldn't have changed since the
+        // previous update.
+        ASSERT(old_value == offset);
         return -1;
     }
   }

runtime/vm/dwarf.h

@@ -82,41 +82,61 @@ struct FunctionIndexPair {
 
 typedef DirectChainedHashMap<FunctionIndexPair> FunctionIndexMap;
 
+struct SegmentRelativeOffset {
+  // Used for the empty constructor (for hash map usage).
+  static constexpr intptr_t kInvalidOffset = -2;
+  // Used for cases where we know which segment, but don't know the offset.
+  static constexpr intptr_t kUnknownOffset = -1;
+
+  SegmentRelativeOffset(bool vm, intptr_t offset) : vm(vm), offset(offset) {
+    ASSERT(offset >= 0);
+  }
+  explicit SegmentRelativeOffset(bool vm) : vm(vm), offset(kUnknownOffset) {}
+  SegmentRelativeOffset() : vm(false), offset(kInvalidOffset) {}
+
+  bool operator==(const SegmentRelativeOffset& b) const {
+    return vm == b.vm && offset == b.offset;
+  }
+  bool operator==(const SegmentRelativeOffset& b) {
+    return *const_cast<const SegmentRelativeOffset*>(this) == b;
+  }
+  bool operator!=(const SegmentRelativeOffset& b) { return !(*this == b); }
+
+  // Whether or not this is an offset into the VM text segment.
+  bool vm;
+  // The byte offset into the segment contents.
+  intptr_t offset;
+};
+
 struct CodeAddressPair {
   // Typedefs needed for the DirectChainedHashMap template.
   typedef const Code* Key;
-  typedef intptr_t Value;
+  typedef SegmentRelativeOffset Value;
   typedef CodeAddressPair Pair;
 
-  static constexpr intptr_t kNoValue = -1;
-  static_assert(kNoValue < 0, "non-negative value used for kNoValue");
+  static Key KeyOf(Pair kv) { return kv.code; }
 
-  static Key KeyOf(Pair kv) { return kv.code_; }
-
-  static Value ValueOf(Pair kv) { return kv.address_; }
+  static Value ValueOf(Pair kv) { return kv.segment_offset; }
 
   static inline intptr_t Hashcode(Key key) {
     // Code objects are always allocated in old space, so they don't move.
     return key->PayloadStart();
   }
 
   static inline bool IsKeyEqual(Pair pair, Key key) {
-    return pair.code_->raw() == key->raw();
+    return pair.code->raw() == key->raw();
   }
 
-  CodeAddressPair(const Code* c, intptr_t address)
-      : code_(c), address_(address) {
+  CodeAddressPair(const Code* c, const SegmentRelativeOffset& o)
+      : code(c), segment_offset(o) {
     ASSERT(!c->IsNull());
     ASSERT(c->IsNotTemporaryScopedHandle());
-    ASSERT(address >= 0);
+    ASSERT(o.offset == SegmentRelativeOffset::kUnknownOffset || o.offset >= 0);
   }
+  CodeAddressPair() : code(nullptr), segment_offset() {}
 
-  CodeAddressPair() : code_(NULL), address_(kNoValue) {}
-
-  void Print() const;
-
-  const Code* code_;
-  intptr_t address_;
+  const Code* code;
+  SegmentRelativeOffset segment_offset;
 };
 
 typedef DirectChainedHashMap<CodeAddressPair> CodeAddressMap;
@@ -235,26 +255,16 @@ class Dwarf : public ZoneAllocated {
 
   const ZoneGrowableArray<const Code*>& codes() const { return codes_; }
 
-  // Assumes that no code objects can be at a relocated address of 0 (true
-  // for ELF, since the program header is at address 0).
-  static constexpr intptr_t kNoCodeAddress = 0;
-
   // Stores the code object for later creating the line number program.
   //
-  // [relocated_address] is passed when the relocated address of the
-  // instructions payload is known at snapshot generation time. For example,
-  // it is provided when generating ELF snapshots.
-  //
   // Returns the stored index of the code object when the relocated address
-  // is not known at snapshot generation time (kNoCodeAddress).
-  intptr_t AddCode(const Code& code,
-                   intptr_t relocated_address = kNoCodeAddress);
-
-  // Returns the stored relocated address for the given Code object. If no
-  // address is stored, returns CodeAddressPair::kNoValue.
-  intptr_t CodeAddress(const Code& code) const {
-    return code_to_address_.LookupValue(&code);
-  }
+  // is not known at snapshot generation time (that is, when offset.offset is
+  // SegmentRelativeOffset::kUnknownOffset).
+  intptr_t AddCode(const Code& code, const SegmentRelativeOffset& offset);
+
+  // Returns the stored segment offset for the given Code object. If no
+  // address is stored, the second element will be kNoCodeAddressPairOffset.
+  SegmentRelativeOffset CodeAddress(const Code& code) const;
 
   intptr_t AddFunction(const Function& function);
   intptr_t AddScript(const Script& script);

runtime/vm/elf.cc

@@ -974,6 +974,8 @@ void Elf::FinalizeDwarfSections() {
 #if defined(DART_PRECOMPILER)
   // Add all the static symbols for Code objects. We'll keep a table of
   // symbol names to relocated addresses for use in the DwarfElfStream.
+  // The default kNoValue of 0 is okay here, as no symbols are defined for
+  // relocated address 0.
   CStringMap<intptr_t> symbol_to_address_map;
   // Prime the map with any existing static symbols.
   if (symtab_ != nullptr) {
@@ -986,15 +988,27 @@ void Elf::FinalizeDwarfSections() {
     }
   }
 
+  // Need these to turn offsets into relocated addresses.
+  auto const vm_start =
+      symbol_to_address_map.LookupValue(kVmSnapshotInstructionsAsmSymbol);
+  ASSERT(vm_start > 0);
+  auto const isolate_start =
+      symbol_to_address_map.LookupValue(kIsolateSnapshotInstructionsAsmSymbol);
+  ASSERT(isolate_start > 0);
+  auto const vm_text = FindSegmentForAddress(vm_start);
+  ASSERT(vm_text != nullptr);
+  auto const isolate_text = FindSegmentForAddress(isolate_start);
+  ASSERT(isolate_text != nullptr);
+
   SnapshotTextObjectNamer namer(zone_);
   const auto& codes = dwarf_->codes();
   for (intptr_t i = 0; i < codes.length(); i++) {
     const auto& code = *codes[i];
     auto const name = namer.SnapshotNameFor(i, code);
-    auto const address = dwarf_->CodeAddress(code);
-    ASSERT(address != CodeAddressPair::kNoValue);
-    auto const segment = FindSegmentForAddress(address);
-    ASSERT(segment != nullptr);
+    const auto& pair = dwarf_->CodeAddress(code);
+    ASSERT(pair.offset > 0);
+    auto const segment = pair.vm ? vm_text : isolate_text;
+    const intptr_t address = segment->memory_offset() + pair.offset;
     auto const info = (elf::STB_GLOBAL << 4) | elf::STT_FUNC;
     AddStaticSymbol(name, info, segment->section_index(), address, code.Size());
     symbol_to_address_map.Insert({name, address});

runtime/vm/image_snapshot.cc

@@ -858,7 +858,8 @@ void AssemblyImageWriter::WriteText(WriteStream* clustered_stream, bool vm) {
     intptr_t dwarf_index = i;
 #if defined(DART_PRECOMPILER)
     if (!is_trampoline && assembly_dwarf_ != nullptr) {
-      dwarf_index = assembly_dwarf_->AddCode(*data.code_);
+      dwarf_index =
+          assembly_dwarf_->AddCode(*data.code_, SegmentRelativeOffset(vm));
     }
 #endif
 
@@ -937,8 +938,7 @@ void AssemblyImageWriter::WriteText(WriteStream* clustered_stream, bool vm) {
 
 #if defined(DART_PRECOMPILER)
     if (debug_elf_ != nullptr) {
-      auto const relocated_address = debug_segment_base + text_offset;
-      debug_elf_->dwarf()->AddCode(code, relocated_address);
+      debug_elf_->dwarf()->AddCode(code, {vm, text_offset});
     }
 #endif
     // 2. Write a label at the entry point.
@@ -1415,12 +1415,10 @@ void BlobImageWriter::WriteText(WriteStream* clustered_stream, bool vm) {
 #if defined(DART_PRECOMPILER)
     const auto& code = *data.code_;
     if (elf_ != nullptr && elf_->dwarf() != nullptr) {
-      auto const relocated_address = segment_base + payload_offset;
-      elf_->dwarf()->AddCode(code, relocated_address);
+      elf_->dwarf()->AddCode(code, {vm, payload_offset});
     }
     if (debug_elf_ != nullptr) {
-      auto const relocated_address = debug_segment_base + payload_offset;
-      debug_elf_->dwarf()->AddCode(code, relocated_address);
+      debug_elf_->dwarf()->AddCode(code, {vm, payload_offset});
     }
 
     // Don't patch the relocation if we're not generating ELF. The regular blobs