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
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 @@
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