Searched defs:copy (Results 1 - 10 of 10) sorted by relevance

/art/runtime/base/
H A Dstringpiece.cc6 * You may obtain a copy of the License at
37 StringPiece::size_type StringPiece::copy(char* buf, size_type n, size_type pos) const { function in class:art::StringPiece
/art/patchoat/
H A Dpatchoat.h6 * You may obtain a copy of the License at
103 void FixupMethod(ArtMethod* object, ArtMethod* copy)
173 // Walks through the old image and patches the mmap'd copy of it to the new offset. It does not
177 PatchVisitor(PatchOat* patcher, mirror::Object* copy) : patcher_(patcher), copy_(copy) {} argument
H A Dpatchoat.cc6 * You may obtain a copy of the License at
467 // Note that we require that ReadFromMemory does not make an internal copy of the elements.
587 mirror::Object* copy = RelocatedCopyOf(object); local
588 CHECK(copy != nullptr);
593 copy->SetReadBarrierPointer(moved_to);
594 DCHECK_EQ(copy->GetReadBarrierPointer(), moved_to);
597 PatchOat::PatchVisitor visitor(this, copy);
601 auto* copy_klass = down_cast<mirror::Class*>(copy);
636 auto* dest = down_cast<mirror::AbstractMethod*>(copy);
642 void PatchOat::FixupMethod(ArtMethod* object, ArtMethod* copy) { argument
[all...]
/art/runtime/mirror/
H A Dobject.cc6 * You may obtain a copy of the License at
80 // object above, copy references fields one by one again with a
129 Object* copy; local
132 copy = heap->AllocObject<true>(self, GetClass(), num_bytes, visitor);
134 copy = heap->AllocNonMovableObject<true>(self, GetClass(), num_bytes, visitor);
136 return copy;
/art/test/449-checker-bce/src/
H A DMain.java6 * You may obtain a copy of the License at
203 static int[] constantIndexing3(int[] array1, int[] array2, boolean copy) { argument
204 if (!copy) {
/art/compiler/utils/
H A Dassembler_test_base.h6 * You may obtain a copy of the License at
446 std::string copy = file.substr(0, space_index - 1); local
449 return stat(copy.c_str(), &buf) == 0;
/art/compiler/
H A Dimage_writer.cc6 * You may obtain a copy of the License at
280 LOG(FATAL) << "Fat locked object " << object << " found during object copy";
284 LOG(FATAL) << "Thin locked object " << object << " found during object copy";
746 // of dex caches first and then lock it again to copy the dex
944 // Transform each object's bin slot into an offset which will be used to do the final copy.
1100 // Note that we require that ReadFromMemory does not make an internal copy of the elements so that
1185 FixupVisitor(ImageWriter* image_writer, Object* copy) : image_writer_(image_writer), copy_(copy) { argument
1212 FixupClassVisitor(ImageWriter* image_writer, Object* copy) : FixupVisitor(image_writer, copy) { argument
1229 FixupClass(mirror::Class* orig, mirror::Class* copy) argument
1282 FixupObject(Object* orig, Object* copy) argument
1383 CopyAndFixupMethod(ArtMethod* orig, ArtMethod* copy) argument
[all...]
/art/tools/
H A Dcpplint.py79 import copy namespace
1559 self.pp_stack.append(_PreprocessorInfo(copy.deepcopy(self.stack)))
1568 self.pp_stack[-1].stack_before_else = copy.deepcopy(self.stack)
1571 self.stack = copy.deepcopy(self.pp_stack[-1].stack_before_if)
1582 # Here we can just use a shallow copy since we are the last
3572 for _template in ('copy', 'max', 'min', 'min_element', 'sort', 'swap',
3723 # Let's copy the include_state so it is only messed up within this function.
3724 include_state = include_state.copy()
3741 # include_state is modified during iteration, so we iterate over a copy of
/art/compiler/dex/
H A Dmir_graph.cc6 * You may obtain a copy of the License at
1104 // Add a copy of each MIR.
1637 // TODO: This value is needed for debugging. Currently, we compute this and then copy to the
1988 // Loop head: it was already processed, mark end and copy exit blocks to the queue.
2166 // We don't do a memcpy style copy here because it would lead to a lot of things
2189 // Now copy instructions.
2191 // Get a copy first.
2192 MIR* copy = mir->Copy(mir_graph); local
2195 result_bb->AppendMIR(copy);
/art/runtime/
H A Dcheck_jni.cc6 * You may obtain a copy of the License at
1201 GuardedCopy* copy = new (new_buf) GuardedCopy(original_buf, len, adler); local
1206 const_cast<char*>(copy->StartRedZone())[i] = kCanary[j];
1213 memcpy(const_cast<uint8_t*>(copy->BufferWithinRedZones()), original_buf, len);
1217 const_cast<char*>(copy->EndRedZone())[i] = kCanary[j];
1223 return const_cast<uint8_t*>(copy->BufferWithinRedZones());
1227 * Create a guarded copy of a primitive array. Modifications to the copied
1245 * Perform the array "release" operation, which may or may not copy data
1255 GuardedCopy* const copy = FromEmbedded(embedded_buf); local
1256 void* original_ptr = copy
1271 GuardedCopy* copy = FromEmbedded(embedded_buf); local
1285 const GuardedCopy* copy = FromEmbedded(embedded_buf); local
[all...]

Completed in 261 milliseconds