| /external/chromium_org/v8/src/x64/ |
| frames-x64.h | 106 return Memory::Object_at(fp() + offset);
113 Memory::Address_at(slot + kPointerSize) = 0;
115 Memory::Address_at(slot) = fp;
|
| assembler-x64-inl.h | 30 Memory::uint32_at(pc_) = x;
37 Memory::uintptr_at(pc_) = value;
46 Memory::uint64_at(pc_) = x;
52 Memory::uint16_at(pc_) = x;
189 return Memory::int32_at(pc) + pc + 4;
197 Memory::int32_at(pc) = static_cast<int32_t>(target - pc - 4);
215 return code_targets_[Memory::int32_at(pc)];
220 return Memory::int32_at(pc) + isolate()->code_range()->start();
231 Memory::Address_at(pc_) += static_cast<int32_t>(delta);
234 Memory::int32_at(pc_) -= static_cast<int32_t>(delta)
[all...] |
| /external/llvm/tools/lli/ |
| RemoteTarget.cpp | 18 #include "llvm/Support/Memory.h"
27 // This implementation will simply move generated code and data to a new memory
34 sys::MemoryBlock Mem = sys::Memory::AllocateRWX(Size, Prev, &ErrorMsg);
38 ErrorMsg = "unable to allocate sufficiently aligned memory";
54 sys::Memory::setExecutable(Mem, &ErrorMsg);
70 sys::Memory::ReleaseRWX(Allocations[i]);
|
| /external/llvm/lib/Target/ARM/ |
| ARMJITInfo.cpp | 23 #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/llvm/lib/Target/X86/AsmParser/ |
| X86Operand.h | 27 Memory
104 assert(Kind == Memory && "Invalid access!");
108 assert(Kind == Memory && "Invalid access!");
112 assert(Kind == Memory && "Invalid access!");
116 assert(Kind == Memory && "Invalid access!");
120 assert(Kind == Memory && "Invalid access!");
207 bool isMem() const override { return Kind == Memory; }
209 return Kind == Memory && (!Mem.Size || Mem.Size == 8);
212 return Kind == Memory && (!Mem.Size || Mem.Size == 16);
215 return Kind == Memory && (!Mem.Size || Mem.Size == 32)
[all...] |
| /frameworks/base/core/java/android/os/ |
| FileBridge.java | 28 import libcore.io.Memory;
98 final int cmd = Memory.peekInt(temp, 0, ByteOrder.BIG_ENDIAN);
101 int len = Memory.peekInt(temp, 4, ByteOrder.BIG_ENDIAN);
164 Memory.pokeInt(mTemp, 0, cmd, ByteOrder.BIG_ENDIAN);
169 if (Memory.peekInt(mTemp, 0, ByteOrder.BIG_ENDIAN) == cmd) {
180 Memory.pokeInt(mTemp, 0, CMD_WRITE, ByteOrder.BIG_ENDIAN);
181 Memory.pokeInt(mTemp, 4, byteCount, ByteOrder.BIG_ENDIAN);
|
| /libcore/luni/src/main/java/java/util/zip/ |
| ZipInputStream.java | 27 import libcore.io.Memory;
189 int sig = Memory.peekInt(hdrBuf, 0, ByteOrder.LITTLE_ENDIAN);
193 currentEntry.crc = ((long) Memory.peekInt(hdrBuf, EXTCRC, ByteOrder.LITTLE_ENDIAN)) & 0xffffffffL;
194 currentEntry.compressedSize = ((long) Memory.peekInt(hdrBuf, EXTSIZ, ByteOrder.LITTLE_ENDIAN)) & 0xffffffffL;
195 currentEntry.size = ((long) Memory.peekInt(hdrBuf, EXTLEN, ByteOrder.LITTLE_ENDIAN)) & 0xffffffffL;
219 int hdr = Memory.peekInt(hdrBuf, 0, ByteOrder.LITTLE_ENDIAN);
245 ceCrc = ((long) Memory.peekInt(hdrBuf, LOCCRC - LOCVER, ByteOrder.LITTLE_ENDIAN)) & 0xffffffffL;
246 ceCompressedSize = ((long) Memory.peekInt(hdrBuf, LOCSIZ - LOCVER, ByteOrder.LITTLE_ENDIAN)) & 0xffffffffL;
247 ceSize = ((long) Memory.peekInt(hdrBuf, LOCLEN - LOCVER, ByteOrder.LITTLE_ENDIAN)) & 0xffffffffL;
290 return Memory.peekShort(hdrBuf, offset, ByteOrder.LITTLE_ENDIAN) & 0xffff
[all...] |
| /libcore/luni/src/main/native/ |
| libcore_io_Memory.cpp | 17 #define LOG_TAG "Memory"
355 NATIVE_METHOD(Memory, memmove, "(Ljava/lang/Object;ILjava/lang/Object;IJ)V"),
356 NATIVE_METHOD(Memory, peekByte, "!(J)B"),
357 NATIVE_METHOD(Memory, peekByteArray, "(J[BII)V"),
358 NATIVE_METHOD(Memory, peekCharArray, "(J[CIIZ)V"),
359 NATIVE_METHOD(Memory, peekDoubleArray, "(J[DIIZ)V"),
360 NATIVE_METHOD(Memory, peekFloatArray, "(J[FIIZ)V"),
361 NATIVE_METHOD(Memory, peekIntNative, "!(J)I"),
362 NATIVE_METHOD(Memory, peekIntArray, "(J[IIIZ)V"),
363 NATIVE_METHOD(Memory, peekLongNative, "!(J)J")
[all...] |
| /external/llvm/lib/Target/Mips/ |
| MipsJITInfo.cpp | 22 #include "llvm/Support/Memory.h"
35 // If the functions are in the same memory segment, insert PC-region branch.
48 sys::Memory::InvalidateInstructionCache(Old, 2 * 4);
71 sys::Memory::InvalidateInstructionCache(Old, 4 * 4);
187 sys::Memory::InvalidateInstructionCache((void*) StubAddr, 16);
207 if (!sys::Memory::setRangeWritable(Addr, 16))
238 sys::Memory::InvalidateInstructionCache(Addr, 16);
239 if (!sys::Memory::setRangeExecutable(Addr, 16))
|
| /external/chromium_org/base/memory/ |
| discardable_memory.h | 14 #include "base/memory/scoped_ptr.h"
32 // Platform abstraction for discardable memory. DiscardableMemory is used to
33 // cache large objects without worrying about blowing out memory, both on mobile
34 // devices where there is no swap, and desktop devices where unused free memory
36 // memory in response to an OOM signal because it is simpler, though it has less
39 // Discardable memory has two states: locked and unlocked. While the memory is
40 // locked, it will not be discarded. Unlocking the memory allows the OS to
44 // - The paging behavior of memory while it is locked is not specified. While
48 // memory, use it as quickly as possible, and then unlock it
[all...] |
| discardable_memory_ashmem.h | 8 #include "base/memory/discardable_memory.h"
11 #include "base/memory/discardable_memory_manager.h"
35 virtual void* Memory() const OVERRIDE;
|
| /external/chromium_org/chrome/browser/extensions/api/system_memory/ |
| system_memory_apitest.cc | 40 IN_PROC_BROWSER_TEST_F(SystemMemoryApiTest, Memory) {
44 ASSERT_TRUE(RunExtensionTest("system/memory")) << message_;
|
| /external/chromium_org/ppapi/tests/ |
| test_memory.cc | 18 REGISTER_TEST_CASE(Memory);
|
| /external/chromium_org/skia/ext/ |
| SkDiscardableMemory_chrome.cc | 24 return discardable_->Memory();
32 scoped_ptr<base::DiscardableMemory> memory)
33 : discardable_(memory.Pass()) {
|
| /external/chromium_org/v8/src/arm/ |
| frames-arm.cc | 40 return Memory::Object_at(fp() + offset);
|
| frames-arm.h | 151 return Memory::Object_at(fp() + offset);
156 Memory::Address_at(slot) = fp;
|
| /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);
|
| /external/chromium_org/tools/perf/measurements/ |
| memory.py | 5 from metrics import memory namespace
9 class Memory(page_test.PageTest):
11 super(Memory, self).__init__('RunStressMemory')
19 self._memory_metric = memory.MemoryMetric(browser)
26 memory.MemoryMetric.CustomizeBrowserOptions(options)
27 # Since this is a memory benchmark, we want to sample memory histograms at
29 options.AppendExtraBrowserArgs('--memory-metrics')
|
| /external/chromium_org/v8/src/arm64/ |
| frames-arm64.h | 98 return Memory::Object_at(fp() + offset);
103 Memory::Address_at(slot) = fp;
|
| /external/chromium_org/v8/src/ia32/ |
| frames-ia32.h | 114 return Memory::Object_at(fp() + offset);
119 Memory::Address_at(slot) = fp;
|
| /external/chromium_org/v8/src/mips/ |
| frames-mips.h | 204 return Memory::Object_at(fp() + offset);
209 Memory::Address_at(slot) = fp;
|
| /external/chromium_org/v8/src/mips64/ |
| frames-mips64.h | 204 return Memory::Object_at(fp() + offset);
209 Memory::Address_at(slot) = fp;
|
| /external/chromium_org/v8/src/x87/ |
| frames-x87.h | 114 return Memory::Object_at(fp() + offset);
119 Memory::Address_at(slot) = fp;
|
| /external/llvm/include/llvm/Support/ |
| 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...] |
