| /ndk/sources/cxx-stl/llvm-libc++/libcxx/test/containers/container.adaptors/stack/stack.cons/ |
| ctor_move.pass.cpp | 10 // <stack>
12 // stack(stack&& q);
14 #include <stack>
36 std::stack<MoveOnly> q(make<std::deque<MoveOnly> >(5));
37 std::stack<MoveOnly> q2 = std::move(q);
|
| /ndk/sources/cxx-stl/llvm-libc++/libcxx/test/containers/container.adaptors/stack/stack.defn/ |
| assign_move.pass.cpp | 10 // <stack>
12 // stack& operator=(stack&& q);
14 #include <stack>
36 std::stack<MoveOnly> q(make<std::deque<MoveOnly> >(5));
37 std::stack<MoveOnly> q2;
|
| /sdk/emulator/qtools/ |
| check_stack.cpp | 45 class Stack {
51 Stack() {
60 void Stack::push(frame *pframe) {
62 fprintf(stderr, "Error: stack overflow\n");
69 frame *Stack::pop() {
76 Stack *mStacks[kMaxThreads];
121 // Get the stack for the current thread
122 Stack *mStack = mStacks[proc->pid];
124 // If the stack does not exist, then allocate a new one.
126 mStack = new Stack();
[all...] |
| read_method.cpp | 26 class Stack {
32 Stack() {
41 void Stack::push(frame *pframe) {
43 fprintf(stderr, "Error: stack overflow\n");
50 frame *Stack::pop() {
57 void Stack::dump() {
70 Stack *stacks[kMaxThreads];
115 // Get the stack for the current thread
116 Stack *pStack = stacks[proc->pid];
118 // If the stack does not exist, then allocate a new one
[all...] |
| /external/chromium_org/tools/deep_memory_profiler/tests/data/ |
| heap.01234.0001.heap | 8 stack 139264 131072
15 nonprofiled-stack 139264 131072
|
| /external/clang/test/CodeGen/ |
| 2002-02-13-UnnamedLocal.c | 4 * and did not have a VAR_DECL that explained the stack slot to LLVM.
5 * Now the LLVM code synthesizes a stack slot if one is presented that
|
| /external/clang/test/Index/ |
| annotate-deep-statements.cpp | 4 // Check that we don't get stack overflow trying to annotate an extremely deep AST.
6 // AddressSanitizer increases stack usage.
|
| /external/compiler-rt/lib/asan/lit_tests/TestCases/ |
| stack-frame-demangle.cc | 11 // CHECK: ERROR: AddressSanitizer: stack-buffer-overflow
13 // CHECK: is located in stack of thread T0 at offset
|
| stack-oob-frames.cc | 41 // CHECK0: AddressSanitizer: stack-buffer-overflow
46 // CHECK0: is located in stack of thread T0 at offset
49 // CHECK1: AddressSanitizer: stack-buffer-overflow
50 // CHECK1: is located in stack of thread T0 at offset
53 // CHECK2: AddressSanitizer: stack-buffer-overflow
54 // CHECK2: is located in stack of thread T0 at offset
57 // CHECK3: AddressSanitizer: stack-buffer-overflow
58 // CHECK3: is located in stack of thread T0 at offset
|
| use-after-scope.cc | 11 // CHECK: ERROR: AddressSanitizer: stack-use-after-scope
13 // CHECK: Address 0x{{.*}} is located in stack of thread T{{.*}} at offset [[OFFSET:[^ ]+]] in frame
|
| /external/valgrind/main/drd/tests/ |
| sem_as_mutex3.stderr.exp | 7 (thread finished, call stack no longer available)
9 (thread finished, call stack no longer available)
|
| sem_open3.stderr.exp | 7 (thread finished, call stack no longer available)
9 (thread finished, call stack no longer available)
|
| /external/valgrind/main/memcheck/tests/ |
| buflen_check.stderr.exp | 4 Address 0x........ is not stack'd, malloc'd or (recently) free'd
9 Address 0x........ is not stack'd, malloc'd or (recently) free'd
|
| /external/valgrind/main/none/tests/ |
| nestedfns.c | 4 modifying code on the stack, at least on x86 and amd64. It now
6 self-checking translations for translations taken from stack-like
|
| /external/apache-xml/src/main/java/org/apache/xml/utils/ |
| IntStack.java | 26 * Implement a stack of simple integers.
67 * Pushes an item onto the top of this stack.
69 * @param i the int to be pushed onto this stack.
94 * Removes the object at the top of this stack and returns that
97 * @return The object at the top of this stack.
105 * Quickly pops a number of items from the stack.
114 * Looks at the object at the top of this stack without removing it
115 * from the stack.
117 * @return the object at the top of this stack.
118 * @throws EmptyStackException if this stack is empty
[all...] |
| ObjectStack.java | 26 * Implement a stack of simple integers.
67 * Pushes an item onto the top of this stack.
69 * @param i the int to be pushed onto this stack.
94 * Removes the object at the top of this stack and returns that
97 * @return The object at the top of this stack.
108 * Quickly pops a number of items from the stack.
117 * Looks at the object at the top of this stack without removing it
118 * from the stack.
120 * @return the object at the top of this stack.
121 * @throws EmptyStackException if this stack is empty
[all...] |
| /external/chromium_org/chrome/browser/ui/panels/ |
| stacked_panel_collection.h | 75 // Returns the maximum available space from the bottom of the stack. The
77 // of the stack and the bottom of the working area, assuming that all inactive
97 // restoring it. When there're only 2 panels in the stack and the bottom
98 // panel is being dragged out of the stack, both panels will be moved to
100 // put it back to the same stack of the dragging panel.
110 // Returns the enclosing bounds that include all panels in the stack.
113 // Returns the work area where the stack resides. If the stack spans across
115 // intersects the stack.
128 // Returns the current available space above the top of the stack. The curren
[all...] |
| /external/chromium_org/tools/memory_watcher/ |
| memory_watcher.cc | 107 AllocationStack* stack = new AllocationStack(size);
108 if (!stack->Valid()) return; // Recursion blocked generation of stack.
119 #if 0 // Don't do this until stack->ToString() uses ONLY our heap.
123 // VLOG(1) << "First Stack size " << stack->size() << "was\n" << output;
124 stack->ToString(&output);
125 // VLOG(1) << "Second Stack size " << stack->size() << "was\n" << output;
128 // TODO(jar): We should delete one stack, and keep the other, perhap
161 AllocationStack* stack = it->second; local
210 AllocationStack* stack = block_it->second; local
246 CallStack* stack = stack_track->stack; local
[all...] |
| /development/samples/devbytes/animation/CardFlip/src/com/example/android/cardflip/ |
| CardFlip.java | 35 * these cards can be flipped from one stack to another where each flip comes with
37 * or right to left depending on which stack the animating card currently belongs to.
39 * This application demonstrates an animation where a stack of cards can either be
41 * Rotate out: Down fling on stack of cards
42 * Rotate in: Up fling on stack of cards
43 * Full rotation: Tap on stack of cards
47 * state, no new cards can be rotated to or from that stack. These changes were made to
113 * Adds a new card to the specified stack. Also performs all the necessary layout setup
116 public void addNewCard(int stack) {
118 view.updateTranslation(mStackCards.get(stack).size())
[all...] |
| /external/compiler-rt/lib/asan/ |
| asan_allocator.h | 44 void GetAllocStack(StackTrace *stack);
45 void GetFreeStack(StackTrace *stack);
105 void *asan_memalign(uptr alignment, uptr size, StackTrace *stack,
107 void asan_free(void *ptr, StackTrace *stack, AllocType alloc_type);
109 void *asan_malloc(uptr size, StackTrace *stack);
110 void *asan_calloc(uptr nmemb, uptr size, StackTrace *stack);
111 void *asan_realloc(void *p, uptr size, StackTrace *stack);
112 void *asan_valloc(uptr size, StackTrace *stack);
113 void *asan_pvalloc(uptr size, StackTrace *stack);
116 StackTrace *stack);
[all...] |
| /libcore/libdvm/src/main/java/dalvik/system/ |
| VMStack.java | 20 * Provides a limited interface to the Dalvik VM stack. This class is mostly
42 * Creates an array of classes from the methods at the top of the stack.
43 * We continue until we reach the bottom of the stack or exceed the
46 * The topmost stack frame (this method) and the one above that (the
57 * @return an array with classes for the most-recent methods on the stack
62 * Returns the first ClassLoader on the call stack that isn't either of
78 * Retrieves the stack trace from the specified thread.
82 * @return an array of stack trace elements, or null if the thread
83 * doesn't have a stack trace (e.g. because it exited)
88 * Retrieves a partial stack trace from the specified thread int
[all...] |
| /external/llvm/test/CodeGen/SystemZ/ |
| args-03.ll | 1 ; Test the handling of GPR, FPR and stack arguments when integers are
9 ; RUN: llc < %s -mtriple=s390x-linux-gnu | FileCheck %s -check-prefix=CHECK-STACK
21 ; The order of the CHECK-STACK stores doesn't matter. It would be OK to reorder
56 ; CHECK-STACK-LABEL: foo:
57 ; CHECK-STACK: aghi %r15, -256
58 ; CHECK-STACK: la [[REGISTER:%r[0-5]+]], {{224|240}}(%r15)
59 ; CHECK-STACK: stg [[REGISTER]], 216(%r15)
60 ; CHECK-STACK: llilf [[AT184:%r[0-5]+]], 4294967288
61 ; CHECK-STACK: stg [[AT184]], 184(%r15)
62 ; CHECK-STACK: llill [[AT176:%r[0-5]+]], 6552
[all...] |
| /external/openfst/src/include/fst/extensions/pdt/ |
| pdt.h | 37 // stack IDs. Each stack ID is unique to each distinct stack. The
46 // 'nodes_'. Each node represents the top of some stack and is
48 // the stack with the top 'popped' and its children are stored in
78 // Returns stack ID given the current stack ID (0 if empty) and
79 // label read. 'Pushes' onto a stack if the label is an open
80 // parenthesis, returning the new stack ID. 'Pops' the stack if th
[all...] |
| /external/chromium_org/third_party/WebKit/Source/wtf/ |
| StackStats.cpp | 64 dataLogF(" === LOG new stack stats ========\n");
69 const StackBounds& stack = wtfThreadData().stack(); local
71 m_stackStart = (char*)stack.origin();
82 const StackBounds& stack = threadData->stack(); local
88 // If there was no previous checkpoint, measure from the start of the stack:
99 // Update the stack height stats:
123 dataLogF(" CHECKPOINT %p diff %d/%.1fk/max %.1fk | reentry %d/max %d | height %.1fk/max %.1fk | stack %p size %.1fk\n",
127 stack.origin(), stack.size() / 1024.0)
143 const StackBounds& stack = threadData->stack(); local
162 const StackBounds& stack = threadData->stack(); local
217 const StackBounds& stack = threadData->stack(); local
[all...] |
| /external/chromium/base/ |
| stack_container.h | 14 // This allocator can be used with STL containers to provide a stack buffer
15 // from which to allocate memory and overflows onto the heap. This stack buffer
16 // would be allocated on the stack and allows us to avoid heap operations in
23 // based on our allocator will share the same stack buffer.
25 // This stack buffer implementation is very simple. The first allocation that
26 // fits in the stack buffer will use the stack buffer. Any subsequent
27 // allocations will not use the stack buffer, even if there is unused room.
29 // be sure to reserve() in the container up to the stack buffer size. Otherwise
30 // the container will allocate a small array which will "use up" the stack
[all...] |
