Searched defs:map (Results 1 - 23 of 23) sorted by relevance

/art/test/004-InterfaceTest/src/
H A DMain.java22 public static long test_virtual(HashMap map) { argument
27 map.put(intobj, s);
33 public static long test_interface(Map map) { argument
38 map.put(intobj, s);
/art/runtime/
H A Dparsed_options_test.cc62 RuntimeArgumentMap map; local
63 std::unique_ptr<ParsedOptions> parsed(ParsedOptions::Create(options, false, &map));
65 ASSERT_NE(0u, map.Size());
69 #define EXPECT_PARSED_EQ(expected, actual_key) EXPECT_EQ(expected, map.GetOrDefault(actual_key))
70 #define EXPECT_PARSED_EXISTS(actual_key) EXPECT_TRUE(map.Exists(actual_key))
79 EXPECT_DOUBLE_EQ(0.75, map.GetOrDefault(Opt::HeapTargetUtilization));
80 EXPECT_TRUE(test_vfprintf == map.GetOrDefault(Opt::HookVfprintf));
81 EXPECT_TRUE(test_exit == map.GetOrDefault(Opt::HookExit));
82 EXPECT_TRUE(test_abort == map.GetOrDefault(Opt::HookAbort));
94 auto&& properties_list = map
104 RuntimeArgumentMap map; local
[all...]
H A Dmem_map.cc73 MemMap* map = it->second; local
74 CHECK_EQ(base, map->BaseBegin());
75 os << *map << std::endl;
140 // Return true if the address range is contained in a single /proc/self/map entry.
145 std::unique_ptr<BacktraceMap> map(BacktraceMap::Create(getpid(), true));
146 if (map.get() == nullptr) {
147 *error_msg = StringPrintf("Failed to build process map");
150 for (BacktraceMap::const_iterator it = map->begin(); it != map->end(); ++it) {
158 "any existing map
657 MemMap* map = begin_map; local
690 MemMap* map = it->second; local
733 HasMemMap(MemMap* map) argument
750 MemMap* map = it->second; local
[all...]
H A Dprofiler.cc436 // A method has been hit, record its invocation in the method map.
577 Map *map = table[i]; local
578 if (map != nullptr) {
579 for (const auto &meth_iter : *map) {
864 // Add it to the profile map.
H A Ddex_file.cc214 std::unique_ptr<MemMap> map; local
228 map.reset(MemMap::MapFile(length, PROT_READ, MAP_PRIVATE, fd, 0, location, error_msg));
229 if (map.get() == nullptr) {
235 if (map->Size() < sizeof(DexFile::Header)) {
241 const Header* dex_header = reinterpret_cast<const Header*>(map->Begin());
243 std::unique_ptr<const DexFile> dex_file(OpenMemory(location, dex_header->checksum_, map.release(),
294 std::unique_ptr<MemMap> map(zip_entry->ExtractToMemMap(location.c_str(), entry_name, error_msg));
295 if (map.get() == nullptr) {
301 std::unique_ptr<const DexFile> dex_file(OpenMemory(location, zip_entry->GetCrc32(), map.release(),
H A Ddex_file_verifier.cc275 CheckValidOffsetAndSize(header_->map_off_, header_->map_off_, "map") &&
288 const DexFile::MapList* map = reinterpret_cast<const DexFile::MapList*>(begin_ + local
290 // Check that map list content is available.
291 if (!CheckListSize(map, 1, sizeof(DexFile::MapList), "maplist content")) {
295 const DexFile::MapItem* item = map->list_;
297 uint32_t count = map->size_;
303 // Sanity check the size of the map list.
304 if (!CheckListSize(item, count, sizeof(DexFile::MapItem), "map size")) {
308 // Check the items listed in the map.
311 ErrorStringPrintf("Out of order map ite
1347 const DexFile::MapList* map = reinterpret_cast<const DexFile::MapList*>(begin_ + header_->map_off_); local
2063 const DexFile::MapList* map = reinterpret_cast<const DexFile::MapList*>(begin_ + header_->map_off_); local
[all...]
H A Delf_file.cc190 // first just map ELF header to get program header size information
208 *error_msg = StringPrintf("Failed to map ELF program headers: %s", error_msg->c_str());
212 // otherwise map entire file
216 *error_msg = StringPrintf("Failed to map ELF file: %s", error_msg->c_str());
471 bool ElfFileImpl<ElfTypes>::SetMap(MemMap* map, std::string* error_msg) { argument
472 if (map == nullptr) {
477 map_.reset(map);
1212 // empty segment, nothing to map
1267 *error_msg = StringPrintf("Failed to map ELF file segment %d from %s: %s",
1272 *error_msg = StringPrintf("Failed to map EL
[all...]
H A Dthread.cc2321 // Process register map (which native and runtime methods don't have)
2330 StackMap map = code_info.GetStackMapForNativePcOffset(native_pc_offset); local
2331 MemoryRegion mask = map.GetStackMask(code_info);
2347 uint32_t register_mask = map.GetRegisterMask(code_info);
2362 NativePcOffsetToReferenceMap map(native_gc_map);
2363 size_t num_regs = std::min(map.RegWidth() * 8,
2369 const uint8_t* reg_bitmap = map.FindBitMap(native_pc_offset);
/art/compiler/dwarf/
H A Dregister.h47 static const int map[8] = {0, 2, 1, 3, 7, 6, 4, 5}; local
48 return Reg(num < 8 ? map[num] : num);
/art/runtime/jit/
H A Djit_code_cache.cc33 MemMap* map = MemMap::MapAnonymous("jit-code-cache", nullptr, capacity, local
35 if (map == nullptr) {
41 return new JitCodeCache(map);
49 // Data cache is 1 / 4 of the map. TODO: Make this variable?
/art/test/004-ThreadStress/src/
H A DMain.java37 // --dumpmap ....... print the frequency map
285 private static void normalize(Map<Operation, Double> map) { argument
287 for (Double d : map.values()) {
295 Set<Operation> tmp = new HashSet<>(map.keySet());
297 map.put(op, map.get(op) / sum);
/art/tools/dexfuzz/src/dexfuzz/listeners/
H A DUniqueProgramTrackerListener.java187 private void addToMap(String md5sum, Map<String, Integer> map) { argument
188 if (map.containsKey(md5sum)) {
189 map.put(md5sum, map.get(md5sum) + 1);
191 map.put(md5sum, 1);
/art/cmdline/
H A Dcmdline_parser_test.cc89 const TMap& map,
91 auto* actual = map.Get(key);
101 return ::testing::AssertionFailure() << "key was not in the map";
146 #define EXPECT_KEY_EXISTS(map, key) EXPECT_TRUE((map).Exists(key))
147 #define EXPECT_KEY_VALUE(map, key, expected) EXPECT_TRUE(IsExpectedKeyValue(expected, map, key))
211 // Test value map substitution fails
544 "-Xnodex2oat -Xmethod-trace -XX:LargeObjectSpace=map")));
546 auto&& map local
88 IsExpectedKeyValue(const T& expected, const TMap& map, const TKey& key) argument
[all...]
/art/compiler/linker/
H A Drelative_patcher_test.h98 method_offset_map_.map.Put(compiled_method_refs_[idx], quick_code_offset);
218 // Wrap the map in a class implementing linker::RelativePatcherTargetProvider.
222 auto it = map.find(ref);
223 if (it == map.end()) {
229 SafeMap<MethodReference, uint32_t, MethodReferenceComparator> map; member in class:art::linker::RelativePatcherTest::FINAL
/art/compiler/dex/
H A Dlocal_value_numbering.h97 uint16_t GetSregValueImpl(int s_reg, const SregValueMap* map) const {
99 auto lb = map->find(s_reg);
100 if (lb != map->end()) {
108 void SetOperandValueImpl(uint16_t s_reg, uint16_t value, SregValueMap* map) { argument
109 DCHECK_EQ(map->count(s_reg), 0u);
110 map->Put(s_reg, value);
113 uint16_t GetOperandValueImpl(int s_reg, const SregValueMap* map) const {
115 auto lb = map->find(s_reg);
116 if (lb != map->end()) {
284 AliasingValues* GetAliasingValues(Map* map, cons
[all...]
H A Dglobal_value_numbering_test.cc279 void DoPrepareVregToSsaMapExit(BasicBlockId bb_id, const int32_t* map, size_t count) { argument
285 std::copy_n(map, count, bb->data_flow_info->vreg_to_ssa_map_exit);
289 void PrepareVregToSsaMapExit(BasicBlockId bb_id, const int32_t (&map)[count]) { argument
290 DoPrepareVregToSsaMapExit(bb_id, map, count);
H A Dgvn_dead_code_elimination_test.cc334 void PrepareSRegToVRegMap(const int (&map)[count]) { argument
335 cu_.mir_graph->ssa_base_vregs_.assign(map, map + count);
336 num_vregs_ = *std::max_element(map, map + count) + 1u;
H A Dlocal_value_numbering.cc29 // Operations used for value map keys instead of actual opcode.
203 Map* map, const typename Map::key_type& key) {
204 auto lb = map->lower_bound(key);
205 if (lb == map->end() || map->key_comp()(key, lb->first)) {
206 lb = map->PutBefore(lb, key, AliasingValues(this));
233 Map* map, const typename Map::key_type& key,
236 // const_cast<LocalValueNumbering*>(lvn)->HandleAliasingValueGet(map. key, location)
237 // but don't modify the map.
239 auto it = map
202 GetAliasingValues( Map* map, const typename Map::key_type& key) argument
231 AliasingValuesMergeGet(GlobalValueNumbering* gvn, const LocalValueNumbering* lvn, Map* map, const typename Map::key_type& key, uint16_t location) argument
257 HandleAliasingValuesGet(Map* map, const typename Map::key_type& key, uint16_t location) argument
278 HandleAliasingValuesPut(Map* map, const typename Map::key_type& key, uint16_t location, uint16_t value) argument
[all...]
/art/runtime/base/
H A Dvariant_map.h21 #include <map>
27 // A variant map is a heterogenous, type safe key->value map. It allows
28 // for multiple different value types to be stored dynamically in the same map.
205 // A variant map allows type-safe heteregeneous key->value mappings.
215 // A null value is returned only when the key does not exist in this map.
222 // A null value is returned only when the key does not exist in this map.
228 // Lookup the value from the key. If it was not set in the map, return the default value.
240 ScopedRemove(VariantMap& map, const TKey<TValue>& key) : map_(map), key argument
[all...]
/art/compiler/
H A Doat_writer.cc177 return "GC map";
398 auto method_lb = writer_->method_offset_map_.map.lower_bound(method_ref);
399 if (method_lb != writer_->method_offset_map_.map.end() &&
400 !writer_->method_offset_map_.map.key_comp()(method_ref, method_lb->first)) {
406 writer_->method_offset_map_.map.PutBefore(method_lb, method_ref, quick_code_offset);
568 const SwapVector<uint8_t>* map = DataAccess::GetData(compiled_method); local
569 uint32_t map_size = map == nullptr ? 0 : map->size() * sizeof((*map)[0]);
571 auto lb = dedupe_map_.lower_bound(map);
916 const SwapVector<uint8_t>* map = DataAccess::GetData(compiled_method); local
[all...]
/art/compiler/optimizing/
H A Dbounds_check_elimination.cc1130 // Return the map of proven value ranges at the beginning of a basic block.
1138 std::unique_ptr<ArenaSafeMap<int, ValueRange*>> map(
1141 maps_.at(block_id) = std::move(map);
1149 ArenaSafeMap<int, ValueRange*>* map = GetValueRangeMap(basic_block); local
1150 if (map != nullptr) {
1151 if (map->find(instruction->GetId()) != map->end()) {
1152 return map->Get(instruction->GetId());
/art/imgdiag/
H A Dimgdiag.cc25 #include <map>
117 // Find the memory map only for boot.art
118 for (const backtrace_map_t& map : *proc_maps) {
119 if (EndsWith(map.name, GetImageLocationBaseName())) {
120 if ((map.flags & PROT_WRITE) != 0) {
121 boot_map = map;
125 // In actuality there's more than 1 map, but the second one is read-only.
126 // The one we care about is the write-able map.
133 os << "Could not find map for " << GetImageLocationBaseName();
160 // Memory-map /pro
704 SortByValueDesc(const std::map<K, V> map) argument
[all...]
/art/runtime/gc/
H A Dheap.cc304 // PreZygoteFork the first time. In this case, call the map "zygote space" since we can't
305 // rename the mem map later.
307 // Reserve the non moving mem map before the other two since it needs to be at a specific
408 large_object_space_ = space::LargeObjectMapSpace::Create("mem map large object space");
532 MemMap* map = MemMap::MapAnonymous(name, request_begin, capacity, local
534 if (map != nullptr || request_begin == nullptr) {
535 return map;
1935 // Use the now empty main space mem map for the bump pointer temp space.
1976 // Temporarily unprotect the backup mem map so rosalloc can write the debug magic number.

Completed in 2639 milliseconds