| /external/compiler-rt/BlocksRuntime/tests/ |
| macro.c | 8 #include <Block.h>
|
| byrefcopy.c | 15 #include <Block.h>
27 void (^block)(void) = ^{ ++i; };
28 //printf("original (old style) is %s\n", _Block_dump_old(block));
29 //printf("original (new style) is %s\n", _Block_dump(block));
30 void (^blockcopy)(void) = Block_copy(block);
33 callVoidVoid(block);
|
| byrefcopyinner.c | 7 #include <Block.h>
|
| byrefcopystack.c | 17 #include <Block.h>
|
| copynull.c | 16 #import <Block.h>
23 void (^block)(void) = (void (^)(void))0;
24 void (^blockcopy)(void) = Block_copy(block);
|
| dispatch_call_Block_with_release.c | 8 #include <Block.h>
16 dispatch_call_Block_with_release2(void *block)
18 void (^b)(void) = (void (^)(void))block;
25 void (^b2)(void) = ^{ callsomething("hellow world\n", 0); }; // global block now
|
| rdar6414583.c | 11 #include <Block.h>
22 dispatch_block_t block = Block_copy(^{ c = i; }); local
24 block();
27 Block_release(block);
|
| recursiveassign.c | 21 #include <Block.h>
26 __block void (^recursive_copy_block)(int) = ^(int arg) { printf("got wrong Block\n"); exit(1); };
|
| blockimport.c | 21 #include <Block.h>
38 //printf("Block dump %s\n", _Block_dump(vv));
|
| globalexpression.c | 10 #import <Block.h>
|
| byrefcopycopy.c | 12 #include <Block.h>
|
| byrefcopyint.c | 27 #include <Block.h>
|
| /external/skia/include/core/ |
| SkChunkAlloc.h | 43 success, the number of bytes freed is returned, or 0 if the block could
60 struct Block;
61 Block* fBlock;
63 Block* fPool;
66 Block* newBlock(size_t bytes, AllocFailType ftype);
|
| SkWriter32.h | 35 * Returns the single block backing the writer, or NULL if the memory is
41 * Specify the single block to back the writer, rathern than dynamically
42 * allocating the memory. If block == NULL, then the writer reverts to
45 void reset(void* block, size_t size);
91 // if we could query how much is avail in the current block, we might
93 // in the current block
140 struct Block;
141 Block* fHead;
142 Block* fTail;
144 Block* newBlock(size_t bytes)
[all...] |
| /external/skia/src/core/ |
| SkChunkAlloc.cpp | 12 struct SkChunkAlloc::Block {
13 Block* fNext;
23 Block* block = this; local
24 while (block) {
25 Block* next = block->fNext;
26 sk_free(block);
27 block = next;
31 Block* tail()
32 Block* block = this; local
78 Block* block = fPool; local
105 Block* block = fBlock; local
126 Block* block = fBlock; local
140 const Block* block = fBlock; local
[all...] |
| SkWriter32.cpp | 10 struct SkWriter32::Block {
11 Block* fNext;
34 static Block* Create(size_t size) {
36 Block* block = (Block*)sk_malloc_throw(sizeof(Block) + size); local
37 block->fNext = NULL;
38 block->fSize = size;
39 block->fAllocated = 0
51 Block* block = fHead; local
80 Block* block = fTail; local
104 Block* block = fHead; local
121 const Block* block = fHead; local
185 const Block* block = fHead; local
[all...] |
| /external/skia/src/gpu/ |
| GrAllocPool.cpp | 15 struct GrAllocPool::Block {
16 Block* fNext;
21 static Block* Create(size_t size, Block* next) {
24 Block* block = (Block*)GrMalloc(sizeof(Block) + size); local
25 block->fNext = next;
26 block->fPtr = (char*)block + sizeof(Block)
70 Block* block = fBlock; local
109 Block* block = fBlock; local
[all...] |
| GrAllocPool.h | 27 * Returns a block of memory bytes size big. This address must not be
39 struct Block;
41 Block* fBlock;
|
| /external/clang/include/clang/Analysis/Analyses/ |
| PostOrderCFGView.h | 50 bool insert(const CFGBlock *Block) {
52 // make sure that Block is non-null. Moreover, the CFGBlock iterator will
55 if (Block == 0)
57 if (VisitedBlockIDs.test(Block->getBlockID()))
59 VisitedBlockIDs.set(Block->getBlockID());
65 /// loop. Block must not be null.
66 bool alreadySet(const CFGBlock *Block) {
67 return VisitedBlockIDs.test(Block->getBlockID());
|
| /external/clang/test/PCH/ |
| types.h | 16 typedef int (^Block)(int, float);
|
| /external/clang/lib/Analysis/ |
| ReachableCode.cpp | 44 void enqueue(const CFGBlock *block);
48 bool isDeadCodeRoot(const CFGBlock *Block);
50 const Stmt *findDeadCode(const CFGBlock *Block);
57 void DeadCodeScan::enqueue(const CFGBlock *block) {
58 unsigned blockID = block->getBlockID();
62 WorkList.push_back(block);
65 bool DeadCodeScan::isDeadCodeRoot(const clang::CFGBlock *Block) {
68 for (CFGBlock::const_pred_iterator I = Block->pred_begin(),
69 E = Block->pred_end(); I != E; ++I) {
96 const Stmt *DeadCodeScan::findDeadCode(const clang::CFGBlock *Block) {
170 const CFGBlock *block = I->first; local
318 const CFGBlock *block = *I; local
[all...] |
| CFG.cpp | 45 /// subexpressions as block-level expressions. For example:
50 /// need to be added as block-level expressions, even though they
54 /// block-level expression.
209 BlockScopePosPair() : block(0) {}
211 : block(b), scopePosition(scopePos) {}
213 CFGBlock *block; member in struct:__anon5092::BlockScopePosPair
246 /// the AST in reverse order so that the successor of a basic block is
257 CFGBlock *Block;
300 Block(NULL), Succ(NULL),
386 return Block;
[all...] |
| /external/stlport/test/eh/ |
| nc_alloc.cpp | 118 if (s <= sizeof(Block)) {
131 Block* b = (Block*)p;
139 struct Block;
140 friend struct Block;
151 struct Block {
153 Block *next;
159 static Block* mBlocks;
160 static Block *mFree;
164 FastAllocator::Block *FastAllocator::mBlocks
[all...] |
| /external/llvm/tools/lli/ |
| RecordingMemoryManager.cpp | 25 sys::MemoryBlock Block(Addr, Size);
26 AllocatedCodeMem.push_back(Allocation(Block, Alignment));
37 sys::MemoryBlock Block(Addr, Size);
38 AllocatedDataMem.push_back(Allocation(Block, Alignment));
|
| /external/valgrind/main/coregrind/ |
| m_mallocfree.c | 74 /* Layout of an in-use block:
77 this block total szB (sizeof(SizeT) bytes)
81 this block total szB (sizeof(SizeT) bytes)
83 Layout of a block on the free list:
86 this block total szB (sizeof(SizeT) bytes)
92 this block total szB (sizeof(SizeT) bytes)
104 block for arenas used by the core is:
117 Furthermore, both size fields in the block have their least-significant
118 bit set if the block is not in use, and unset if it is in use.
120 A block size of zero is not possible, because a block always has a
[all...] |
