| /art/cmdline/ |
| memory_representation.h | 28 // An integral representation of bytes of memory.
31 struct Memory {
34 static Memory<kDivisor> FromBytes(size_t bytes) {
36 return Memory<kDivisor>(bytes);
39 Memory() : Value(0u) {}
40 Memory(size_t value) : Value(value) { // NOLINT [runtime/explicit] [5]
52 str = "Memory<" + std::to_string(kDivisor) + '>';
62 std::ostream& operator<<(std::ostream& stream, Memory<kDivisor> memory) {
63 return stream << memory.Value << '*' << kDivisor
[all...] |
| /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...] |
| /external/v8/src/arm/ |
| assembler-arm-inl.h | 79 Assembler::IsMovW(Memory::int32_at(pc_))) {
85 DCHECK(Assembler::IsLdrPcImmediateOffset(Memory::int32_at(pc_)));
153 return Memory::Address_at(pc_);
180 Address address = Memory::Address_at(pc_);
187 return Cell::FromValueAddress(Memory::Address_at(pc_));
196 Memory::Address_at(pc_) = address;
216 Memory::Address_at(pc_ +
224 Memory::Address_at(pc_ +
234 return Memory::Address_at(pc_ + Assembler::kPatchDebugBreakSlotAddressOffset);
240 Memory::Address_at(pc_ + Assembler::kPatchDebugBreakSlotAddressOffset)
[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);
|
| /external/llvm/include/llvm/IR/ |
| PredIteratorCache.h | 33 /// Memory - This is the space that holds cached preds.
34 BumpPtrAllocator Memory;
53 Entry = Memory.Allocate<BasicBlock *>(PredCache.size());
73 Memory.Reset();
|
| /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/curl/src/macos/src/ |
| macos_main.cpp | 19 /* =========================================================================
Copyright (C) 2001 Eric Lavigne
Permission is granted to anyone to use this software for any purpose on any
computer system, and to redistribute it freely, subject to the following
restrictions:
- The author is not responsible for the consequences of use of this
software, no matter how awful, even if they arise from defects in it.
- The origin of this software must not be misrepresented, either by
explicit claim or by omission.
- You are allowed to distributed modified copies of the software, in source
and binary form, provided they are marked plainly as altered versions, and
are not misrepresented as being the original software.
========================================================================= */
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <Memory.h>
#include <GUSICommandLine.h>
#include <stdlib.h>
/* ========================================== (…)
|
| /libcore/ojluni/src/main/java/java/nio/ |
| DirectByteBuffer.java | 32 import libcore.io.Memory;
41 * Stores the details of the memory backing a DirectByteBuffer. This could be a pointer
44 * whether the underlying memory is "accessible". The notion of "accessibility" is usually
46 * memory as defined by the underlying system.
190 return Memory.peekByte(a);
218 Memory.peekByteArray(ix(pos),
225 Memory.pokeByte(a, x);
265 Memory.pokeByteArray(ix(pos),
309 return (char) Memory.peekShort(position, !nativeByteOrder);
320 char x = (char) Memory.peekShort(ix(position), !nativeByteOrder)
[all...] |
| HeapByteBuffer.java | 31 import libcore.io.Memory;
201 Memory.unsafeBulkGet(dst, dstOffset, length * 2, hb, ix(pos), 2, !nativeByteOrder);
225 Memory.unsafeBulkPut(hb, ix(pos), length * 2, src, srcOffset, 2, !nativeByteOrder);
253 Memory.unsafeBulkGet(dst, dstOffset, length * 2, hb, ix(pos), 2, !nativeByteOrder);
277 Memory.unsafeBulkPut(hb, ix(pos), length * 2, src, srcOffset, 2, !nativeByteOrder);
305 Memory.unsafeBulkGet(dst, dstOffset, length * 4, hb, ix(pos), 4, !nativeByteOrder);
329 Memory.unsafeBulkPut(hb, ix(pos), length * 4, src, srcOffset, 4, !nativeByteOrder);
358 Memory.unsafeBulkGet(dst, dstOffset, length * 8, hb, ix(pos), 8, !nativeByteOrder);
382 Memory.unsafeBulkPut(hb, ix(pos), length * 8, src, srcOffset, 8, !nativeByteOrder);
410 Memory.unsafeBulkGet(dst, dstOffset, length * 4, hb, ix(pos), 4, !nativeByteOrder)
[all...] |
| /external/webrtc/webrtc/modules/audio_device/mac/portaudio/ |
| pa_memorybarrier.h | 4 * Memory barrier utilities
49 * Some memory barrier primitives based on the system.
51 * memory barriers, these functions should ensure that data cached in registers
65 /* Here are the memory barrier functions. Mac OS X only provides
66 full memory barriers, so the three types of barriers are the same,
77 /* as a fallback, GCC understands volatile asm and "memory" to mean it
78 * should not reorder memory read/writes */
82 # define PaUtil_FullMemoryBarrier() asm volatile("sync":::"memory")
83 # define PaUtil_ReadMemoryBarrier() asm volatile("sync":::"memory")
84 # define PaUtil_WriteMemoryBarrier() asm volatile("sync":::"memory")
[all...] |
| /toolchain/binutils/binutils-2.25/gas/testsuite/gas/cris/ |
| bound-err-1.s | 4 ; Memory operand for bound didn't make it to v32. Check that
|
| /external/llvm/lib/Target/X86/AsmParser/ |
| X86Operand.h | 30 Memory
108 assert(Kind == Memory && "Invalid access!");
112 assert(Kind == Memory && "Invalid access!");
116 assert(Kind == Memory && "Invalid access!");
120 assert(Kind == Memory && "Invalid access!");
124 assert(Kind == Memory && "Invalid access!");
128 assert(Kind == Memory && "Invalid access!");
208 bool isMem() const override { return Kind == Memory; }
210 return Kind == Memory && Mem.Size == 0;
213 return Kind == Memory && (!Mem.Size || Mem.Size == 8)
[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/v8/src/ |
| frames-inl.h | 46 return FromAddress(Memory::Address_at(address() + offset));
108 return Memory::Object_at(GetExpressionAddress(index));
113 Memory::Object_at(GetExpressionAddress(index)) = value;
119 Object* maybe_result = Memory::Object_at(fp() + offset);
126 return Memory::Address_at(fp() + StandardFrameConstants::kCallerFPOffset);
131 return Memory::Address_at(ComputePCAddress(fp()));
147 Memory::Object_at(fp + TypedFrameConstants::kFrameTypeOffset);
154 Memory::Object_at(fp + TypedFrameConstants::kFrameTypeOffset);
170 return Memory::Object_at(GetParameterSlot(index));
186 return Memory::Object_at(GetOperandSlot(index))
[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);
|
| /external/llvm/lib/ExecutionEngine/ |
| SectionMemoryManager.cpp | 1 //===- SectionMemoryManager.cpp - Memory manager for MCJIT/RtDyld *- C++ -*-==//
10 // This file implements the section-based memory manager used by the MCJIT
50 // Look in the list of free memory regions and use a block there if one
77 // No pre-allocated free block was large enough. Allocate a new memory region.
79 // be updated later based on memory group.
84 // FIXME: Initialize the Near member for each memory group to avoid
87 sys::MemoryBlock MB = sys::Memory::allocateMappedMemory(RequiredSize,
89 sys::Memory::MF_READ |
90 sys::Memory::MF_WRITE,
100 // Remember that we allocated this memory
[all...] |
| /libcore/luni/src/main/native/ |
| libcore_io_Memory.cpp | 17 #define LOG_TAG "Memory"
291 NATIVE_METHOD(Memory, memmove, "(Ljava/lang/Object;ILjava/lang/Object;IJ)V"),
292 NATIVE_METHOD(Memory, peekByte, "!(J)B"),
293 NATIVE_METHOD(Memory, peekByteArray, "(J[BII)V"),
294 NATIVE_METHOD(Memory, peekCharArray, "(J[CIIZ)V"),
295 NATIVE_METHOD(Memory, peekDoubleArray, "(J[DIIZ)V"),
296 NATIVE_METHOD(Memory, peekFloatArray, "(J[FIIZ)V"),
297 NATIVE_METHOD(Memory, peekIntNative, "!(J)I"),
298 NATIVE_METHOD(Memory, peekIntArray, "(J[IIIZ)V"),
299 NATIVE_METHOD(Memory, peekLongNative, "!(J)J")
[all...] |
| /external/llvm/lib/ExecutionEngine/Orc/ |
| OrcTargetSupport.cpp | 129 // Allocate memory for stubs and pointers in one call.
133 sys::Memory::allocateMappedMemory(2 * NumPages * PageSize, nullptr,
134 sys::Memory::MF_READ |
135 sys::Memory::MF_WRITE,
154 if (auto EC = sys::Memory::protectMappedMemory(StubsBlock,
155 sys::Memory::MF_READ |
156 sys::Memory::MF_EXEC))
|
| /external/llvm/include/llvm/ExecutionEngine/Orc/ |
| IndirectionUtils.h | 152 sys::Memory::allocateMappedMemory(TargetT::ResolverCodeSize, nullptr,
153 sys::Memory::MF_READ |
154 sys::Memory::MF_WRITE, EC));
160 EC = sys::Memory::protectMappedMemory(ResolverBlock.getMemoryBlock(),
161 sys::Memory::MF_READ |
162 sys::Memory::MF_EXEC);
182 sys::Memory::allocateMappedMemory(TargetT::PageSize, nullptr,
183 sys::Memory::MF_READ |
184 sys::Memory::MF_WRITE, EC));
200 EC = sys::Memory::protectMappedMemory(TrampolineBlock.getMemoryBlock()
[all...] |
| /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.
37 void *Address; ///< Address of first byte of memory area
38 size_t Size; ///< Size, in bytes of the memory are
[all...] |
| /external/pdfium/tools/drmemory/scripts/ |
| pdfium_tests.bat | 9 :: Set up DRMEMORY_COMMAND to invoke Dr. Memory {{{1
13 echo "Can't find Dr. Memory executables."
14 echo "See http://www.chromium.org/developers/how-tos/using-valgrind/dr-memory"
|
| /frameworks/base/wifi/java/android/net/wifi/nan/ |
| TlvBufferUtils.java | 19 import libcore.io.Memory;
191 Memory.pokeShort(mArray, mPosition, data, ByteOrder.BIG_ENDIAN);
209 Memory.pokeInt(mArray, mPosition, data, ByteOrder.BIG_ENDIAN);
266 Memory.pokeShort(mArray, mPosition, (short) type, ByteOrder.BIG_ENDIAN);
273 Memory.pokeShort(mArray, mPosition, (short) length, ByteOrder.BIG_ENDIAN);
343 return Memory.peekShort(mRefArray, mOffset, ByteOrder.BIG_ENDIAN);
358 return Memory.peekInt(mRefArray, mOffset, ByteOrder.BIG_ENDIAN);
466 type = Memory.peekShort(mArray, mOffset, ByteOrder.BIG_ENDIAN);
474 length = Memory.peekShort(mArray, mOffset, ByteOrder.BIG_ENDIAN);
|
| /external/google-breakpad/src/processor/ |
| synth_minidump.h | 38 // streams, memory regions, strings, and so on --- each is a Section
39 // that eventually gets appended to the minidump. Dump, Memory,
46 // using google_breakpad::SynthMinidump::Memory;
51 // Memory stack1(minidump, 0x569eb0a9);
91 // the stream directory; memory ranges should be listed in the
92 // memory list; threads should be placed in the thread list; and so
98 // references to a Memory and a Context, it does not add them to the
101 // cited from more than one place; for example, Memory ranges are
103 // memory list stream.
132 class Memory;
[all...] |
| /external/v8/src/x64/ |
| 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;
270 return Memory::int32_at(pc) + pc + 4;
277 Memory::int32_at(pc) = static_cast<int32_t>(target - pc - 4);
286 Memory::Address_at(pc) = target;
296 return code_targets_[Memory::int32_at(pc)];
301 return Memory::int32_at(pc) +
311 Memory::int32_at(pc_) -= static_cast<int32_t>(delta)
[all...] |
| /libcore/ojluni/src/main/java/java/io/ |
| DataInputStream.java | 29 import libcore.io.Memory;
318 return Memory.peekShort(readBuffer, 0, ByteOrder.BIG_ENDIAN);
342 return Memory.peekShort(readBuffer, 0, ByteOrder.BIG_ENDIAN) & 0xffff;
366 return (char)Memory.peekShort(readBuffer, 0, ByteOrder.BIG_ENDIAN);
390 return Memory.peekInt(readBuffer, 0, ByteOrder.BIG_ENDIAN);
|
