| /ndk/sources/cxx-stl/llvm-libc++/libcxx/test/containers/container.adaptors/stack/stack.cons.alloc/ |
| ctor_rqueue_alloc.pass.cpp | 10 // <stack>
13 // stack(stack&& q, const Alloc& a);
15 #include <stack>
37 : public std::stack<T, C>
39 typedef std::stack<T, C> base;
|
| /ndk/sources/host-tools/ndk-stack/ |
| ndk-stack.c | 14 * Contains implementation of main routine for ndk-stack utility.
22 #include "ndk-stack-parser.h"
27 " ndk-stack -sym <path> [-dump <path>]\n\n"
30 " This is an optional parameter. If ommited, ndk-stack will\n"
33 " See docs/NDK-STACK.html in your NDK installation tree for more details.\n\n";
88 fprintf(stderr, "Unable to create NDK stack parser: %s\n",
|
| /prebuilts/python/darwin-x86/2.7.5/lib/python2.7/ |
| pickle.py | 102 MARK = '(' # push special markobject on stack
104 POP = '0' # discard topmost stack item
105 POP_MARK = '1' # discard stack top through topmost markobject
106 DUP = '2' # duplicate top stack item
115 BINPERSID = 'Q' # " " " ; " " " " stack
116 REDUCE = 'R' # apply callable to argtuple, both on stack
122 APPEND = 'a' # append stack top to list below it
125 DICT = 'd' # build a dict from stack items
127 APPENDS = 'e' # extend list on stack by topmost stack slic
[all...] |
| /prebuilts/python/linux-x86/2.7.5/lib/python2.7/ |
| pickle.py | 102 MARK = '(' # push special markobject on stack
104 POP = '0' # discard topmost stack item
105 POP_MARK = '1' # discard stack top through topmost markobject
106 DUP = '2' # duplicate top stack item
115 BINPERSID = 'Q' # " " " ; " " " " stack
116 REDUCE = 'R' # apply callable to argtuple, both on stack
122 APPEND = 'a' # append stack top to list below it
125 DICT = 'd' # build a dict from stack items
127 APPENDS = 'e' # extend list on stack by topmost stack slic
[all...] |
| /external/compiler-rt/lib/sanitizer_common/ |
| sanitizer_stackdepot.cc | 34 uptr stack[1]; // [size] member in struct:__sanitizer::StackDesc
51 static u32 hash(const uptr *stack, uptr size) {
58 u32 k = stack[i];
101 uptr mem = (uptr)MmapOrDie(allocsz, "stack depot");
108 static u32 find(StackDesc *s, const uptr *stack, uptr size, u32 hash) {
109 // Searches linked list s for the stack, returns its id.
114 if (stack[i] != s->stack[i])
144 u32 StackDepotPut(const uptr *stack, uptr size) {
145 if (stack == 0 || size == 0
[all...] |
| sanitizer_stacktrace.cc | 73 // PCs in stack traces are actually the return addresses, that is,
76 uptr addr_frames_num = 0; // The number of stack frames for current
137 if (stack_top < 4096) return; // Sanity check for stack top.
161 // On 32-bits we don't compress stack traces.
162 // On 64-bits we compress stack traces: if a given pc differes slightly from
165 uptr StackTrace::CompressStack(StackTrace *stack, u32 *compressed, uptr size) {
169 for (uptr i = 0; i < stack->size && i < size; i++) {
170 compressed[i] = stack->trace[i];
173 if (stack->size < size)
174 compressed[stack->size] = 0
[all...] |
| /dalvik/vm/alloc/ |
| MarkSweep.cpp | 41 * Initializes the stack top and advises the mark stack pages as needed.
43 static bool createMarkStack(GcMarkStack *stack)
45 assert(stack != NULL);
48 madvise(stack->base, length, MADV_NORMAL);
49 stack->top = stack->base;
54 * Assigns NULL to the stack top and advises the mark stack pages as
57 static void destroyMarkStack(GcMarkStack *stack)
476 GcMarkStack *stack = &ctx->stack; local
[all...] |
| /external/chromium_org/v8/test/mjsunit/ |
| stack-traces.js | 127 // in the stack trace produced when running the given function.
134 assertTrue(e.stack.indexOf(expected[i]) != -1,
135 name + " doesn't contain expected[" + i + "] stack = " + e.stack);
139 assertEquals(e.stack.indexOf(unexpected[i]), -1,
154 assertEquals(-1, e.stack.indexOf('at new ReferenceError'),
171 assertTrue(e.stack.indexOf('at new ReferenceError') != -1,
178 // If an error occurs while the stack trace is being formatted it should
190 assertTrue(e.stack.indexOf('<error: ReferenceError') != -1,
196 // the stack frame. Put that in your pipe and smoke it
[all...] |
| /external/bison/lib/ |
| timevar.c | 146 /* If this variable is timed independently of the timing stack,
158 the timing stack. */
162 /* An element on the timing stack. Elapsed time is attributed to the
163 topmost timing variable on the stack. */
167 /* The timing variable at this stack level. */
170 /* The next lower timing variable context in the stack. */
178 /* The top of the timing stack. */
179 static struct timevar_stack_def *stack; variable in typeref:struct:timevar_stack_def
185 /* The time at which the topmost element on the timing stack was
276 /* Push TIMEVAR onto the timing stack. No further elapsed time i
[all...] |
| /external/chromium/chrome/browser/ui/cocoa/ |
| animation_utils.h | 11 // This class is a stack-based helper useful for unit testing of Cocoa UI,
15 // this goes out of scope and pops our state off the Core Animation stack.
|
| /external/chromium_org/chrome/browser/resources/ntp4/ |
| logging.js | 10 /* Stack of events that has been logged. */
18 * stack.
|
| /external/chromium_org/third_party/skia/src/animator/ |
| thingstodo.txt | 3 at these points, generate an error if actual physical stack gets too large
6 ((((( operator precedence or similar making stack deep
|
| /external/chromium_org/tools/deep_memory_profiler/tests/data/ |
| heap.01234.0002.heap | 8 stack 1789952 1789952
15 nonprofiled-stack 1789952 1789952
|
| /external/chromium_org/v8/test/mjsunit/regress/ |
| regress-798.js | 35 assertEquals(3, e.stack.split('\n').length);
44 assertEquals(3, e.stack.split('\n').length);
53 assertEquals(3, e.stack.split('\n').length);
62 assertEquals(3, e.stack.split('\n').length);
75 assertEquals(3, e.stack.split('\n').length);
83 assertEquals(3, e.stack.split('\n').length);
90 // Check that the stack for an exception in a getter and setter produce the
91 // expected stack height.
|
| /external/chromium_org/webkit/browser/fileapi/ |
| remove_operation_delegate.h | 8 #include <stack>
39 std::stack<FileSystemURL> to_remove_directories_;
|
| /external/clang/lib/CodeGen/ |
| EHScopeStack.h | 1 //===-- EHScopeStack.h - Stack for cleanup IR generation --------*- C++ -*-===//
88 /// A stack of scopes which respond to exceptions, including cleanups
92 /// A saved depth on the scope stack. This is necessary because
93 /// pushing scopes onto the stack invalidates iterators.
129 /// allocated on the cleanup stack and freely copied and moved
263 /// The start of the scope-stack buffer, i.e. the allocated pointer
274 /// The innermost normal cleanup on the stack.
277 /// The innermost EH scope on the stack.
282 /// know the EH stack depth. Whenever we pop a cleanup, we have
311 /// Push a lazily-created cleanup on the stack
[all...] |
| /external/compiler-rt/lib/msan/lit_tests/ |
| getaddrinfo.cc | 10 // With -O0 this poisons a large chunk of stack.
20 // stack-allocated buffer, which is very likely to be poisoned. Test that we
|
| /external/eigen/doc/ |
| D03_WrongStackAlignment.dox | 3 /** \page TopicWrongStackAlignment Compiler making a wrong assumption on stack alignment
20 GCC assumes that the stack is already 16-byte-aligned so that the object \a q will be created at a 16-byte-aligned location. For this reason, it doesn't take any special care to explicitly align the object \a q, as Eigen requires.
22 The problem is that, in some particular cases, this assumption can be wrong on Windows, where the stack is only guaranteed to have 4-byte alignment. Indeed, even though GCC takes care of aligning the stack in the main function and does its best to keep it aligned, when a function is called from another thread or from a binary compiled with another compiler, the stack alignment can be corrupted. This results in the object 'q' being created at an unaligned location, making your program crash with the \ref TopicUnalignedArrayAssert "assertion on unaligned arrays". So far we found the three following solutions.
35 Read <a href="http://gcc.gnu.org/onlinedocs/gcc-4.4.0/gcc/Function-Attributes.html#Function-Attributes">this GCC documentation</a> to understand what this does. Of course this should only be done on GCC on Windows, so for portability you'll have to encapsulate this in a macro which you leave empty on other platforms. The advantage of this solution is that you can finely select which function might have a corrupted stack alignment. Of course on the downside this has to be done for every such function, so you may prefer one of the following two global solutions.
42 -mincoming-stack-boundary=2
44 Explanation: this tells GCC that the stack is only required to be aligned to 2^2=4 bytes, so that GCC now knows that it really must take extra care to honor the 16 byte alignment of \ref TopicFixedSizeVectorizable "fixed-size vectorizable Eigen types" when needed.
|
| /external/llvm/include/llvm/CodeGen/ |
| LiveStackAnalysis.h | 1 //===-- LiveStackAnalysis.h - Live Stack Slot Analysis ----------*- C++ -*-===//
10 // This file implements the live stack slot analysis pass. It is analogous to
11 // live interval analysis except it's analyzing liveness of stack slots rather
34 /// S2IMap - Stack slot indices to live interval mapping.
39 /// S2RCMap - Stack slot indices to register class mapping.
62 assert(I != S2IMap.end() && "Interval does not exist for stack slot");
69 assert(I != S2IMap.end() && "Interval does not exist for stack slot");
82 "Register class info does not exist for stack slot");
|
| /external/llvm/test/CodeGen/ARM/ |
| 2013-04-16-AAPCS-C4-vs-VFP.ll | 6 ;Co-Processor register candidates may be either in VFP or in stack, so after
7 ;all VFP are allocated, stack is used. We can use stack without GPR allocation
9 ;First eight params goes to d0-d7, ninth one goes to the stack.
72 double %p8, ; --> Stack
73 i32 %p9) #0 { ; --> R0, not Stack+8
91 double 23.8, ; --> Stack
92 i32 43) ; --> R0, not Stack+8
|
| indirect-reg-input.ll | 9 define void @switch_to_stack(%struct.my_stack* %stack) nounwind {
11 %regs = getelementptr inbounds %struct.my_stack* %stack, i32 0, i32 0
|
| /external/llvm/test/CodeGen/Mips/ |
| eh-return32.ll | 15 ; check that $a0-$a3 are saved on stack.
27 ; check that stack adjustment and handler are put in $v1 and $v0.
33 ; check that $a0-$a3 are restored from stack.
39 ; check that stack is adjusted by $v1 and that code returns to address in $v0
56 ; check that $a0-$a3 are saved on stack.
68 ; check that stack adjustment and handler are put in $v1 and $v0.
72 ; check that $a0-$a3 are restored from stack.
78 ; check that stack is adjusted by $v1 and that code returns to address in $v0
|
| eh-return64.ll | 15 ; check that $a0-$a3 are saved on stack.
27 ; check that stack adjustment and handler are put in $v1 and $v0.
33 ; check that $a0-$a3 are restored from stack.
39 ; check that stack is adjusted by $v1 and that code returns to address in $v0
59 ; check that $a0-$a3 are saved on stack.
71 ; check that stack adjustment and handler are put in $v1 and $v0.
75 ; check that $a0-$a3 are restored from stack.
81 ; check that stack is adjusted by $v1 and that code returns to address in $v0
|
| /external/llvm/test/CodeGen/X86/ |
| tailcall-largecode.ll | 17 ; Adjust the stack to enter the function. (The amount of the
19 ; the stack argument and the return adjustment will change too.)
24 ; Pass the stack argument.
33 ; Adjust the stack to "return".
46 ; Adjust the stack to enter the function. (The amount of the
48 ; the stack argument and the return adjustment will change too.)
50 ; Pass the stack argument.
64 ; Adjust the stack to "return".
|
| tailcall-stackalign.ll | 2 ; Linux has 8 byte alignment so the params cause stack size 20 when tailcallopt
3 ; is enabled, ensure that a normal fastcc call has matching stack size
|
