Add support for invoke-static in optimizing compiler.

Support is limited to calls without parameters and returning
void. For simplicity, we currently follow the Quick ABI.

Change-Id: I54805161141b7eac5959f1cae0dc138dd0b2e8a5

1 files changed, 91 insertions, 1 deletions

diff --git a/compiler/optimizing/code_generator.cc b/compiler/optimizing/code_generator.cc
index bb6ac84..b86665b 100644
--- a/compiler/optimizing/code_generator.cc
+++ b/compiler/optimizing/code_generator.cc
@@ -21,8 +21,11 @@
 #include "dex/verified_method.h"
 #include "driver/dex_compilation_unit.h"
 #include "gc_map_builder.h"
+#include "leb128.h"
+#include "mapping_table.h"
 #include "utils/assembler.h"
 #include "verifier/dex_gc_map.h"
+#include "vmap_table.h"
 
 namespace art {
 
@@ -120,8 +123,95 @@ void CodeGenerator::BuildNativeGCMap(
       dex_compilation_unit.GetVerifiedMethod()->GetDexGcMap();
   verifier::DexPcToReferenceMap dex_gc_map(&(gc_map_raw)[0]);
 
-  GcMapBuilder builder(data, 0, 0, dex_gc_map.RegWidth());
+  uint32_t max_native_offset = 0;
+  for (size_t i = 0; i < pc_infos_.Size(); i++) {
+    uint32_t native_offset = pc_infos_.Get(i).native_pc;
+    if (native_offset > max_native_offset) {
+      max_native_offset = native_offset;
+    }
+  }
+
+  GcMapBuilder builder(data, pc_infos_.Size(), max_native_offset, dex_gc_map.RegWidth());
+  for (size_t i = 0; i < pc_infos_.Size(); i++) {
+    struct PcInfo pc_info = pc_infos_.Get(i);
+    uint32_t native_offset = pc_info.native_pc;
+    uint32_t dex_pc = pc_info.dex_pc;
+    const uint8_t* references = dex_gc_map.FindBitMap(dex_pc, false);
+    CHECK(references != NULL) << "Missing ref for dex pc 0x" << std::hex << dex_pc;
+    builder.AddEntry(native_offset, references);
+  }
 }
 
+void CodeGenerator::BuildMappingTable(std::vector<uint8_t>* data) const {
+  uint32_t pc2dex_data_size = 0u;
+  uint32_t pc2dex_entries = pc_infos_.Size();
+  uint32_t pc2dex_offset = 0u;
+  int32_t pc2dex_dalvik_offset = 0;
+  uint32_t dex2pc_data_size = 0u;
+  uint32_t dex2pc_entries = 0u;
+
+  // We currently only have pc2dex entries.
+  for (size_t i = 0; i < pc2dex_entries; i++) {
+    struct PcInfo pc_info = pc_infos_.Get(i);
+    pc2dex_data_size += UnsignedLeb128Size(pc_info.native_pc - pc2dex_offset);
+    pc2dex_data_size += SignedLeb128Size(pc_info.dex_pc - pc2dex_dalvik_offset);
+    pc2dex_offset = pc_info.native_pc;
+    pc2dex_dalvik_offset = pc_info.dex_pc;
+  }
+
+  uint32_t total_entries = pc2dex_entries + dex2pc_entries;
+  uint32_t hdr_data_size = UnsignedLeb128Size(total_entries) + UnsignedLeb128Size(pc2dex_entries);
+  uint32_t data_size = hdr_data_size + pc2dex_data_size + dex2pc_data_size;
+  data->resize(data_size);
+
+  uint8_t* data_ptr = &(*data)[0];
+  uint8_t* write_pos = data_ptr;
+  write_pos = EncodeUnsignedLeb128(write_pos, total_entries);
+  write_pos = EncodeUnsignedLeb128(write_pos, pc2dex_entries);
+  DCHECK_EQ(static_cast<size_t>(write_pos - data_ptr), hdr_data_size);
+  uint8_t* write_pos2 = write_pos + pc2dex_data_size;
+
+  pc2dex_offset = 0u;
+  pc2dex_dalvik_offset = 0u;
+  for (size_t i = 0; i < pc2dex_entries; i++) {
+    struct PcInfo pc_info = pc_infos_.Get(i);
+    DCHECK(pc2dex_offset <= pc_info.native_pc);
+    write_pos = EncodeUnsignedLeb128(write_pos, pc_info.native_pc - pc2dex_offset);
+    write_pos = EncodeSignedLeb128(write_pos, pc_info.dex_pc - pc2dex_dalvik_offset);
+    pc2dex_offset = pc_info.native_pc;
+    pc2dex_dalvik_offset = pc_info.dex_pc;
+  }
+  DCHECK_EQ(static_cast<size_t>(write_pos - data_ptr), hdr_data_size + pc2dex_data_size);
+  DCHECK_EQ(static_cast<size_t>(write_pos2 - data_ptr), data_size);
+
+  if (kIsDebugBuild) {
+    // Verify the encoded table holds the expected data.
+    MappingTable table(data_ptr);
+    CHECK_EQ(table.TotalSize(), total_entries);
+    CHECK_EQ(table.PcToDexSize(), pc2dex_entries);
+    auto it = table.PcToDexBegin();
+    auto it2 = table.DexToPcBegin();
+    for (size_t i = 0; i < pc2dex_entries; i++) {
+      struct PcInfo pc_info = pc_infos_.Get(i);
+      CHECK_EQ(pc_info.native_pc, it.NativePcOffset());
+      CHECK_EQ(pc_info.dex_pc, it.DexPc());
+      ++it;
+    }
+    CHECK(it == table.PcToDexEnd());
+    CHECK(it2 == table.DexToPcEnd());
+  }
+}
+
+void CodeGenerator::BuildVMapTable(std::vector<uint8_t>* data) const {
+  Leb128EncodingVector vmap_encoder;
+  size_t size = 1 + 1 /* marker */ + 0;
+  vmap_encoder.Reserve(size + 1u);  // All values are likely to be one byte in ULEB128 (<128).
+  vmap_encoder.PushBackUnsigned(size);
+  // We're currently always saving the frame pointer, so set it in the table as a temporary.
+  vmap_encoder.PushBackUnsigned(kVRegTempBaseReg + VmapTable::kEntryAdjustment);
+  vmap_encoder.PushBackUnsigned(VmapTable::kAdjustedFpMarker);
+
+  *data = vmap_encoder.GetData();
+}
 
 }  // namespace art