| /external/llvm/tools/llvm-diff/ |
| DifferenceEngine.h | 25 class Function;
65 void diff(Function *L, Function *R);
|
| DiffConsumer.cpp | 21 static void ComputeNumbering(Function *F, DenseMap<Value*,unsigned> &Numbering){
25 for (Function::arg_iterator
31 for (Function::iterator FI = F->begin(), FE = F->end(); FI != FE; ++FI) {
80 ComputeNumbering(cast<Function>(ctxt.L), ctxt.LNumbering);
85 ComputeNumbering(cast<Function>(ctxt.R), ctxt.RNumbering);
99 if (isa<Function>(I->L)) {
103 Function *L = cast<Function>(I->L);
104 Function *R = cast<Function>(I->R)
[all...] |
| /external/llvm/unittests/Transforms/Utils/ |
| IntegerDivision.cpp | 12 #include "llvm/IR/Function.h"
28 Function *F = Function::Create(FunctionType::get(Builder.getInt32Ty(),
36 Function::arg_iterator AI = F->arg_begin();
58 Function *F = Function::Create(FunctionType::get(Builder.getInt32Ty(),
66 Function::arg_iterator AI = F->arg_begin();
88 Function *F = Function::Create(FunctionType::get(Builder.getInt32Ty(),
96 Function::arg_iterator AI = F->arg_begin()
[all...] |
| /external/chromium/base/ |
| task.h | 58 // // If this function might be called directly, you might want to revoke
291 // Runnable methods are a type of task that call a function on an object when
299 // Method/Function - the signature of a pointer to the method or function you
311 // PostTask(FROM_HERE, NewRunnableFunction(&function[, a[, b]])
444 template <class Function, class Params>
447 RunnableFunction(Function function, const Params& params)
448 : function_(function), params_(params) {
466 Function function_
[all...] |
| /external/llvm/include/llvm/IR/ |
| Module.h | 19 #include "llvm/IR/Function.h"
35 template<> struct ilist_traits<Function>
36 : public SymbolTableListTraits<Function, Module> {
40 Function *createSentinel() const {
41 return static_cast<Function*>(&Sentinel);
43 static void destroySentinel(Function*) {}
45 Function *provideInitialHead() const { return createSentinel(); }
46 Function *ensureHead(Function*) const { return createSentinel(); }
47 static void noteHead(Function*, Function*) {
[all...] |
| BasicBlock.h | 79 Function *Parent;
81 void setParent(Function *parent);
82 friend class SymbolTableListTraits<BasicBlock, Function>;
89 /// If the function parameter is specified, the basic block is automatically
90 /// inserted at either the end of the function (if InsertBefore is null), or
93 Function *Parent = 0, BasicBlock *InsertBefore = 0);
107 /// inserted at either the end of the function (if InsertBefore is 0), or
110 Function *Parent = 0,BasicBlock *InsertBefore = 0) {
116 const Function *getParent() const { return Parent; }
117 Function *getParent() { return Parent;
[all...] |
| /external/ceres-solver/internal/ceres/ |
| line_search.h | 55 // While finding the exact minimum of a one dimensionl function is
62 class Function;
74 function(NULL) {}
77 // function.
86 // which decreases the value of the objective function
147 // The one dimensional function that the line search algorithm
149 Function* function; member in struct:ceres::internal::LineSearch::Options
152 // An object used by the line search to access the function values
153 // and gradient of the one dimensional function being optimized
[all...] |
| /external/chromium/testing/gmock/test/ |
| gmock-generated-internal-utils_test.cc | 46 using ::testing::internal::Function;
72 // Tests the Function template struct.
75 typedef Function<int()> F; // NOLINT
84 typedef Function<int(bool)> F; // NOLINT
95 typedef Function<int(bool, const long&)> F; // NOLINT
108 typedef Function<char(bool, int, char*, int&, const long&)> F; // NOLINT
|
| /external/llvm/include/llvm/Analysis/ |
| CFGPrinter.h | 20 #include "llvm/IR/Function.h"
27 struct DOTGraphTraits<const Function*> : public DefaultDOTGraphTraits {
31 static std::string getGraphName(const Function *F) {
32 return "CFG for '" + F->getName().str() + "' function";
36 const Function *) {
48 const Function *) {
76 const Function *Graph) {
|
| /external/llvm/include/llvm/CodeGen/ |
| GCMetadata.h | 25 // GCModuleInfo simply collects GCFunctionInfo instances for each Function as
81 /// GCFunctionInfo - Garbage collection metadata for a single function.
90 const Function &F;
107 GCFunctionInfo(const Function &F, GCStrategy &S);
110 /// getFunction - Return the function to which this metadata applies.
112 const Function &getFunction() const { return F; }
114 /// getStrategy - Return the GC strategy for the function.
137 /// getFrameSize/setFrameSize - Records the function's frame size.
148 /// roots_begin/roots_end - Iterators for all roots in the function.
167 typedef DenseMap<const Function*,GCFunctionInfo*> finfo_map_type
[all...] |
| /external/llvm/lib/Analysis/ |
| Analysis.cpp | 97 return verifyFunction(*unwrap<Function>(Fn),
102 Function *F = unwrap<Function>(Fn);
107 Function *F = unwrap<Function>(Fn);
|
| /external/llvm/unittests/ExecutionEngine/MCJIT/ |
| MCJITTest.cpp | 10 // This test suite verifies basic MCJIT functionality such as making function
33 // does require retrieval of a pointer to a function/global.
61 Function *F = insertAddFunction(M.get());
66 << "Unable to get pointer to function from JIT";
78 Function *Main = insertMainFunction(M.get(), 6);
96 Function *ReturnGlobal = startFunction<int32_t(void)>(M.get(),
108 << "Invalid value for global returned from JITted function";
124 Function *IncrementGlobal = startFunction<int32_t(void)>(M.get(), "IncrementGlobal");
160 Function *Inner = startFunction<int32_t(void)>(M.get(), "Inner");
163 Function *Outer
[all...] |
| MCJITCAPITest.cpp | 87 Function = 0;
104 Function = LLVMAddFunction(
106 LLVMSetFunctionCallConv(Function, LLVMCCallConv);
108 LLVMBasicBlockRef entry = LLVMAppendBasicBlock(Function, "entry");
152 LLVMValueRef Function;
170 functionPointer.raw = LLVMGetPointerToGlobal(Engine, Function);
188 functionPointer.raw = LLVMGetPointerToGlobal(Engine, Function);
|
| /external/llvm/lib/Transforms/Utils/ |
| CloneFunction.cpp | 1 //===- CloneFunction.cpp - Clone a function into another function ---------===//
11 // low-level function cloner. This is used by the CloneFunction and function
12 // inliner to do the dirty work of copying the body of a function around.
23 #include "llvm/IR/Function.h"
39 const Twine &NameSuffix, Function *F,
76 void llvm::CloneFunctionInto(Function *NewFunc, const Function *OldFunc,
86 for (Function::const_arg_iterator I = OldFunc->arg_begin(),
[all...] |
| /external/chromium_org/v8/test/mjsunit/ |
| debug-stepout-scope-part1.js | 35 function listener(event, exec_state, event_data, data) {
56 function test1() {
65 function test2() {
79 function test3() {
91 function test4() {
98 function test5() {
111 function test6() {
122 function test7() {
124 function foo() {}
129 function test8()
[all...] |
| /external/llvm/lib/Transforms/IPO/ |
| Inliner.cpp | 41 // to inline a function A into B, we analyze the callers of B in order to see
75 /// \brief If the inlined function had a higher stack protection level than the
76 /// calling function, then bump up the caller's stack protection level.
77 static void AdjustCallerSSPLevel(Function *Caller, Function *Callee) {
112 /// This function also does some basic book-keeping to update the IR. The
121 Function *Callee = CS.getCalledFunction();
122 Function *Caller = CS.getCaller();
124 // Try to inline the function. Get the list of static allocas that were
132 // have already inlined other allocas through other calls into this function,
[all...] |
| LoopExtractor.cpp | 1 //===- LoopExtractor.cpp - Extract each loop into a new function ----------===//
11 // top-level loop into its own new function. If the loop is the ONLY loop in a
12 // given function, it is not touched. This is a pass most useful for debugging
74 "Extract at most one loop into a new function", false, false)
77 // program into a function if it can.
93 // If there is more than one top-level loop in this function, extract all of
95 // this function is more than a minimal wrapper around the loop, extract
121 // function. An infinite cycle occurs when it tries to extract that loop as
138 // After extraction, the loop is replaced by a function call, so
149 // program into a function if it can. This is used by bugpoint
[all...] |
| MergeFunctions.cpp | 12 // A hash is computed from the function, based on its type and number of
16 // on each function pair. This takes n^2/2 comparisons per bucket, so it's
17 // important that the hash function be high quality. The equality comparison
21 // overridable, we move the functionality into a new internal function and
30 // Many functions have their address taken by the virtual function table for
84 /// Creates a hash-code for the function which is the same for any two
86 /// inside the function.
87 static unsigned profileFunction(const Function *F) {
111 ComparableFunction(Function *Func, DataLayout *TD)
114 Function *getFunc() const { return Func;
[all...] |
| /external/llvm/tools/bugpoint/ |
| ExtractFunction.cpp | 1 //===- ExtractFunction.cpp - Extract a function from Program --------------===//
51 Function* globalInitUsesExternalBA(GlobalVariable* GV) {
69 Function *F = BA->getFunction();
95 const Function *PF = PBB->getParent();
101 Function::iterator RBI = RFI->begin(); // Get iterator to corresponding BB
102 std::advance(RBI, std::distance(PF->begin(), Function::const_iterator(PBB)));
162 /// function. This returns null if there are no extractable loops in the
194 // DeleteFunctionBody - "Remove" the function by deleting all of its basic
197 void llvm::DeleteFunctionBody(Function *F) {
198 // delete the body of the function..
[all...] |
| /external/llvm/unittests/ExecutionEngine/JIT/ |
| JITEventListenerTest.cpp | 33 const Function *F;
51 virtual void NotifyFunctionEmitted(const Function &F,
79 Function *buildFunction(Module *M) {
80 Function *Result = Function::Create(
93 Function *F1 = buildFunction(M);
94 Function *F2 = buildFunction(M);
109 << "We don't know how big the function will be, but it had better"
116 << "We don't know how big the function will be, but it had better"
134 Function *F1 = buildFunction(M)
[all...] |
| /art/compiler/llvm/ |
| runtime_support_builder.cc | 27 #include <llvm/IR/Function.h>
33 using ::llvm::Function;
46 ::llvm::Function* fn = module_.getFunction(#NAME); \
47 DCHECK(fn != NULL) << "Function not found: " << #NAME; \
58 Function* func = GetRuntimeSupportFunction(runtime_support::GetCurrentThread);
78 Function* func = GetRuntimeSupportFunction(runtime_support::SetCurrentThread);
120 Function* func = GetRuntimeSupportFunction(runtime_support::PushShadowFrame);
142 Function* slow_func = GetRuntimeSupportFunction(runtime_support::GetAndClearException);
158 Function* slow_func = GetRuntimeSupportFunction(runtime_support::TestSuspend);
179 Function* parent_func = irb_.GetInsertBlock()->getParent()
[all...] |
| intrinsic_helper.cc | 23 #include <llvm/IR/Function.h>
100 // 1. Introduce the intrinsic function into the module
126 // Construct the function type
135 // Declare the function
136 ::llvm::Function *fn = ::llvm::Function::Create(type,
137 ::llvm::Function::ExternalLinkage,
151 DCHECK_NE(fn, static_cast< ::llvm::Function*>(NULL)) << "Intrinsic `"
155 for (::llvm::Function::arg_iterator arg_iter = fn->arg_begin(),
|
| /external/llvm/examples/Kaleidoscope/Chapter3/ |
| toy.cpp | 116 /// CallExprAST - Expression class for function calls.
126 /// PrototypeAST - This class represents the "prototype" for a function,
128 /// of arguments the function takes).
136 Function *Codegen();
139 /// FunctionAST - This class represents a function definition itself.
147 Function *Codegen();
297 return ErrorP("Expected function name in prototype");
359 // Look this variable up in the function.
384 Function *CalleeF = TheModule->getFunction(Callee);
386 return ErrorV("Unknown function referenced")
[all...] |
| /external/llvm/include/llvm/ExecutionEngine/ |
| ExecutionEngine.h | 39 class Function;
151 /// LazyFunctionCreator - If an unknown function is needed, this function
157 /// register dwarf tables with this function.
162 DenseMap<const Function*, void*> AllExceptionTables;
199 /// function.
228 Function *FindFunctionNamed(const char *FnName);
230 /// runFunction - Execute the specified function with the specified arguments,
232 virtual GenericValue runFunction(Function *F,
236 /// specified function by using the dlsym function call. As such it is onl
[all...] |
| /external/chromium/testing/gmock/include/gmock/ |
| gmock-actions.h | 53 // 2. a factory function that creates an Action object from a
69 // function will abort the process.
73 // This function returns true iff type T has a built-in default value.
77 "Default action undefined for the function return type.");
80 // order for this function to compile.
147 // When an unexpected function call is encountered, Google Mock will
155 // destructible (i.e. anything that can be used as a function return
248 // Implement this interface to define an action for function type F.
252 typedef typename internal::Function<F>::Result Result;
253 typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple
[all...] |
