| /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);
|
| /external/llvm/unittests/Support/ |
| MemoryTest.cpp | 10 #include "llvm/Support/Memory.h"
28 // Adds RW flags to permit testing of the resulting memory
31 case Memory::MF_READ:
32 case Memory::MF_WRITE:
33 case Memory::MF_READ|Memory::MF_WRITE:
34 return Memory::MF_READ|Memory::MF_WRITE;
35 case Memory::MF_READ|Memory::MF_EXEC
[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
148 Memory.pokeByte(address + offset, value);
152 Memory.pokeByteArray(address + offset, src, srcOffset, byteCount);
156 Memory.pokeCharArray(address + offset, src, srcOffset, charCount, swap);
160 Memory.pokeDoubleArray(address + offset, src, srcOffset, doubleCount, swap);
164 Memory.pokeFloatArray(address + offset, src, srcOffset, floatCount, swap);
168 Memory.pokeIntArray(address + offset, src, srcOffset, intCount, swap)
[all...] |
| ByteArrayBuffer.java | 21 import libcore.io.Memory;
116 Memory.unsafeBulkGet(dst, dstOffset, byteCount, backingArray, arrayOffset + position, SizeOf.CHAR, order.needsSwap);
122 Memory.unsafeBulkGet(dst, dstOffset, byteCount, backingArray, arrayOffset + position, SizeOf.DOUBLE, order.needsSwap);
128 Memory.unsafeBulkGet(dst, dstOffset, byteCount, backingArray, arrayOffset + position, SizeOf.FLOAT, order.needsSwap);
134 Memory.unsafeBulkGet(dst, dstOffset, byteCount, backingArray, arrayOffset + position, SizeOf.INT, order.needsSwap);
140 Memory.unsafeBulkGet(dst, dstOffset, byteCount, backingArray, arrayOffset + position, SizeOf.LONG, order.needsSwap);
146 Memory.unsafeBulkGet(dst, dstOffset, byteCount, backingArray, arrayOffset + position, SizeOf.SHORT, order.needsSwap);
167 char result = (char) Memory.peekShort(backingArray, arrayOffset + position, order);
174 return (char) Memory.peekShort(backingArray, arrayOffset + index, order);
198 int result = Memory.peekInt(backingArray, arrayOffset + position, 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.
24 /// This class encapsulates the notion of a memory block which has an address
25 /// and a size. It is used by the Memory class (a friend) as the result of
26 /// various memory allocation operations.
27 /// @see Memory
28 /// @brief Memory block abstraction.
36 void *Address; ///< Address of first byte of memory area
37 size_t Size; ///< Size, in bytes of the memory are
[all...] |
| /libcore/luni/src/test/java/libcore/io/ |
| MemoryTest.java | 42 Memory.pokeIntArray(ptr, values, 0, values.length, false);
47 Memory.pokeIntArray(ptr, values, 0, values.length, true);
53 Memory.pokeIntArray(ptr + i * scale, values, i, 1, true);
62 assertEquals(expectedValues[i], Memory.peekInt(ptr + SizeOf.INT * i, swap));
83 Memory.pokeLongArray(ptr, values, 0, values.length, false);
88 Memory.pokeLongArray(ptr, values, 0, values.length, true);
94 Memory.pokeLongArray(ptr + i * scale, values, i, 1, true);
103 assertEquals(expectedValues[i], Memory.peekLong(ptr + SizeOf.LONG * i, swap));
121 Memory.pokeShortArray(ptr, values, 0, values.length, false);
126 Memory.pokeShortArray(ptr, values, 0, values.length, true)
[all...] |
| /external/llvm/lib/ExecutionEngine/MCJIT/ |
| SectionMemoryManager.cpp | 1 //===- SectionMemoryManager.cpp - Memory manager for MCJIT/RtDyld *- C++ -*-==//
10 // This file implements the section-based memory manager used by the MCJIT
58 // Look in the list of free memory regions and use a block there if one
67 // Store cutted free memory block.
74 // No pre-allocated free block was large enough. Allocate a new memory region.
76 // be updated later based on memory group.
81 // FIXME: Initialize the Near member for each memory group to avoid
84 sys::MemoryBlock MB = sys::Memory::allocateMappedMemory(RequiredSize,
86 sys::Memory::MF_READ |
87 sys::Memory::MF_WRITE
[all...] |
| /external/llvm/tools/lli/ |
| RemoteTarget.cpp | 18 #include "llvm/Support/Memory.h"
26 sys::MemoryBlock Mem = sys::Memory::AllocateRWX(Size, Prev, &ErrorMsg);
30 ErrorMsg = "unable to allocate sufficiently aligned memory";
45 sys::Memory::setExecutable(Mem, &ErrorMsg);
60 sys::Memory::ReleaseRWX(Allocations[i]);
|
| RecordingMemoryManager.cpp | 1 //===- RecordingMemoryManager.cpp - Recording memory manager --------------===//
10 // This memory manager allocates local storage and keeps a record of each
22 sys::Memory::releaseMappedMemory(I->first);
26 sys::Memory::releaseMappedMemory(I->first);
31 // The recording memory manager is just a local copy of the remote target.
33 // heap storage is sufficient here, but we're using mapped memory to work
43 // The recording memory manager is just a local copy of the remote target.
45 // heap storage is sufficient here, but we're using mapped memory to work
54 sys::MemoryBlock MB = sys::Memory::allocateMappedMemory(Size,
56 sys::Memory::MF_READ
[all...] |
| /external/llvm/lib/Target/ARM/ |
| ARMJITInfo.cpp | 24 #include "llvm/Support/Memory.h"
125 if (!sys::Memory::setRangeWritable((void*)StubAddr, 8)) {
130 if (!sys::Memory::setRangeExecutable((void*)StubAddr, 8)) {
181 if (!sys::Memory::setRangeWritable(Addr, 16)) {
188 sys::Memory::InvalidateInstructionCache(Addr, 16);
189 if (!sys::Memory::setRangeExecutable(Addr, 16)) {
196 if (!sys::Memory::setRangeWritable(Addr, 8)) {
201 sys::Memory::InvalidateInstructionCache(Addr, 8);
202 if (!sys::Memory::setRangeExecutable(Addr, 8)) {
216 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...] |
| /libcore/luni/src/main/java/java/util/zip/ |
| ZipInputStream.java | 28 import libcore.io.Memory;
194 int sig = Memory.peekInt(hdrBuf, 0, ByteOrder.LITTLE_ENDIAN);
198 currentEntry.crc = ((long) Memory.peekInt(hdrBuf, EXTCRC, ByteOrder.LITTLE_ENDIAN)) & 0xffffffffL;
199 currentEntry.compressedSize = ((long) Memory.peekInt(hdrBuf, EXTSIZ, ByteOrder.LITTLE_ENDIAN)) & 0xffffffffL;
200 currentEntry.size = ((long) Memory.peekInt(hdrBuf, EXTLEN, ByteOrder.LITTLE_ENDIAN)) & 0xffffffffL;
224 int hdr = Memory.peekInt(hdrBuf, 0, ByteOrder.LITTLE_ENDIAN);
250 ceCrc = ((long) Memory.peekInt(hdrBuf, LOCCRC - LOCVER, ByteOrder.LITTLE_ENDIAN)) & 0xffffffffL;
251 ceCompressedSize = ((long) Memory.peekInt(hdrBuf, LOCSIZ - LOCVER, ByteOrder.LITTLE_ENDIAN)) & 0xffffffffL;
252 ceSize = ((long) Memory.peekInt(hdrBuf, LOCLEN - LOCVER, ByteOrder.LITTLE_ENDIAN)) & 0xffffffffL;
285 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"
375 NATIVE_METHOD(Memory, memmove, "(Ljava/lang/Object;ILjava/lang/Object;IJ)V"),
376 NATIVE_METHOD(Memory, peekByte, "!(J)B"),
377 NATIVE_METHOD(Memory, peekByteArray, "(J[BII)V"),
378 NATIVE_METHOD(Memory, peekCharArray, "(J[CIIZ)V"),
379 NATIVE_METHOD(Memory, peekDoubleArray, "(J[DIIZ)V"),
380 NATIVE_METHOD(Memory, peekFloatArray, "(J[FIIZ)V"),
381 NATIVE_METHOD(Memory, peekInt, "!(JZ)I"),
382 NATIVE_METHOD(Memory, peekIntArray, "(J[IIIZ)V"),
383 NATIVE_METHOD(Memory, peekLong, "!(JZ)J")
[all...] |
| /external/llvm/lib/Target/Mips/ |
| MipsJITInfo.cpp | 23 #include "llvm/Support/Memory.h"
34 // If the functions are in the same memory segment, insert PC-region branch.
47 sys::Memory::InvalidateInstructionCache(Old, 2 * 4);
70 sys::Memory::InvalidateInstructionCache(Old, 4 * 4);
186 sys::Memory::InvalidateInstructionCache((void*) StubAddr, 16);
206 if (!sys::Memory::setRangeWritable(Addr, 16))
237 sys::Memory::InvalidateInstructionCache(Addr, 16);
238 if (!sys::Memory::setRangeExecutable(Addr, 16))
|
| /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);
|
