/external/v8/src/arm/ |
frames-arm.cc | 39 return Memory::Address_at(fp + ExitFrameConstants::kSPOffset);
|
assembler-arm-inl.h | 100 return Memory::Object_at(Assembler::target_address_address_at(pc_)); 106 return Memory::Object_Handle_at(Assembler::target_address_address_at(pc_)); 123 host(), &Memory::Object_at(pc_), HeapObject::cast(target)); 136 Address address = Memory::Address_at(pc_); 144 Address address = Memory::Address_at(pc_); 155 Memory::Address_at(pc_) = address; 170 return Memory::Address_at(pc_ + 2 * Assembler::kInstrSize); 177 Memory::Address_at(pc_ + 2 * Assembler::kInstrSize) = target; 334 Instr instr = Memory::int32_at(target_pc); 341 instr = Memory::int32_at(target_pc) [all...] |
/external/v8/src/ia32/ |
frames-ia32.cc | 39 return Memory::Address_at(fp + ExitFrameConstants::kSPOffset);
|
/external/v8/src/mips/ |
frames-mips.cc | 41 return Memory::Address_at(fp + ExitFrameConstants::kSPOffset);
|
/external/v8/src/x64/ |
frames-x64.cc | 39 return Memory::Address_at(fp + ExitFrameConstants::kSPOffset);
|
assembler-x64-inl.h | 46 Memory::uint32_at(pc_) = x; 52 Memory::uint64_at(pc_) = x; 61 Memory::uint16_at(pc_) = x; 189 return Memory::int32_at(pc) + pc + 4; 194 Memory::int32_at(pc) = static_cast<int32_t>(target - pc - 4); 199 return code_targets_[Memory::int32_at(pc)]; 209 Memory::Address_at(pc_) += static_cast<int32_t>(delta); 212 Memory::int32_at(pc_) -= static_cast<int32_t>(delta); 223 return Memory::Address_at(pc_); 255 Memory::Address_at(pc_) = target [all...] |
/libcore/luni/src/main/java/libcore/io/ |
NioBufferIterator.java | 19 import libcore.io.Memory; 49 Memory.peekByteArray(address + position, dst, dstOffset, byteCount); 54 byte result = Memory.peekByte(address + position); 60 int result = Memory.peekInt(address + position, swap); 66 Memory.peekIntArray(address + position, dst, dstOffset, intCount, swap); 71 short result = Memory.peekShort(address + position, swap);
|
HeapBufferIterator.java | 20 import libcore.io.Memory; 62 int result = Memory.peekInt(buffer, offset + position, order); 69 Memory.unsafeBulkGet(dst, dstOffset, byteCount, buffer, offset + position, SizeOf.INT, order.needsSwap); 74 short result = Memory.peekShort(buffer, offset + position, order);
|
/libcore/luni/src/main/java/java/nio/ |
MemoryBlock.java | 26 import libcore.io.Memory; 31 * Handles calling munmap(2) on a memory-mapped region. 82 * Represents a block of memory we don't own. (We don't take ownership of memory corresponding 149 Memory.pokeByte(address + offset, value); 153 Memory.pokeByteArray(address + offset, src, srcOffset, byteCount); 157 Memory.pokeCharArray(address + offset, src, srcOffset, charCount, swap); 161 Memory.pokeDoubleArray(address + offset, src, srcOffset, doubleCount, swap); 165 Memory.pokeFloatArray(address + offset, src, srcOffset, floatCount, swap); 169 Memory.pokeIntArray(address + offset, src, srcOffset, intCount, swap) [all...] |
HeapByteBuffer.java | 21 import libcore.io.Memory; 71 Memory.unsafeBulkGet(dst, dstOffset, byteCount, backingArray, offset + position, SizeOf.CHAR, order.needsSwap); 77 Memory.unsafeBulkGet(dst, dstOffset, byteCount, backingArray, offset + position, SizeOf.DOUBLE, order.needsSwap); 83 Memory.unsafeBulkGet(dst, dstOffset, byteCount, backingArray, offset + position, SizeOf.FLOAT, order.needsSwap); 89 Memory.unsafeBulkGet(dst, dstOffset, byteCount, backingArray, offset + position, SizeOf.INT, order.needsSwap); 95 Memory.unsafeBulkGet(dst, dstOffset, byteCount, backingArray, offset + position, SizeOf.LONG, order.needsSwap); 101 Memory.unsafeBulkGet(dst, dstOffset, byteCount, backingArray, offset + position, SizeOf.SHORT, order.needsSwap); 125 char result = (char) Memory.peekShort(backingArray, offset + position, order); 133 return (char) Memory.peekShort(backingArray, offset + index, order); 162 int result = Memory.peekInt(backingArray, offset + position, order) [all...] |
ReadWriteHeapByteBuffer.java | 19 import libcore.io.Memory; 118 Memory.unsafeBulkPut(backingArray, offset + position, byteCount, src, srcOffset, SizeOf.CHAR, order.needsSwap); 124 Memory.unsafeBulkPut(backingArray, offset + position, byteCount, src, srcOffset, SizeOf.DOUBLE, order.needsSwap); 130 Memory.unsafeBulkPut(backingArray, offset + position, byteCount, src, srcOffset, SizeOf.FLOAT, order.needsSwap); 136 Memory.unsafeBulkPut(backingArray, offset + position, byteCount, src, srcOffset, SizeOf.INT, order.needsSwap); 142 Memory.unsafeBulkPut(backingArray, offset + position, byteCount, src, srcOffset, SizeOf.LONG, order.needsSwap); 148 Memory.unsafeBulkPut(backingArray, offset + position, byteCount, src, srcOffset, SizeOf.SHORT, order.needsSwap); 155 Memory.pokeShort(backingArray, offset + index, (short) value, order); 165 Memory.pokeShort(backingArray, offset + position, (short) value, order); 196 Memory.pokeInt(backingArray, offset + position, value, order) [all...] |
/external/llvm/include/llvm/Support/ |
PredIteratorCache.h | 32 /// Memory - This is the space that holds cached preds. 33 BumpPtrAllocator Memory; 51 Entry = Memory.Allocate<BasicBlock*>(PredCache.size()); 65 Memory.Reset();
|
Memory.h | 1 //===- llvm/Support/Memory.h - Memory Support --------------------*- C++ -*-===// 10 // This file declares the llvm::sys::Memory class. 23 /// This class encapsulates the notion of a memory block which has an address 24 /// and a size. It is used by the Memory class (a friend) as the result of 25 /// various memory allocation operations. 26 /// @see Memory 27 /// @brief Memory block abstraction. 35 void *Address; ///< Address of first byte of memory area 36 size_t Size; ///< Size, in bytes of the memory are [all...] |
/libcore/luni/src/test/java/libcore/io/ |
MemoryTest.java | 37 Memory.pokeIntArray(ptr, values, 0, values.length, false); 42 Memory.pokeIntArray(ptr, values, 0, values.length, true); 48 Memory.pokeIntArray(ptr + i * scale, values, i, 1, true); 56 assertEquals(expectedValues[i], Memory.peekInt(ptr + 4 * i, swap)); 70 Memory.pokeShortArray(ptr, values, 0, values.length, false); 75 Memory.pokeShortArray(ptr, values, 0, values.length, true); 81 Memory.pokeShortArray(ptr + i * scale, values, i, 1, true); 89 assertEquals(expectedValues[i], Memory.peekShort(ptr + 2 * i, swap));
|
/external/llvm/lib/Target/ARM/ |
ARMJITInfo.cpp | 26 #include "llvm/Support/Memory.h" 126 if (!sys::Memory::setRangeWritable((void*)StubAddr, 8)) { 131 if (!sys::Memory::setRangeExecutable((void*)StubAddr, 8)) { 182 if (!sys::Memory::setRangeWritable(Addr, 16)) { 189 sys::Memory::InvalidateInstructionCache(Addr, 16); 190 if (!sys::Memory::setRangeExecutable(Addr, 16)) { 197 if (!sys::Memory::setRangeWritable(Addr, 8)) { 202 sys::Memory::InvalidateInstructionCache(Addr, 8); 203 if (!sys::Memory::setRangeExecutable(Addr, 8)) { 217 if (!sys::Memory::setRangeWritable(Addr, 16)) [all...] |
/external/v8/src/ |
frames-inl.h | 58 return FromAddress(Memory::Address_at(address() + offset)); 97 return KindField::decode(Memory::unsigned_at(address() + offset)); 154 return Memory::Object_at(GetExpressionAddress(index)); 159 Memory::Object_at(GetExpressionAddress(index)) = value; 165 return Memory::Object_at(fp() + offset); 170 return Memory::Address_at(fp() + StandardFrameConstants::kCallerFPOffset); 175 return Memory::Address_at(ComputePCAddress(fp())); 186 Memory::Object_at(fp + StandardFrameConstants::kContextOffset); 193 Memory::Object_at(fp + StandardFrameConstants::kMarkerOffset); 212 return Memory::Object_at(GetParameterSlot(index)) [all...] |
v8memory.h | 34 // Memory provides an interface to 'raw' memory. It encapsulates the casts 37 class Memory {
|
/libcore/luni/src/main/java/java/util/zip/ |
ZipInputStream.java | 28 import libcore.io.Memory; 199 int sig = Memory.peekInt(hdrBuf, 0, ByteOrder.LITTLE_ENDIAN); 203 currentEntry.crc = ((long) Memory.peekInt(hdrBuf, EXTCRC, ByteOrder.LITTLE_ENDIAN)) & 0xffffffffL; 204 currentEntry.compressedSize = ((long) Memory.peekInt(hdrBuf, EXTSIZ, ByteOrder.LITTLE_ENDIAN)) & 0xffffffffL; 205 currentEntry.size = ((long) Memory.peekInt(hdrBuf, EXTLEN, ByteOrder.LITTLE_ENDIAN)) & 0xffffffffL; 232 int hdr = Memory.peekInt(hdrBuf, 0, ByteOrder.LITTLE_ENDIAN); 254 ceCrc = ((long) Memory.peekInt(hdrBuf, LOCCRC - LOCVER, ByteOrder.LITTLE_ENDIAN)) & 0xffffffffL; 255 ceCompressedSize = ((long) Memory.peekInt(hdrBuf, LOCSIZ - LOCVER, ByteOrder.LITTLE_ENDIAN)) & 0xffffffffL; 256 ceSize = ((long) Memory.peekInt(hdrBuf, LOCLEN - LOCVER, ByteOrder.LITTLE_ENDIAN)) & 0xffffffffL; 289 return Memory.peekShort(hdrBuf, offset, ByteOrder.LITTLE_ENDIAN) & 0xffff [all...] |
GZIPInputStream.java | 25 import libcore.io.Memory; 99 short magic = Memory.peekShort(header, 0, ByteOrder.LITTLE_ENDIAN); 113 int length = Memory.peekShort(header, 0, ByteOrder.LITTLE_ENDIAN) & 0xffff; 134 short crc16 = Memory.peekShort(header, 0, ByteOrder.LITTLE_ENDIAN); 193 if (Memory.peekInt(b, 0, ByteOrder.LITTLE_ENDIAN) != (int) crc.getValue()) { 196 if (Memory.peekInt(b, 4, ByteOrder.LITTLE_ENDIAN) != inf.getTotalOut()) {
|
/libcore/luni/src/main/native/ |
libcore_io_Memory.cpp | 17 #define LOG_TAG "Memory" 232 // Handle unaligned memory access one byte at a time 257 // Handle unaligned memory access one byte at a time 328 NATIVE_METHOD(Memory, memmove, "(Ljava/lang/Object;ILjava/lang/Object;IJ)V"), 329 NATIVE_METHOD(Memory, peekByte, "!(I)B"), 330 NATIVE_METHOD(Memory, peekByteArray, "(I[BII)V"), 331 NATIVE_METHOD(Memory, peekCharArray, "(I[CIIZ)V"), 332 NATIVE_METHOD(Memory, peekDoubleArray, "(I[DIIZ)V"), 333 NATIVE_METHOD(Memory, peekFloatArray, "(I[FIIZ)V"), 334 NATIVE_METHOD(Memory, peekInt, "!(IZ)I") [all...] |
/external/llvm/lib/Target/Mips/ |
MipsJITInfo.cpp | 24 #include "llvm/Support/Memory.h" 141 sys::Memory::InvalidateInstructionCache((void*) StubAddr, 16); 161 if (!sys::Memory::setRangeWritable(Addr, 16)) 185 sys::Memory::InvalidateInstructionCache(Addr, 16); 186 if (!sys::Memory::setRangeExecutable(Addr, 16))
|
/external/llvm/tools/llvm-rtdyld/ |
llvm-rtdyld.cpp | 20 #include "llvm/Support/Memory.h" 49 // A trivial memory manager that doesn't do anything fancy, just uses the 71 return (uint8_t*)sys::Memory::AllocateRWX(Size, 0, 0).base(); 77 return (uint8_t*)sys::Memory::AllocateRWX(Size, 0, 0).base(); 102 // Load the input memory buffer. 127 // Make sure the memory is executable. 129 sys::Memory::InvalidateInstructionCache(Data.base(), Data.size()); 130 if (!sys::Memory::setExecutable(Data, &ErrorStr))
|
/libcore/luni/src/main/java/java/io/ |
DataOutputStream.java | 22 import libcore.io.Memory; 179 Memory.pokeInt(scratch, 0, val, ByteOrder.BIG_ENDIAN); 185 Memory.pokeLong(scratch, 0, val, ByteOrder.BIG_ENDIAN); 191 Memory.pokeShort(scratch, 0, (short) val, ByteOrder.BIG_ENDIAN);
|
/libcore/luni/src/main/java/java/net/ |
Socks4Message.java | 22 import libcore.io.Memory; 80 return Memory.peekShort(buffer, INDEX_PORT, ByteOrder.BIG_ENDIAN); 87 Memory.pokeShort(buffer, INDEX_PORT, (short) port, ByteOrder.BIG_ENDIAN); 94 return Memory.peekInt(buffer, INDEX_IP, ByteOrder.BIG_ENDIAN);
|
Inet4Address.java | 22 import libcore.io.Memory; 74 int address = Memory.peekInt(ipaddress, 0, ByteOrder.BIG_ENDIAN);
|