| /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);
|
