| /external/clang/test/CodeGenCXX/ |
| 2003-11-27-MultipleInheritanceThunk.cpp | 5 struct CallSite {
8 CallSite(const CallSite &CS);
14 virtual int getModRefInfo(CallSite CS);
24 int getModRefInfo(CallSite CS) {
|
| x86_32-arguments.cpp | 34 // CHECK: %struct.CallSite* byval align 4 %CS)
35 struct CallSite {
37 CallSite(unsigned XX) : Ptr(XX) {}
42 virtual void getModRefInfo(CallSite CS) = 0;
50 void getModRefInfo(CallSite CS);
53 void BasicAliasAnalysis::getModRefInfo(CallSite CS) {
|
| /external/clang/lib/StaticAnalyzer/Core/ |
| BlockCounter.cpp | 25 const StackFrameContext *CallSite;
30 : CallSite(CS), BlockID(ID) {}
33 return (CallSite == RHS.CallSite) && (BlockID == RHS.BlockID);
37 return std::tie(CallSite, BlockID) < std::tie(RHS.CallSite, RHS.BlockID);
41 ID.AddPointer(CallSite);
58 unsigned BlockCounter::getNumVisited(const StackFrameContext *CallSite,
61 CountMap::data_type* T = M.lookup(CountKey(CallSite, BlockID));
75 const StackFrameContext *CallSite,
[all...] |
| /external/llvm/include/llvm/Transforms/IPO/ |
| InlinerPass.h | 23 class CallSite;
60 unsigned getInlineThreshold(CallSite CS) const;
67 virtual InlineCost getInlineCost(CallSite CS) = 0;
85 /// inline at the given CallSite.
86 bool shouldInline(CallSite CS);
|
| /external/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ |
| BlockCounter.h | 38 unsigned getNumVisited(const StackFrameContext *CallSite,
49 const StackFrameContext *CallSite,
|
| /external/clang/test/SemaCXX/ |
| invalid-instantiated-field-decl.cpp | 15 typedef typename SmallVectorImpl<T>::U U; // expected-error {{no type named 'U' in 'SmallVectorImpl<CallSite>'}}
18 MinUs = (static_cast<unsigned int>(sizeof(T))*N + // expected-error {{invalid application of 'sizeof' to an incomplete type 'CallSite'}}
30 class CallSite; // expected-note {{forward declaration of 'CallSite'}}
34 SmallVector<CallSite, 2> DevirtualizedCalls; // expected-note {{in instantiation of template class 'SmallVector<CallSite, 2>' requested}}
|
| /external/llvm/include/llvm/Analysis/ |
| InlineCost.h | 22 class CallSite;
47 /// based on the information available for a particular callsite. They can be
56 /// \brief The estimated cost of inlining this callsite.
115 /// callsite.
123 /// inlining the callsite. It is an expensive, heavyweight call.
124 InlineCost getInlineCost(CallSite CS, int Threshold);
133 InlineCost getInlineCost(CallSite CS, Function *Callee, int Threshold);
|
| CallGraph.h | 57 #include "llvm/IR/CallSite.h"
226 "Cannot steal callsite information if I already have some");
231 void addCalledFunction(CallSite CS, CallGraphNode *M) {
247 void removeCallEdgeFor(CallSite CS);
256 /// \brief Removes one edge associated with a null callsite from this node to
264 void replaceCallEdge(CallSite CS, CallSite NewCS, CallGraphNode *NewNode);
|
| MemoryDependenceAnalysis.h | 29 class CallSite;
363 const NonLocalDepInfo &getNonLocalCallDependency(CallSite QueryCS);
422 MemDepResult getCallSiteDependencyFrom(CallSite C, bool isReadOnlyCall,
|
| /external/llvm/include/llvm/IR/ |
| CallSite.h | 1 //===- CallSite.h - Abstract Call & Invoke instrs ---------------*- C++ -*-===//
10 // This file defines the CallSite class, which is a handy wrapper for code that
22 // accessors of CallSite are employed.
305 /// hasArgument - Returns true if this CallSite passes the given Value* as an
331 class CallSite : public CallSiteBase<Function, Value, User, Instruction,
336 CallSite() {}
337 CallSite(Base B) : Base(B) {}
338 CallSite(Value* V) : Base(V) {}
339 CallSite(CallInst *CI) : Base(CI) {}
340 CallSite(InvokeInst *II) : Base(II) {
[all...] |
| /external/llvm/lib/Transforms/IPO/ |
| InlineAlways.cpp | 19 #include "llvm/IR/CallSite.h"
52 InlineCost getInlineCost(CallSite CS) override;
91 InlineCost AlwaysInliner::getInlineCost(CallSite CS) {
|
| InlineSimple.cpp | 17 #include "llvm/IR/CallSite.h"
52 InlineCost getInlineCost(CallSite CS) override {
|
| Inliner.cpp | 21 #include "llvm/IR/CallSite.h"
126 static bool InlineCallIfPossible(CallSite CS, InlineFunctionInfo &IFI,
170 // reuse and makes a callsite (C) available for inlining. When we process
264 unsigned Inliner::getInlineThreshold(CallSite CS) const {
304 static void emitAnalysis(CallSite CS, const Twine &Msg) {
312 /// at the given CallSite.
313 bool Inliner::shouldInline(CallSite CS) {
370 CallSite CS2(U);
389 // See if inlining or original callsite would erase the cost delta of
390 // this callsite. We subtract off the penalty for the call instruction
[all...] |
| IPConstantPropagation.cpp | 22 #include "llvm/IR/CallSite.h"
100 CallSite CS(cast<Instruction>(UR));
106 CallSite::arg_iterator AI = CS.arg_begin();
225 CallSite CS(U.getUser());
|
| /external/llvm/tools/opt/ |
| AnalysisWrappers.cpp | 21 #include "llvm/IR/CallSite.h"
44 CallSite CS(cast<Value>(UI));
47 for (CallSite::arg_iterator AI = CS.arg_begin(),
|
| /external/llvm/lib/Analysis/IPA/ |
| CallGraph.cpp | 11 #include "llvm/IR/CallSite.h"
57 ExternalCallingNode->addCalledFunction(CallSite(), Node);
70 ExternalCallingNode->addCalledFunction(CallSite(), Node);
75 Node->addCalledFunction(CallSite(), CallsExternalNode);
81 CallSite CS(cast<Value>(II));
182 void CallGraphNode::removeCallEdgeFor(CallSite CS) {
184 assert(I != CalledFunctions.end() && "Cannot find callsite to remove!");
207 /// removeOneAbstractEdgeTo - Remove one edge associated with a null callsite
225 void CallGraphNode::replaceCallEdge(CallSite CS,
226 CallSite NewCS, CallGraphNode *NewNode)
[all...] |
| InlineCost.cpp | 23 #include "llvm/IR/CallSite.h"
73 // maintain a mapping of simplified values specific to this callsite. The
103 bool simplifyCallSite(Function *F, CallSite CS);
134 bool visitCallSite(CallSite CS);
156 bool analyzeCall(CallSite CS);
228 /// Respects any simplified values known during the analysis of this callsite.
240 /// simplified values known during the analysis of this callsite.
676 /// Takes a concrete function and callsite and tries to actually simplify it by
678 /// it has simplified the callsite to some other entity (a constant), making it
680 bool CallAnalyzer::simplifyCallSite(Function *F, CallSite CS)
[all...] |
| /external/llvm/lib/Analysis/ |
| CaptureTracking.cpp | 23 #include "llvm/IR/CallSite.h"
107 CallSite CS(I);
121 CallSite::arg_iterator B = CS.arg_begin(), E = CS.arg_end();
122 for (CallSite::arg_iterator A = B; A != E; ++A)
|
| AliasAnalysisEvaluator.cpp | 119 PrintModRefResults(const char *Msg, bool P, CallSite CSA, CallSite CSB,
145 SetVector<CallSite> CallSites;
161 if (CallSite CS = cast<Value>(&Inst)) {
167 for (CallSite::arg_iterator AI = CS.arg_begin(), AE = CS.arg_end();
272 for (SetVector<CallSite>::iterator C = CallSites.begin(),
300 for (SetVector<CallSite>::iterator C = CallSites.begin(),
302 for (SetVector<CallSite>::iterator D = CallSites.begin(); D != Ce; ++D) {
|
| /external/llvm/include/llvm/Transforms/Utils/ |
| Cloning.h | 39 class CallSite;
194 bool InlineFunction(CallSite CS, InlineFunctionInfo &IFI, bool InsertLifetime = true);
|
| /external/chromium_org/third_party/WebKit/Source/devtools/scripts/jsdoc-validator/src/org/chromium/devtools/jsdoc/checks/ |
| FunctionReceiverChecker.java | 30 private final Map<String, Set<CallSite>> callSitesByFunctionName = new HashMap<>();
79 .add(new CallSite(hasReceiver, functionCall));
225 private void processFunctionCallSites(FunctionRecord function, Set<CallSite> callSites) {
230 for (CallSite callSite : callSites) {
231 if (functionReferencesThis == callSite.hasReceiver || function.isConstructor()) {
234 if (callSite.hasReceiver) {
235 reportErrorAtNodeStart(callSite.callNode,
238 reportErrorAtNodeStart(callSite.callNode,
288 private static class CallSite {
[all...] |
| /external/llvm/lib/ExecutionEngine/Interpreter/ |
| Interpreter.h | 19 #include "llvm/IR/CallSite.h"
76 CallSite Caller; // Holds the call that called subframes.
171 void visitCallSite(CallSite CS);
172 void visitCallInst(CallInst &I) { visitCallSite (CallSite (&I)); }
173 void visitInvokeInst(InvokeInst &I) { visitCallSite (CallSite (&I)); }
|
| /external/llvm/lib/CodeGen/ |
| JumpInstrTables.cpp | 21 #include "llvm/IR/CallSite.h"
62 // Checks to see if a given CallSite is making an indirect call, including
64 bool isIndirectCall(CallSite &CS) {
86 CallSite CS(I);
104 CallSite CS(CI);
|
| /external/llvm/tools/llvm-diff/ |
| DifferenceEngine.cpp | 22 #include "llvm/IR/CallSite.h"
226 bool diffCallSites(CallSite L, CallSite R, bool Complain) {
262 return diffCallSites(CallSite(L), CallSite(R), Complain);
279 if (diffCallSites(CallSite(LI), CallSite(RI), Complain))
|
| /external/clang/include/clang/Analysis/ |
| AnalysisContext.h | 266 // The callsite where this stack frame is established.
267 const Stmt *CallSite;
269 // The parent block of the callsite.
272 // The index of the callsite in the CFGBlock.
279 : LocationContext(StackFrame, ctx, parent), CallSite(s),
285 const Stmt *getCallSite() const { return CallSite; }
|
