| /external/llvm/lib/Target/ |
| TargetIntrinsicInfo.cpp | 15 #include "llvm/Function.h"
25 unsigned TargetIntrinsicInfo::getIntrinsicID(Function *F) const {
|
| /external/valgrind/main/none/tests/ |
| procfs-non-linux.stderr.exp | 8 readlinkat: Function not implemented
9 readlinkat: Function not implemented
|
| /external/webkit/Source/JavaScriptCore/tests/mozilla/ecma_2/Statements/ |
| forin-002.js | 22 function MyObject( value ) {
24 this.valueOf = new Function ( "return this.value" );
25 this.toString = new Function ( "return this.value + \"\"" );
26 this.toNumber = new Function ( "return this.value + 0" );
27 this.toBoolean = new Function ( "return Boolean( this.value )" );
44 function ForIn_1( object) {
61 function ForIn_2(object) {
|
| /external/llvm/include/llvm/Analysis/ |
| BlockFrequencyInfo.h | 31 BlockFrequencyImpl<BasicBlock, Function, BranchProbabilityInfo> *BFI;
42 bool runOnFunction(Function &F);
|
| PathProfileInfo.h | 35 typedef std::map<Function*,unsigned int> FunctionPathCountMap;
36 typedef std::map<Function*,ProfilePathMap> FunctionPathMap;
37 typedef std::map<Function*,ProfilePathMap>::iterator FunctionPathIterator;
86 void setCurrentFunction(Function* F);
87 Function* getCurrentFunction() const;
106 Function* _currentFunction;
|
| ConstantFolding.h | 28 class Function;
36 /// this function can only fail when attempting to fold instructions like loads
48 /// null is returned. Note that this function can fail when attempting to
81 /// the specified function.
82 bool canConstantFoldCallTo(const Function *F);
84 /// ConstantFoldCall - Attempt to constant fold a call to the specified function
87 ConstantFoldCall(Function *F, ArrayRef<Constant *> Operands);
|
| /external/llvm/include/llvm/Assembly/ |
| AssemblyAnnotationWriter.h | 22 class Function;
34 /// the start of a function.
35 virtual void emitFunctionAnnot(const Function *F,
|
| /external/llvm/include/llvm/ExecutionEngine/ |
| JITEventListener.h | 24 class Function;
28 /// about a generated machine code function.
39 /// The machine function the struct contains information for.
59 /// NotifyFunctionEmitted - Called after a function has been successfully
60 /// emitted to memory. The function still has its MachineFunction attached,
62 virtual void NotifyFunctionEmitted(const Function &F,
71 /// parameter to a previous NotifyFunctionEmitted call. The Function passed
|
| JITMemoryManager.h | 18 class Function;
72 /// startFunctionBody - When we start JITing a function, the JIT calls this
77 /// much space it will need to emit the function, it passes 0 for the
81 virtual uint8_t *startFunctionBody(const Function *F,
85 /// function stub (used to handle limited branch displacements) while it is
86 /// JIT compiling a function. For example, if foo calls bar, and if bar
87 /// either needs to be lazily compiled or is a native function that exists too
89 /// thunk for it. The stub should be "close" to the current function body,
96 /// the specified function. At this point we know the size of the JIT
97 /// compiled function. This passes in FunctionStart (which was returned b
[all...] |
| /external/llvm/lib/Analysis/ |
| CFGPrinter.cpp | 11 // cfg.<fnname>.dot file for each function in the program, with a graph of the
12 // CFG for that function.
15 // Function::viewCFG method, which is useful for debugging passes which operate
32 virtual bool runOnFunction(Function &F) {
46 INITIALIZE_PASS(CFGViewer, "view-cfg", "View CFG of function", false, true)
55 virtual bool runOnFunction(Function &F) {
70 "View CFG of function (with no function bodies)", false, true)
79 virtual bool runOnFunction(Function &F) {
87 WriteGraph(File, (const Function*)&F)
[all...] |
| Trace.cpp | 19 #include "llvm/Function.h"
25 Function *Trace::getFunction() const {
36 Function *F = getFunction();
37 O << "; Trace from function " << F->getNameStr() << ", blocks:\n";
43 O << "; Trace parent function: \n" << *F;
|
| /external/llvm/lib/Target/Mips/ |
| MipsJITInfo.h | 36 /// replaceMachineCodeForFunction - Make it so that calling the function
48 /// small native function that simply calls the function at the specified
50 virtual void *emitFunctionStub(const Function* F, void *Fn,
59 virtual void relocate(void *Function, MachineRelocation *MR,
62 /// Initialize - Initialize internal stage for the function being JITted.
|
| /external/llvm/lib/Target/PowerPC/ |
| PPCJITInfo.h | 34 virtual void *emitFunctionStub(const Function* F, void *Fn,
37 virtual void relocate(void *Function, MachineRelocation *MR,
40 /// replaceMachineCodeForFunction - Make it so that calling the function
|
| /external/webkit/Source/JavaScriptCore/tests/mozilla/ecma_3/Function/ |
| call-001.js | 22 * SUMMARY: Applying Function.prototype.call to the Function object itself
25 * ECMA-262 15.3.4.4 Function.prototype.call (thisArg [,arg1 [,arg2,?] ] )
27 * When applied to the Function object itself, thisArg should be ignored.
30 * Function.call(obj, "print(this)") is equivalent to invoking
31 * Function("print(this)") with this set to obj. Now, Function("print(this)")
32 * is equivalent to new Function("print(this)") (see 15.3.1.1), and the latter
33 * ignores the this value that you passed it and constructs a function
45 var summary = 'Applying Function.prototype.call to the Function object itself'
[all...] |
| /external/webkit/Source/WebCore/bindings/v8/ |
| V8EventListener.cpp | 44 v8::Local<v8::Function> V8EventListener::getListenerFunction(ScriptExecutionContext* context)
50 return v8::Local<v8::Function>();
53 return v8::Local<v8::Function>::Cast(listener);
58 // handleEvent property and that the value is a function.
60 return v8::Local<v8::Function>::Cast(property);
63 return v8::Local<v8::Function>();
69 v8::Local<v8::Function> handlerFunction = getListenerFunction(context);
|
| /external/v8/test/mjsunit/ |
| function.js | 28 var f = Function();
30 f = new Function();
33 f = Function('return 1');
35 f = new Function('return 1');
38 f = Function('return true');
40 f = new Function('return true');
43 f = Function('x', 'return x');
50 f = Function('x', 'return x // comment');
53 f = Function('return typeof anonymous');
57 f = Function('return anonymous;')
[all...] |
| /external/llvm/lib/ExecutionEngine/JIT/ |
| JIT.h | 23 class Function;
32 FunctionPassManager PM; // Passes to compile a function
36 /// were called from a function being code generated.
37 std::vector<AssertingVH<Function> > PendingFunctions;
47 std::vector<AssertingVH<Function> > &getPendingFunctions(const MutexGuard &L){
115 /// runFunction - Start execution with the specified function and arguments.
117 virtual GenericValue runFunction(Function *F,
121 /// specified function by using the dlsym function call. As such it is only
124 /// If AbortOnFailure is false and no function with the given name i
[all...] |
| JITDwarfEmitter.h | 20 class Function;
46 unsigned char* EmitCommonEHFrame(const Function* Personality) const;
48 unsigned char* EmitEHFrame(const Function* Personality,
|
| /external/guava/src/com/google/common/base/ |
| Functions.java | 44 * Returns a function that calls {@code toString()} on its argument. The
45 * function does not accept nulls; it will throw a
48 public static Function<Object, String> toStringFunction() {
53 private enum ToStringFunction implements Function<Object, String> {
66 * Returns the identity function.
69 public static <E> Function<E, E> identity() {
70 return (Function<E, E>) IdentityFunction.INSTANCE;
74 private enum IdentityFunction implements Function<Object, Object> {
87 * Returns a function which performs a map lookup. The returned function
[all...] |
| /external/llvm/include/llvm/ |
| Function.h | 1 //===-- llvm/Function.h - Class to represent a single function --*- C++ -*-===//
10 // This file contains the declaration of the Function class, which represents a
11 // single function/procedure in LLVM.
13 // A function basically consists of a list of basic blocks, a list of arguments,
35 : public SymbolTableListTraits<BasicBlock, Function> {
48 static ValueSymbolTable *getSymTab(Function *ItemParent);
54 : public SymbolTableListTraits<Argument, Function> {
65 static ValueSymbolTable *getSymTab(Function *ItemParent);
70 class Function : public GlobalValue
[all...] |
| /external/llvm/lib/Transforms/Utils/ |
| BasicInliner.cpp | 1 //===- BasicInliner.cpp - Basic function level inliner --------------------===//
10 // This file defines a simple function based inliner that does not use
17 #include "llvm/Function.h"
44 /// addFunction - Add function into the list of functions to process.
47 void addFunction(Function *F) {
51 /// neverInlineFunction - Sometimes a function is never to be inlined
53 void neverInlineFunction(Function *F) {
64 std::vector<Function *> Functions;
65 SmallPtrSet<const Function *, 16> NeverInline;
66 SmallPtrSet<Function *, 8> DeadFunctions
[all...] |
| InstructionNamer.cpp | 18 #include "llvm/Function.h"
34 bool runOnFunction(Function &F) {
35 for (Function::arg_iterator AI = F.arg_begin(), AE = F.arg_end();
40 for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB) {
|
| /external/llvm/examples/BrainF/ |
| BrainF.h | 37 /// and returns the module with a function
68 /// Put the brainf function preamble and other fixed pieces of code
81 Function *brainf_func;
82 Function *getchar_func;
83 Function *putchar_func;
|
| /external/llvm/examples/ModuleMaker/ |
| ModuleMaker.cpp | 29 // function
32 // Create the main function: first create the type 'int ()'
36 // By passing a module as the last parameter to the Function constructor,
38 Function *F = Function::Create(FT, Function::ExternalLinkage, "main", M);
40 // Add a basic block to the function... again, it automatically inserts
|
| /external/llvm/include/llvm/Target/ |
| TargetJITInfo.h | 25 class Function;
36 /// replaceMachineCodeForFunction - Make it so that calling the function
65 /// small native function that simply calls the function at the specified
67 /// stub. Return the address of the resultant function, which may have been
69 virtual void *emitFunctionStub(const Function* F, void *Target,
82 /// LazyResolverFn - This typedef is used to represent the function that
84 /// function that knows how to walk the stack and find out which stub the
88 /// JITCompilerFn - This typedef is used to represent the JIT function that
89 /// lazily compiles the function corresponding to a stub. The JIT keep
[all...] |
