Cross Reference: /external/clang/lib/Analysis/ThreadSafetyCommon.cpp

Lines Matching refs:Ctx
95 // Also performs substitution of variables; Ctx provides the context.
97 til::SExpr *SExprBuilder::translate(const Stmt *S, CallingContext *Ctx) {
108     return translateDeclRefExpr(cast<DeclRefExpr>(S), Ctx);
110     return translateCXXThisExpr(cast<CXXThisExpr>(S), Ctx);
112     return translateMemberExpr(cast<MemberExpr>(S), Ctx);
114     return translateCallExpr(cast<CallExpr>(S), Ctx);
116     return translateCXXMemberCallExpr(cast<CXXMemberCallExpr>(S), Ctx);
118     return translateCXXOperatorCallExpr(cast<CXXOperatorCallExpr>(S), Ctx);
120     return translateUnaryOperator(cast<UnaryOperator>(S), Ctx);
123     return translateBinaryOperator(cast<BinaryOperator>(S), Ctx);
126     return translateArraySubscriptExpr(cast<ArraySubscriptExpr>(S), Ctx);
128     return translateConditionalOperator(cast<ConditionalOperator>(S), Ctx);
131              cast<BinaryConditionalOperator>(S), Ctx);
135     return translate(cast<ParenExpr>(S)->getSubExpr(), Ctx);
137     return translate(cast<ExprWithCleanups>(S)->getSubExpr(), Ctx);
139     return translate(cast<CXXBindTemporaryExpr>(S)->getSubExpr(), Ctx);
154     return translateDeclStmt(cast<DeclStmt>(S), Ctx);
159     return translateCastExpr(CE, Ctx);
166                                                CallingContext *Ctx) {
175     if (Ctx && Ctx->FunArgs && FD == Ctx->AttrDecl->getCanonicalDecl()) {
177       assert(I < Ctx->NumArgs);
178       return translate(Ctx->FunArgs[I], Ctx->Prev);
191                                                CallingContext *Ctx) {
193   if (Ctx && Ctx->SelfArg)
194     return translate(Ctx->SelfArg, Ctx->Prev);
201                                               CallingContext *Ctx) {
202   til::SExpr *E = translate(ME->getBase(), Ctx);
209                                             CallingContext *Ctx) {
211   til::SExpr *E = translate(CE->getCallee(), Ctx);
213     til::SExpr *A = translate(Arg, Ctx);
221     const CXXMemberCallExpr *ME, CallingContext *Ctx) {
222   return translateCallExpr(cast<CallExpr>(ME), Ctx);
227     const CXXOperatorCallExpr *OCE, CallingContext *Ctx) {
228   return translateCallExpr(cast<CallExpr>(OCE), Ctx);
233                                                  CallingContext *Ctx) {
245     return translate(UO->getSubExpr(), Ctx);
249       til::UnaryOp(til::UOP_Minus, translate(UO->getSubExpr(), Ctx));
252       til::UnaryOp(til::UOP_BitNot, translate(UO->getSubExpr(), Ctx));
255       til::UnaryOp(til::UOP_LogicNot, translate(UO->getSubExpr(), Ctx));
269                                          CallingContext *Ctx, bool Reverse) {
270    til::SExpr *E0 = translate(BO->getLHS(), Ctx);
271    til::SExpr *E1 = translate(BO->getRHS(), Ctx);
281                                              CallingContext *Ctx,
285   til::SExpr *E0 = translate(LHS, Ctx);
286   til::SExpr *E1 = translate(RHS, Ctx);
307                                                   CallingContext *Ctx) {
313   case BO_Mul:  return translateBinOp(til::BOP_Mul, BO, Ctx);
314   case BO_Div:  return translateBinOp(til::BOP_Div, BO, Ctx);
315   case BO_Rem:  return translateBinOp(til::BOP_Rem, BO, Ctx);
316   case BO_Add:  return translateBinOp(til::BOP_Add, BO, Ctx);
317   case BO_Sub:  return translateBinOp(til::BOP_Sub, BO, Ctx);
318   case BO_Shl:  return translateBinOp(til::BOP_Shl, BO, Ctx);
319   case BO_Shr:  return translateBinOp(til::BOP_Shr, BO, Ctx);
320   case BO_LT:   return translateBinOp(til::BOP_Lt,  BO, Ctx);
321   case BO_GT:   return translateBinOp(til::BOP_Lt,  BO, Ctx, true);
322   case BO_LE:   return translateBinOp(til::BOP_Leq, BO, Ctx);
323   case BO_GE:   return translateBinOp(til::BOP_Leq, BO, Ctx, true);
324   case BO_EQ:   return translateBinOp(til::BOP_Eq,  BO, Ctx);
325   case BO_NE:   return translateBinOp(til::BOP_Neq, BO, Ctx);
326   case BO_And:  return translateBinOp(til::BOP_BitAnd,   BO, Ctx);
327   case BO_Xor:  return translateBinOp(til::BOP_BitXor,   BO, Ctx);
328   case BO_Or:   return translateBinOp(til::BOP_BitOr,    BO, Ctx);
329   case BO_LAnd: return translateBinOp(til::BOP_LogicAnd, BO, Ctx);
330   case BO_LOr:  return translateBinOp(til::BOP_LogicOr,  BO, Ctx);
332   case BO_Assign:    return translateBinAssign(til::BOP_Eq,  BO, Ctx, true);
333   case BO_MulAssign: return translateBinAssign(til::BOP_Mul, BO, Ctx);
334   case BO_DivAssign: return translateBinAssign(til::BOP_Div, BO, Ctx);
335   case BO_RemAssign: return translateBinAssign(til::BOP_Rem, BO, Ctx);
336   case BO_AddAssign: return translateBinAssign(til::BOP_Add, BO, Ctx);
337   case BO_SubAssign: return translateBinAssign(til::BOP_Sub, BO, Ctx);
338   case BO_ShlAssign: return translateBinAssign(til::BOP_Shl, BO, Ctx);
339   case BO_ShrAssign: return translateBinAssign(til::BOP_Shr, BO, Ctx);
340   case BO_AndAssign: return translateBinAssign(til::BOP_BitAnd, BO, Ctx);
341   case BO_XorAssign: return translateBinAssign(til::BOP_BitXor, BO, Ctx);
342   case BO_OrAssign:  return translateBinAssign(til::BOP_BitOr,  BO, Ctx);
346     return translate(BO->getRHS(), Ctx);
353                                             CallingContext *Ctx) {
362     til::SExpr *E0 = translate(CE->getSubExpr(), Ctx);
370     til::SExpr *E0 = translate(CE->getSubExpr(), Ctx);
375     til::SExpr *E0 = translate(CE->getSubExpr(), Ctx);
384                                           CallingContext *Ctx) {
385   til::SExpr *E0 = translate(E->getBase(), Ctx);
386   til::SExpr *E1 = translate(E->getIdx(), Ctx);
393                                            CallingContext *Ctx) {
399     const BinaryConditionalOperator *C, CallingContext *Ctx) {
405 SExprBuilder::translateDeclStmt(const DeclStmt *S, CallingContext *Ctx) {
410       til::SExpr* SE = translate(E, Ctx);