1/*
2 * Copyright 2010, The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *     http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include "slang_rs_object_ref_count.h"
18
19#include <list>
20
21#include "clang/AST/DeclGroup.h"
22#include "clang/AST/Expr.h"
23#include "clang/AST/NestedNameSpecifier.h"
24#include "clang/AST/OperationKinds.h"
25#include "clang/AST/Stmt.h"
26#include "clang/AST/StmtVisitor.h"
27
28#include "slang_assert.h"
29#include "slang_rs.h"
30#include "slang_rs_ast_replace.h"
31#include "slang_rs_export_type.h"
32
33namespace slang {
34
35clang::FunctionDecl *RSObjectRefCount::
36    RSSetObjectFD[RSExportPrimitiveType::LastRSObjectType -
37                  RSExportPrimitiveType::FirstRSObjectType + 1];
38clang::FunctionDecl *RSObjectRefCount::
39    RSClearObjectFD[RSExportPrimitiveType::LastRSObjectType -
40                    RSExportPrimitiveType::FirstRSObjectType + 1];
41
42void RSObjectRefCount::GetRSRefCountingFunctions(clang::ASTContext &C) {
43  for (unsigned i = 0;
44       i < (sizeof(RSClearObjectFD) / sizeof(clang::FunctionDecl*));
45       i++) {
46    RSSetObjectFD[i] = NULL;
47    RSClearObjectFD[i] = NULL;
48  }
49
50  clang::TranslationUnitDecl *TUDecl = C.getTranslationUnitDecl();
51
52  for (clang::DeclContext::decl_iterator I = TUDecl->decls_begin(),
53          E = TUDecl->decls_end(); I != E; I++) {
54    if ((I->getKind() >= clang::Decl::firstFunction) &&
55        (I->getKind() <= clang::Decl::lastFunction)) {
56      clang::FunctionDecl *FD = static_cast<clang::FunctionDecl*>(*I);
57
58      // points to RSSetObjectFD or RSClearObjectFD
59      clang::FunctionDecl **RSObjectFD;
60
61      if (FD->getName() == "rsSetObject") {
62        slangAssert((FD->getNumParams() == 2) &&
63                    "Invalid rsSetObject function prototype (# params)");
64        RSObjectFD = RSSetObjectFD;
65      } else if (FD->getName() == "rsClearObject") {
66        slangAssert((FD->getNumParams() == 1) &&
67                    "Invalid rsClearObject function prototype (# params)");
68        RSObjectFD = RSClearObjectFD;
69      } else {
70        continue;
71      }
72
73      const clang::ParmVarDecl *PVD = FD->getParamDecl(0);
74      clang::QualType PVT = PVD->getOriginalType();
75      // The first parameter must be a pointer like rs_allocation*
76      slangAssert(PVT->isPointerType() &&
77          "Invalid rs{Set,Clear}Object function prototype (pointer param)");
78
79      // The rs object type passed to the FD
80      clang::QualType RST = PVT->getPointeeType();
81      RSExportPrimitiveType::DataType DT =
82          RSExportPrimitiveType::GetRSSpecificType(RST.getTypePtr());
83      slangAssert(RSExportPrimitiveType::IsRSObjectType(DT)
84             && "must be RS object type");
85
86      RSObjectFD[(DT - RSExportPrimitiveType::FirstRSObjectType)] = FD;
87    }
88  }
89}
90
91namespace {
92
93// This function constructs a new CompoundStmt from the input StmtList.
94static clang::CompoundStmt* BuildCompoundStmt(clang::ASTContext &C,
95      std::list<clang::Stmt*> &StmtList, clang::SourceLocation Loc) {
96  unsigned NewStmtCount = StmtList.size();
97  unsigned CompoundStmtCount = 0;
98
99  clang::Stmt **CompoundStmtList;
100  CompoundStmtList = new clang::Stmt*[NewStmtCount];
101
102  std::list<clang::Stmt*>::const_iterator I = StmtList.begin();
103  std::list<clang::Stmt*>::const_iterator E = StmtList.end();
104  for ( ; I != E; I++) {
105    CompoundStmtList[CompoundStmtCount++] = *I;
106  }
107  slangAssert(CompoundStmtCount == NewStmtCount);
108
109  clang::CompoundStmt *CS = new(C) clang::CompoundStmt(C,
110                                                       CompoundStmtList,
111                                                       CompoundStmtCount,
112                                                       Loc,
113                                                       Loc);
114
115  delete [] CompoundStmtList;
116
117  return CS;
118}
119
120static void AppendAfterStmt(clang::ASTContext &C,
121                            clang::CompoundStmt *CS,
122                            clang::Stmt *S,
123                            std::list<clang::Stmt*> &StmtList) {
124  slangAssert(CS);
125  clang::CompoundStmt::body_iterator bI = CS->body_begin();
126  clang::CompoundStmt::body_iterator bE = CS->body_end();
127  clang::Stmt **UpdatedStmtList =
128      new clang::Stmt*[CS->size() + StmtList.size()];
129
130  unsigned UpdatedStmtCount = 0;
131  unsigned Once = 0;
132  for ( ; bI != bE; bI++) {
133    if (!S && ((*bI)->getStmtClass() == clang::Stmt::ReturnStmtClass)) {
134      // If we come across a return here, we don't have anything we can
135      // reasonably replace. We should have already inserted our destructor
136      // code in the proper spot, so we just clean up and return.
137      delete [] UpdatedStmtList;
138
139      return;
140    }
141
142    UpdatedStmtList[UpdatedStmtCount++] = *bI;
143
144    if ((*bI == S) && !Once) {
145      Once++;
146      std::list<clang::Stmt*>::const_iterator I = StmtList.begin();
147      std::list<clang::Stmt*>::const_iterator E = StmtList.end();
148      for ( ; I != E; I++) {
149        UpdatedStmtList[UpdatedStmtCount++] = *I;
150      }
151    }
152  }
153  slangAssert(Once <= 1);
154
155  // When S is NULL, we are appending to the end of the CompoundStmt.
156  if (!S) {
157    slangAssert(Once == 0);
158    std::list<clang::Stmt*>::const_iterator I = StmtList.begin();
159    std::list<clang::Stmt*>::const_iterator E = StmtList.end();
160    for ( ; I != E; I++) {
161      UpdatedStmtList[UpdatedStmtCount++] = *I;
162    }
163  }
164
165  CS->setStmts(C, UpdatedStmtList, UpdatedStmtCount);
166
167  delete [] UpdatedStmtList;
168
169  return;
170}
171
172// This class visits a compound statement and inserts DtorStmt
173// in proper locations. This includes inserting it before any
174// return statement in any sub-block, at the end of the logical enclosing
175// scope (compound statement), and/or before any break/continue statement that
176// would resume outside the declared scope. We will not handle the case for
177// goto statements that leave a local scope.
178//
179// To accomplish these goals, it collects a list of sub-Stmt's that
180// correspond to scope exit points. It then uses an RSASTReplace visitor to
181// transform the AST, inserting appropriate destructors before each of those
182// sub-Stmt's (and also before the exit of the outermost containing Stmt for
183// the scope).
184class DestructorVisitor : public clang::StmtVisitor<DestructorVisitor> {
185 private:
186  clang::ASTContext &mCtx;
187
188  // The loop depth of the currently visited node.
189  int mLoopDepth;
190
191  // The switch statement depth of the currently visited node.
192  // Note that this is tracked separately from the loop depth because
193  // SwitchStmt-contained ContinueStmt's should have destructors for the
194  // corresponding loop scope.
195  int mSwitchDepth;
196
197  // The outermost statement block that we are currently visiting.
198  // This should always be a CompoundStmt.
199  clang::Stmt *mOuterStmt;
200
201  // The destructor to execute for this scope/variable.
202  clang::Stmt* mDtorStmt;
203
204  // The stack of statements which should be replaced by a compound statement
205  // containing the new destructor call followed by the original Stmt.
206  std::stack<clang::Stmt*> mReplaceStmtStack;
207
208  // The source location for the variable declaration that we are trying to
209  // insert destructors for. Note that InsertDestructors() will not generate
210  // destructor calls for source locations that occur lexically before this
211  // location.
212  clang::SourceLocation mVarLoc;
213
214 public:
215  DestructorVisitor(clang::ASTContext &C,
216                    clang::Stmt* OuterStmt,
217                    clang::Stmt* DtorStmt,
218                    clang::SourceLocation VarLoc);
219
220  // This code walks the collected list of Stmts to replace and actually does
221  // the replacement. It also finishes up by appending the destructor to the
222  // current outermost CompoundStmt.
223  void InsertDestructors() {
224    clang::Stmt *S = NULL;
225    clang::SourceManager &SM = mCtx.getSourceManager();
226    std::list<clang::Stmt *> StmtList;
227    StmtList.push_back(mDtorStmt);
228
229    while (!mReplaceStmtStack.empty()) {
230      S = mReplaceStmtStack.top();
231      mReplaceStmtStack.pop();
232
233      // Skip all source locations that occur before the variable's
234      // declaration, since it won't have been initialized yet.
235      if (SM.isBeforeInTranslationUnit(S->getLocStart(), mVarLoc)) {
236        continue;
237      }
238
239      StmtList.push_back(S);
240      clang::CompoundStmt *CS =
241          BuildCompoundStmt(mCtx, StmtList, S->getLocEnd());
242      StmtList.pop_back();
243
244      RSASTReplace R(mCtx);
245      R.ReplaceStmt(mOuterStmt, S, CS);
246    }
247    clang::CompoundStmt *CS =
248      llvm::dyn_cast<clang::CompoundStmt>(mOuterStmt);
249    slangAssert(CS);
250    AppendAfterStmt(mCtx, CS, NULL, StmtList);
251  }
252
253  void VisitStmt(clang::Stmt *S);
254  void VisitCompoundStmt(clang::CompoundStmt *CS);
255
256  void VisitBreakStmt(clang::BreakStmt *BS);
257  void VisitCaseStmt(clang::CaseStmt *CS);
258  void VisitContinueStmt(clang::ContinueStmt *CS);
259  void VisitDefaultStmt(clang::DefaultStmt *DS);
260  void VisitDoStmt(clang::DoStmt *DS);
261  void VisitForStmt(clang::ForStmt *FS);
262  void VisitIfStmt(clang::IfStmt *IS);
263  void VisitReturnStmt(clang::ReturnStmt *RS);
264  void VisitSwitchCase(clang::SwitchCase *SC);
265  void VisitSwitchStmt(clang::SwitchStmt *SS);
266  void VisitWhileStmt(clang::WhileStmt *WS);
267};
268
269DestructorVisitor::DestructorVisitor(clang::ASTContext &C,
270                         clang::Stmt *OuterStmt,
271                         clang::Stmt *DtorStmt,
272                         clang::SourceLocation VarLoc)
273  : mCtx(C),
274    mLoopDepth(0),
275    mSwitchDepth(0),
276    mOuterStmt(OuterStmt),
277    mDtorStmt(DtorStmt),
278    mVarLoc(VarLoc) {
279  return;
280}
281
282void DestructorVisitor::VisitStmt(clang::Stmt *S) {
283  for (clang::Stmt::child_iterator I = S->child_begin(), E = S->child_end();
284       I != E;
285       I++) {
286    if (clang::Stmt *Child = *I) {
287      Visit(Child);
288    }
289  }
290  return;
291}
292
293void DestructorVisitor::VisitCompoundStmt(clang::CompoundStmt *CS) {
294  VisitStmt(CS);
295  return;
296}
297
298void DestructorVisitor::VisitBreakStmt(clang::BreakStmt *BS) {
299  VisitStmt(BS);
300  if ((mLoopDepth == 0) && (mSwitchDepth == 0)) {
301    mReplaceStmtStack.push(BS);
302  }
303  return;
304}
305
306void DestructorVisitor::VisitCaseStmt(clang::CaseStmt *CS) {
307  VisitStmt(CS);
308  return;
309}
310
311void DestructorVisitor::VisitContinueStmt(clang::ContinueStmt *CS) {
312  VisitStmt(CS);
313  if (mLoopDepth == 0) {
314    // Switch statements can have nested continues.
315    mReplaceStmtStack.push(CS);
316  }
317  return;
318}
319
320void DestructorVisitor::VisitDefaultStmt(clang::DefaultStmt *DS) {
321  VisitStmt(DS);
322  return;
323}
324
325void DestructorVisitor::VisitDoStmt(clang::DoStmt *DS) {
326  mLoopDepth++;
327  VisitStmt(DS);
328  mLoopDepth--;
329  return;
330}
331
332void DestructorVisitor::VisitForStmt(clang::ForStmt *FS) {
333  mLoopDepth++;
334  VisitStmt(FS);
335  mLoopDepth--;
336  return;
337}
338
339void DestructorVisitor::VisitIfStmt(clang::IfStmt *IS) {
340  VisitStmt(IS);
341  return;
342}
343
344void DestructorVisitor::VisitReturnStmt(clang::ReturnStmt *RS) {
345  mReplaceStmtStack.push(RS);
346  return;
347}
348
349void DestructorVisitor::VisitSwitchCase(clang::SwitchCase *SC) {
350  slangAssert(false && "Both case and default have specialized handlers");
351  VisitStmt(SC);
352  return;
353}
354
355void DestructorVisitor::VisitSwitchStmt(clang::SwitchStmt *SS) {
356  mSwitchDepth++;
357  VisitStmt(SS);
358  mSwitchDepth--;
359  return;
360}
361
362void DestructorVisitor::VisitWhileStmt(clang::WhileStmt *WS) {
363  mLoopDepth++;
364  VisitStmt(WS);
365  mLoopDepth--;
366  return;
367}
368
369clang::Expr *ClearSingleRSObject(clang::ASTContext &C,
370                                 clang::Expr *RefRSVar,
371                                 clang::SourceLocation Loc) {
372  slangAssert(RefRSVar);
373  const clang::Type *T = RefRSVar->getType().getTypePtr();
374  slangAssert(!T->isArrayType() &&
375              "Should not be destroying arrays with this function");
376
377  clang::FunctionDecl *ClearObjectFD = RSObjectRefCount::GetRSClearObjectFD(T);
378  slangAssert((ClearObjectFD != NULL) &&
379              "rsClearObject doesn't cover all RS object types");
380
381  clang::QualType ClearObjectFDType = ClearObjectFD->getType();
382  clang::QualType ClearObjectFDArgType =
383      ClearObjectFD->getParamDecl(0)->getOriginalType();
384
385  // Example destructor for "rs_font localFont;"
386  //
387  // (CallExpr 'void'
388  //   (ImplicitCastExpr 'void (*)(rs_font *)' <FunctionToPointerDecay>
389  //     (DeclRefExpr 'void (rs_font *)' FunctionDecl='rsClearObject'))
390  //   (UnaryOperator 'rs_font *' prefix '&'
391  //     (DeclRefExpr 'rs_font':'rs_font' Var='localFont')))
392
393  // Get address of targeted RS object
394  clang::Expr *AddrRefRSVar =
395      new(C) clang::UnaryOperator(RefRSVar,
396                                  clang::UO_AddrOf,
397                                  ClearObjectFDArgType,
398                                  clang::VK_RValue,
399                                  clang::OK_Ordinary,
400                                  Loc);
401
402  clang::Expr *RefRSClearObjectFD =
403      clang::DeclRefExpr::Create(C,
404                                 clang::NestedNameSpecifierLoc(),
405                                 clang::SourceLocation(),
406                                 ClearObjectFD,
407                                 false,
408                                 ClearObjectFD->getLocation(),
409                                 ClearObjectFDType,
410                                 clang::VK_RValue,
411                                 NULL);
412
413  clang::Expr *RSClearObjectFP =
414      clang::ImplicitCastExpr::Create(C,
415                                      C.getPointerType(ClearObjectFDType),
416                                      clang::CK_FunctionToPointerDecay,
417                                      RefRSClearObjectFD,
418                                      NULL,
419                                      clang::VK_RValue);
420
421  llvm::SmallVector<clang::Expr*, 1> ArgList;
422  ArgList.push_back(AddrRefRSVar);
423
424  clang::CallExpr *RSClearObjectCall =
425      new(C) clang::CallExpr(C,
426                             RSClearObjectFP,
427                             ArgList,
428                             ClearObjectFD->getCallResultType(),
429                             clang::VK_RValue,
430                             Loc);
431
432  return RSClearObjectCall;
433}
434
435static int ArrayDim(const clang::Type *T) {
436  if (!T || !T->isArrayType()) {
437    return 0;
438  }
439
440  const clang::ConstantArrayType *CAT =
441    static_cast<const clang::ConstantArrayType *>(T);
442  return static_cast<int>(CAT->getSize().getSExtValue());
443}
444
445static clang::Stmt *ClearStructRSObject(
446    clang::ASTContext &C,
447    clang::DeclContext *DC,
448    clang::Expr *RefRSStruct,
449    clang::SourceLocation StartLoc,
450    clang::SourceLocation Loc);
451
452static clang::Stmt *ClearArrayRSObject(
453    clang::ASTContext &C,
454    clang::DeclContext *DC,
455    clang::Expr *RefRSArr,
456    clang::SourceLocation StartLoc,
457    clang::SourceLocation Loc) {
458  const clang::Type *BaseType = RefRSArr->getType().getTypePtr();
459  slangAssert(BaseType->isArrayType());
460
461  int NumArrayElements = ArrayDim(BaseType);
462  // Actually extract out the base RS object type for use later
463  BaseType = BaseType->getArrayElementTypeNoTypeQual();
464
465  clang::Stmt *StmtArray[2] = {NULL};
466  int StmtCtr = 0;
467
468  if (NumArrayElements <= 0) {
469    return NULL;
470  }
471
472  // Example destructor loop for "rs_font fontArr[10];"
473  //
474  // (CompoundStmt
475  //   (DeclStmt "int rsIntIter")
476  //   (ForStmt
477  //     (BinaryOperator 'int' '='
478  //       (DeclRefExpr 'int' Var='rsIntIter')
479  //       (IntegerLiteral 'int' 0))
480  //     (BinaryOperator 'int' '<'
481  //       (DeclRefExpr 'int' Var='rsIntIter')
482  //       (IntegerLiteral 'int' 10)
483  //     NULL << CondVar >>
484  //     (UnaryOperator 'int' postfix '++'
485  //       (DeclRefExpr 'int' Var='rsIntIter'))
486  //     (CallExpr 'void'
487  //       (ImplicitCastExpr 'void (*)(rs_font *)' <FunctionToPointerDecay>
488  //         (DeclRefExpr 'void (rs_font *)' FunctionDecl='rsClearObject'))
489  //       (UnaryOperator 'rs_font *' prefix '&'
490  //         (ArraySubscriptExpr 'rs_font':'rs_font'
491  //           (ImplicitCastExpr 'rs_font *' <ArrayToPointerDecay>
492  //             (DeclRefExpr 'rs_font [10]' Var='fontArr'))
493  //           (DeclRefExpr 'int' Var='rsIntIter')))))))
494
495  // Create helper variable for iterating through elements
496  clang::IdentifierInfo& II = C.Idents.get("rsIntIter");
497  clang::VarDecl *IIVD =
498      clang::VarDecl::Create(C,
499                             DC,
500                             StartLoc,
501                             Loc,
502                             &II,
503                             C.IntTy,
504                             C.getTrivialTypeSourceInfo(C.IntTy),
505                             clang::SC_None,
506                             clang::SC_None);
507  clang::Decl *IID = (clang::Decl *)IIVD;
508
509  clang::DeclGroupRef DGR = clang::DeclGroupRef::Create(C, &IID, 1);
510  StmtArray[StmtCtr++] = new(C) clang::DeclStmt(DGR, Loc, Loc);
511
512  // Form the actual destructor loop
513  // for (Init; Cond; Inc)
514  //   RSClearObjectCall;
515
516  // Init -> "rsIntIter = 0"
517  clang::DeclRefExpr *RefrsIntIter =
518      clang::DeclRefExpr::Create(C,
519                                 clang::NestedNameSpecifierLoc(),
520                                 clang::SourceLocation(),
521                                 IIVD,
522                                 false,
523                                 Loc,
524                                 C.IntTy,
525                                 clang::VK_RValue,
526                                 NULL);
527
528  clang::Expr *Int0 = clang::IntegerLiteral::Create(C,
529      llvm::APInt(C.getTypeSize(C.IntTy), 0), C.IntTy, Loc);
530
531  clang::BinaryOperator *Init =
532      new(C) clang::BinaryOperator(RefrsIntIter,
533                                   Int0,
534                                   clang::BO_Assign,
535                                   C.IntTy,
536                                   clang::VK_RValue,
537                                   clang::OK_Ordinary,
538                                   Loc);
539
540  // Cond -> "rsIntIter < NumArrayElements"
541  clang::Expr *NumArrayElementsExpr = clang::IntegerLiteral::Create(C,
542      llvm::APInt(C.getTypeSize(C.IntTy), NumArrayElements), C.IntTy, Loc);
543
544  clang::BinaryOperator *Cond =
545      new(C) clang::BinaryOperator(RefrsIntIter,
546                                   NumArrayElementsExpr,
547                                   clang::BO_LT,
548                                   C.IntTy,
549                                   clang::VK_RValue,
550                                   clang::OK_Ordinary,
551                                   Loc);
552
553  // Inc -> "rsIntIter++"
554  clang::UnaryOperator *Inc =
555      new(C) clang::UnaryOperator(RefrsIntIter,
556                                  clang::UO_PostInc,
557                                  C.IntTy,
558                                  clang::VK_RValue,
559                                  clang::OK_Ordinary,
560                                  Loc);
561
562  // Body -> "rsClearObject(&VD[rsIntIter]);"
563  // Destructor loop operates on individual array elements
564
565  clang::Expr *RefRSArrPtr =
566      clang::ImplicitCastExpr::Create(C,
567          C.getPointerType(BaseType->getCanonicalTypeInternal()),
568          clang::CK_ArrayToPointerDecay,
569          RefRSArr,
570          NULL,
571          clang::VK_RValue);
572
573  clang::Expr *RefRSArrPtrSubscript =
574      new(C) clang::ArraySubscriptExpr(RefRSArrPtr,
575                                       RefrsIntIter,
576                                       BaseType->getCanonicalTypeInternal(),
577                                       clang::VK_RValue,
578                                       clang::OK_Ordinary,
579                                       Loc);
580
581  RSExportPrimitiveType::DataType DT =
582      RSExportPrimitiveType::GetRSSpecificType(BaseType);
583
584  clang::Stmt *RSClearObjectCall = NULL;
585  if (BaseType->isArrayType()) {
586    RSClearObjectCall =
587        ClearArrayRSObject(C, DC, RefRSArrPtrSubscript, StartLoc, Loc);
588  } else if (DT == RSExportPrimitiveType::DataTypeUnknown) {
589    RSClearObjectCall =
590        ClearStructRSObject(C, DC, RefRSArrPtrSubscript, StartLoc, Loc);
591  } else {
592    RSClearObjectCall = ClearSingleRSObject(C, RefRSArrPtrSubscript, Loc);
593  }
594
595  clang::ForStmt *DestructorLoop =
596      new(C) clang::ForStmt(C,
597                            Init,
598                            Cond,
599                            NULL,  // no condVar
600                            Inc,
601                            RSClearObjectCall,
602                            Loc,
603                            Loc,
604                            Loc);
605
606  StmtArray[StmtCtr++] = DestructorLoop;
607  slangAssert(StmtCtr == 2);
608
609  clang::CompoundStmt *CS =
610      new(C) clang::CompoundStmt(C, StmtArray, StmtCtr, Loc, Loc);
611
612  return CS;
613}
614
615static unsigned CountRSObjectTypes(clang::ASTContext &C,
616                                   const clang::Type *T,
617                                   clang::SourceLocation Loc) {
618  slangAssert(T);
619  unsigned RSObjectCount = 0;
620
621  if (T->isArrayType()) {
622    return CountRSObjectTypes(C, T->getArrayElementTypeNoTypeQual(), Loc);
623  }
624
625  RSExportPrimitiveType::DataType DT =
626      RSExportPrimitiveType::GetRSSpecificType(T);
627  if (DT != RSExportPrimitiveType::DataTypeUnknown) {
628    return (RSExportPrimitiveType::IsRSObjectType(DT) ? 1 : 0);
629  }
630
631  if (T->isUnionType()) {
632    clang::RecordDecl *RD = T->getAsUnionType()->getDecl();
633    RD = RD->getDefinition();
634    for (clang::RecordDecl::field_iterator FI = RD->field_begin(),
635           FE = RD->field_end();
636         FI != FE;
637         FI++) {
638      const clang::FieldDecl *FD = *FI;
639      const clang::Type *FT = RSExportType::GetTypeOfDecl(FD);
640      if (CountRSObjectTypes(C, FT, Loc)) {
641        slangAssert(false && "can't have unions with RS object types!");
642        return 0;
643      }
644    }
645  }
646
647  if (!T->isStructureType()) {
648    return 0;
649  }
650
651  clang::RecordDecl *RD = T->getAsStructureType()->getDecl();
652  RD = RD->getDefinition();
653  for (clang::RecordDecl::field_iterator FI = RD->field_begin(),
654         FE = RD->field_end();
655       FI != FE;
656       FI++) {
657    const clang::FieldDecl *FD = *FI;
658    const clang::Type *FT = RSExportType::GetTypeOfDecl(FD);
659    if (CountRSObjectTypes(C, FT, Loc)) {
660      // Sub-structs should only count once (as should arrays, etc.)
661      RSObjectCount++;
662    }
663  }
664
665  return RSObjectCount;
666}
667
668static clang::Stmt *ClearStructRSObject(
669    clang::ASTContext &C,
670    clang::DeclContext *DC,
671    clang::Expr *RefRSStruct,
672    clang::SourceLocation StartLoc,
673    clang::SourceLocation Loc) {
674  const clang::Type *BaseType = RefRSStruct->getType().getTypePtr();
675
676  slangAssert(!BaseType->isArrayType());
677
678  // Structs should show up as unknown primitive types
679  slangAssert(RSExportPrimitiveType::GetRSSpecificType(BaseType) ==
680              RSExportPrimitiveType::DataTypeUnknown);
681
682  unsigned FieldsToDestroy = CountRSObjectTypes(C, BaseType, Loc);
683
684  unsigned StmtCount = 0;
685  clang::Stmt **StmtArray = new clang::Stmt*[FieldsToDestroy];
686  for (unsigned i = 0; i < FieldsToDestroy; i++) {
687    StmtArray[i] = NULL;
688  }
689
690  // Populate StmtArray by creating a destructor for each RS object field
691  clang::RecordDecl *RD = BaseType->getAsStructureType()->getDecl();
692  RD = RD->getDefinition();
693  for (clang::RecordDecl::field_iterator FI = RD->field_begin(),
694         FE = RD->field_end();
695       FI != FE;
696       FI++) {
697    // We just look through all field declarations to see if we find a
698    // declaration for an RS object type (or an array of one).
699    bool IsArrayType = false;
700    clang::FieldDecl *FD = *FI;
701    const clang::Type *FT = RSExportType::GetTypeOfDecl(FD);
702    const clang::Type *OrigType = FT;
703    while (FT && FT->isArrayType()) {
704      FT = FT->getArrayElementTypeNoTypeQual();
705      IsArrayType = true;
706    }
707
708    if (RSExportPrimitiveType::IsRSObjectType(FT)) {
709      clang::DeclAccessPair FoundDecl =
710          clang::DeclAccessPair::make(FD, clang::AS_none);
711      clang::MemberExpr *RSObjectMember =
712          clang::MemberExpr::Create(C,
713                                    RefRSStruct,
714                                    false,
715                                    clang::NestedNameSpecifierLoc(),
716                                    clang::SourceLocation(),
717                                    FD,
718                                    FoundDecl,
719                                    clang::DeclarationNameInfo(),
720                                    NULL,
721                                    OrigType->getCanonicalTypeInternal(),
722                                    clang::VK_RValue,
723                                    clang::OK_Ordinary);
724
725      slangAssert(StmtCount < FieldsToDestroy);
726
727      if (IsArrayType) {
728        StmtArray[StmtCount++] = ClearArrayRSObject(C,
729                                                    DC,
730                                                    RSObjectMember,
731                                                    StartLoc,
732                                                    Loc);
733      } else {
734        StmtArray[StmtCount++] = ClearSingleRSObject(C,
735                                                     RSObjectMember,
736                                                     Loc);
737      }
738    } else if (FT->isStructureType() && CountRSObjectTypes(C, FT, Loc)) {
739      // In this case, we have a nested struct. We may not end up filling all
740      // of the spaces in StmtArray (sub-structs should handle themselves
741      // with separate compound statements).
742      clang::DeclAccessPair FoundDecl =
743          clang::DeclAccessPair::make(FD, clang::AS_none);
744      clang::MemberExpr *RSObjectMember =
745          clang::MemberExpr::Create(C,
746                                    RefRSStruct,
747                                    false,
748                                    clang::NestedNameSpecifierLoc(),
749                                    clang::SourceLocation(),
750                                    FD,
751                                    FoundDecl,
752                                    clang::DeclarationNameInfo(),
753                                    NULL,
754                                    OrigType->getCanonicalTypeInternal(),
755                                    clang::VK_RValue,
756                                    clang::OK_Ordinary);
757
758      if (IsArrayType) {
759        StmtArray[StmtCount++] = ClearArrayRSObject(C,
760                                                    DC,
761                                                    RSObjectMember,
762                                                    StartLoc,
763                                                    Loc);
764      } else {
765        StmtArray[StmtCount++] = ClearStructRSObject(C,
766                                                     DC,
767                                                     RSObjectMember,
768                                                     StartLoc,
769                                                     Loc);
770      }
771    }
772  }
773
774  slangAssert(StmtCount > 0);
775  clang::CompoundStmt *CS =
776      new(C) clang::CompoundStmt(C, StmtArray, StmtCount, Loc, Loc);
777
778  delete [] StmtArray;
779
780  return CS;
781}
782
783static clang::Stmt *CreateSingleRSSetObject(clang::ASTContext &C,
784                                            clang::Expr *DstExpr,
785                                            clang::Expr *SrcExpr,
786                                            clang::SourceLocation StartLoc,
787                                            clang::SourceLocation Loc) {
788  const clang::Type *T = DstExpr->getType().getTypePtr();
789  clang::FunctionDecl *SetObjectFD = RSObjectRefCount::GetRSSetObjectFD(T);
790  slangAssert((SetObjectFD != NULL) &&
791              "rsSetObject doesn't cover all RS object types");
792
793  clang::QualType SetObjectFDType = SetObjectFD->getType();
794  clang::QualType SetObjectFDArgType[2];
795  SetObjectFDArgType[0] = SetObjectFD->getParamDecl(0)->getOriginalType();
796  SetObjectFDArgType[1] = SetObjectFD->getParamDecl(1)->getOriginalType();
797
798  clang::Expr *RefRSSetObjectFD =
799      clang::DeclRefExpr::Create(C,
800                                 clang::NestedNameSpecifierLoc(),
801                                 clang::SourceLocation(),
802                                 SetObjectFD,
803                                 false,
804                                 Loc,
805                                 SetObjectFDType,
806                                 clang::VK_RValue,
807                                 NULL);
808
809  clang::Expr *RSSetObjectFP =
810      clang::ImplicitCastExpr::Create(C,
811                                      C.getPointerType(SetObjectFDType),
812                                      clang::CK_FunctionToPointerDecay,
813                                      RefRSSetObjectFD,
814                                      NULL,
815                                      clang::VK_RValue);
816
817  llvm::SmallVector<clang::Expr*, 2> ArgList;
818  ArgList.push_back(new(C) clang::UnaryOperator(DstExpr,
819                                                clang::UO_AddrOf,
820                                                SetObjectFDArgType[0],
821                                                clang::VK_RValue,
822                                                clang::OK_Ordinary,
823                                                Loc));
824  ArgList.push_back(SrcExpr);
825
826  clang::CallExpr *RSSetObjectCall =
827      new(C) clang::CallExpr(C,
828                             RSSetObjectFP,
829                             ArgList,
830                             SetObjectFD->getCallResultType(),
831                             clang::VK_RValue,
832                             Loc);
833
834  return RSSetObjectCall;
835}
836
837static clang::Stmt *CreateStructRSSetObject(clang::ASTContext &C,
838                                            clang::Expr *LHS,
839                                            clang::Expr *RHS,
840                                            clang::SourceLocation StartLoc,
841                                            clang::SourceLocation Loc);
842
843/*static clang::Stmt *CreateArrayRSSetObject(clang::ASTContext &C,
844                                           clang::Expr *DstArr,
845                                           clang::Expr *SrcArr,
846                                           clang::SourceLocation StartLoc,
847                                           clang::SourceLocation Loc) {
848  clang::DeclContext *DC = NULL;
849  const clang::Type *BaseType = DstArr->getType().getTypePtr();
850  slangAssert(BaseType->isArrayType());
851
852  int NumArrayElements = ArrayDim(BaseType);
853  // Actually extract out the base RS object type for use later
854  BaseType = BaseType->getArrayElementTypeNoTypeQual();
855
856  clang::Stmt *StmtArray[2] = {NULL};
857  int StmtCtr = 0;
858
859  if (NumArrayElements <= 0) {
860    return NULL;
861  }
862
863  // Create helper variable for iterating through elements
864  clang::IdentifierInfo& II = C.Idents.get("rsIntIter");
865  clang::VarDecl *IIVD =
866      clang::VarDecl::Create(C,
867                             DC,
868                             StartLoc,
869                             Loc,
870                             &II,
871                             C.IntTy,
872                             C.getTrivialTypeSourceInfo(C.IntTy),
873                             clang::SC_None,
874                             clang::SC_None);
875  clang::Decl *IID = (clang::Decl *)IIVD;
876
877  clang::DeclGroupRef DGR = clang::DeclGroupRef::Create(C, &IID, 1);
878  StmtArray[StmtCtr++] = new(C) clang::DeclStmt(DGR, Loc, Loc);
879
880  // Form the actual loop
881  // for (Init; Cond; Inc)
882  //   RSSetObjectCall;
883
884  // Init -> "rsIntIter = 0"
885  clang::DeclRefExpr *RefrsIntIter =
886      clang::DeclRefExpr::Create(C,
887                                 clang::NestedNameSpecifierLoc(),
888                                 IIVD,
889                                 Loc,
890                                 C.IntTy,
891                                 clang::VK_RValue,
892                                 NULL);
893
894  clang::Expr *Int0 = clang::IntegerLiteral::Create(C,
895      llvm::APInt(C.getTypeSize(C.IntTy), 0), C.IntTy, Loc);
896
897  clang::BinaryOperator *Init =
898      new(C) clang::BinaryOperator(RefrsIntIter,
899                                   Int0,
900                                   clang::BO_Assign,
901                                   C.IntTy,
902                                   clang::VK_RValue,
903                                   clang::OK_Ordinary,
904                                   Loc);
905
906  // Cond -> "rsIntIter < NumArrayElements"
907  clang::Expr *NumArrayElementsExpr = clang::IntegerLiteral::Create(C,
908      llvm::APInt(C.getTypeSize(C.IntTy), NumArrayElements), C.IntTy, Loc);
909
910  clang::BinaryOperator *Cond =
911      new(C) clang::BinaryOperator(RefrsIntIter,
912                                   NumArrayElementsExpr,
913                                   clang::BO_LT,
914                                   C.IntTy,
915                                   clang::VK_RValue,
916                                   clang::OK_Ordinary,
917                                   Loc);
918
919  // Inc -> "rsIntIter++"
920  clang::UnaryOperator *Inc =
921      new(C) clang::UnaryOperator(RefrsIntIter,
922                                  clang::UO_PostInc,
923                                  C.IntTy,
924                                  clang::VK_RValue,
925                                  clang::OK_Ordinary,
926                                  Loc);
927
928  // Body -> "rsSetObject(&Dst[rsIntIter], Src[rsIntIter]);"
929  // Loop operates on individual array elements
930
931  clang::Expr *DstArrPtr =
932      clang::ImplicitCastExpr::Create(C,
933          C.getPointerType(BaseType->getCanonicalTypeInternal()),
934          clang::CK_ArrayToPointerDecay,
935          DstArr,
936          NULL,
937          clang::VK_RValue);
938
939  clang::Expr *DstArrPtrSubscript =
940      new(C) clang::ArraySubscriptExpr(DstArrPtr,
941                                       RefrsIntIter,
942                                       BaseType->getCanonicalTypeInternal(),
943                                       clang::VK_RValue,
944                                       clang::OK_Ordinary,
945                                       Loc);
946
947  clang::Expr *SrcArrPtr =
948      clang::ImplicitCastExpr::Create(C,
949          C.getPointerType(BaseType->getCanonicalTypeInternal()),
950          clang::CK_ArrayToPointerDecay,
951          SrcArr,
952          NULL,
953          clang::VK_RValue);
954
955  clang::Expr *SrcArrPtrSubscript =
956      new(C) clang::ArraySubscriptExpr(SrcArrPtr,
957                                       RefrsIntIter,
958                                       BaseType->getCanonicalTypeInternal(),
959                                       clang::VK_RValue,
960                                       clang::OK_Ordinary,
961                                       Loc);
962
963  RSExportPrimitiveType::DataType DT =
964      RSExportPrimitiveType::GetRSSpecificType(BaseType);
965
966  clang::Stmt *RSSetObjectCall = NULL;
967  if (BaseType->isArrayType()) {
968    RSSetObjectCall = CreateArrayRSSetObject(C, DstArrPtrSubscript,
969                                             SrcArrPtrSubscript,
970                                             StartLoc, Loc);
971  } else if (DT == RSExportPrimitiveType::DataTypeUnknown) {
972    RSSetObjectCall = CreateStructRSSetObject(C, DstArrPtrSubscript,
973                                              SrcArrPtrSubscript,
974                                              StartLoc, Loc);
975  } else {
976    RSSetObjectCall = CreateSingleRSSetObject(C, DstArrPtrSubscript,
977                                              SrcArrPtrSubscript,
978                                              StartLoc, Loc);
979  }
980
981  clang::ForStmt *DestructorLoop =
982      new(C) clang::ForStmt(C,
983                            Init,
984                            Cond,
985                            NULL,  // no condVar
986                            Inc,
987                            RSSetObjectCall,
988                            Loc,
989                            Loc,
990                            Loc);
991
992  StmtArray[StmtCtr++] = DestructorLoop;
993  slangAssert(StmtCtr == 2);
994
995  clang::CompoundStmt *CS =
996      new(C) clang::CompoundStmt(C, StmtArray, StmtCtr, Loc, Loc);
997
998  return CS;
999} */
1000
1001static clang::Stmt *CreateStructRSSetObject(clang::ASTContext &C,
1002                                            clang::Expr *LHS,
1003                                            clang::Expr *RHS,
1004                                            clang::SourceLocation StartLoc,
1005                                            clang::SourceLocation Loc) {
1006  clang::QualType QT = LHS->getType();
1007  const clang::Type *T = QT.getTypePtr();
1008  slangAssert(T->isStructureType());
1009  slangAssert(!RSExportPrimitiveType::IsRSObjectType(T));
1010
1011  // Keep an extra slot for the original copy (memcpy)
1012  unsigned FieldsToSet = CountRSObjectTypes(C, T, Loc) + 1;
1013
1014  unsigned StmtCount = 0;
1015  clang::Stmt **StmtArray = new clang::Stmt*[FieldsToSet];
1016  for (unsigned i = 0; i < FieldsToSet; i++) {
1017    StmtArray[i] = NULL;
1018  }
1019
1020  clang::RecordDecl *RD = T->getAsStructureType()->getDecl();
1021  RD = RD->getDefinition();
1022  for (clang::RecordDecl::field_iterator FI = RD->field_begin(),
1023         FE = RD->field_end();
1024       FI != FE;
1025       FI++) {
1026    bool IsArrayType = false;
1027    clang::FieldDecl *FD = *FI;
1028    const clang::Type *FT = RSExportType::GetTypeOfDecl(FD);
1029    const clang::Type *OrigType = FT;
1030
1031    if (!CountRSObjectTypes(C, FT, Loc)) {
1032      // Skip to next if we don't have any viable RS object types
1033      continue;
1034    }
1035
1036    clang::DeclAccessPair FoundDecl =
1037        clang::DeclAccessPair::make(FD, clang::AS_none);
1038    clang::MemberExpr *DstMember =
1039        clang::MemberExpr::Create(C,
1040                                  LHS,
1041                                  false,
1042                                  clang::NestedNameSpecifierLoc(),
1043                                  clang::SourceLocation(),
1044                                  FD,
1045                                  FoundDecl,
1046                                  clang::DeclarationNameInfo(),
1047                                  NULL,
1048                                  OrigType->getCanonicalTypeInternal(),
1049                                  clang::VK_RValue,
1050                                  clang::OK_Ordinary);
1051
1052    clang::MemberExpr *SrcMember =
1053        clang::MemberExpr::Create(C,
1054                                  RHS,
1055                                  false,
1056                                  clang::NestedNameSpecifierLoc(),
1057                                  clang::SourceLocation(),
1058                                  FD,
1059                                  FoundDecl,
1060                                  clang::DeclarationNameInfo(),
1061                                  NULL,
1062                                  OrigType->getCanonicalTypeInternal(),
1063                                  clang::VK_RValue,
1064                                  clang::OK_Ordinary);
1065
1066    if (FT->isArrayType()) {
1067      FT = FT->getArrayElementTypeNoTypeQual();
1068      IsArrayType = true;
1069    }
1070
1071    RSExportPrimitiveType::DataType DT =
1072        RSExportPrimitiveType::GetRSSpecificType(FT);
1073
1074    if (IsArrayType) {
1075      clang::DiagnosticsEngine &DiagEngine = C.getDiagnostics();
1076      DiagEngine.Report(
1077        clang::FullSourceLoc(Loc, C.getSourceManager()),
1078        DiagEngine.getCustomDiagID(
1079          clang::DiagnosticsEngine::Error,
1080          "Arrays of RS object types within structures cannot be copied"));
1081      // TODO(srhines): Support setting arrays of RS objects
1082      // StmtArray[StmtCount++] =
1083      //    CreateArrayRSSetObject(C, DstMember, SrcMember, StartLoc, Loc);
1084    } else if (DT == RSExportPrimitiveType::DataTypeUnknown) {
1085      StmtArray[StmtCount++] =
1086          CreateStructRSSetObject(C, DstMember, SrcMember, StartLoc, Loc);
1087    } else if (RSExportPrimitiveType::IsRSObjectType(DT)) {
1088      StmtArray[StmtCount++] =
1089          CreateSingleRSSetObject(C, DstMember, SrcMember, StartLoc, Loc);
1090    } else {
1091      slangAssert(false);
1092    }
1093  }
1094
1095  slangAssert(StmtCount > 0 && StmtCount < FieldsToSet);
1096
1097  // We still need to actually do the overall struct copy. For simplicity,
1098  // we just do a straight-up assignment (which will still preserve all
1099  // the proper RS object reference counts).
1100  clang::BinaryOperator *CopyStruct =
1101      new(C) clang::BinaryOperator(LHS, RHS, clang::BO_Assign, QT,
1102                                   clang::VK_RValue, clang::OK_Ordinary, Loc);
1103  StmtArray[StmtCount++] = CopyStruct;
1104
1105  clang::CompoundStmt *CS =
1106      new(C) clang::CompoundStmt(C, StmtArray, StmtCount, Loc, Loc);
1107
1108  delete [] StmtArray;
1109
1110  return CS;
1111}
1112
1113}  // namespace
1114
1115void RSObjectRefCount::Scope::ReplaceRSObjectAssignment(
1116    clang::BinaryOperator *AS) {
1117
1118  clang::QualType QT = AS->getType();
1119
1120  clang::ASTContext &C = RSObjectRefCount::GetRSSetObjectFD(
1121      RSExportPrimitiveType::DataTypeRSFont)->getASTContext();
1122
1123  clang::SourceLocation Loc = AS->getExprLoc();
1124  clang::SourceLocation StartLoc = AS->getLHS()->getExprLoc();
1125  clang::Stmt *UpdatedStmt = NULL;
1126
1127  if (!RSExportPrimitiveType::IsRSObjectType(QT.getTypePtr())) {
1128    // By definition, this is a struct assignment if we get here
1129    UpdatedStmt =
1130        CreateStructRSSetObject(C, AS->getLHS(), AS->getRHS(), StartLoc, Loc);
1131  } else {
1132    UpdatedStmt =
1133        CreateSingleRSSetObject(C, AS->getLHS(), AS->getRHS(), StartLoc, Loc);
1134  }
1135
1136  RSASTReplace R(C);
1137  R.ReplaceStmt(mCS, AS, UpdatedStmt);
1138  return;
1139}
1140
1141void RSObjectRefCount::Scope::AppendRSObjectInit(
1142    clang::VarDecl *VD,
1143    clang::DeclStmt *DS,
1144    RSExportPrimitiveType::DataType DT,
1145    clang::Expr *InitExpr) {
1146  slangAssert(VD);
1147
1148  if (!InitExpr) {
1149    return;
1150  }
1151
1152  clang::ASTContext &C = RSObjectRefCount::GetRSSetObjectFD(
1153      RSExportPrimitiveType::DataTypeRSFont)->getASTContext();
1154  clang::SourceLocation Loc = RSObjectRefCount::GetRSSetObjectFD(
1155      RSExportPrimitiveType::DataTypeRSFont)->getLocation();
1156  clang::SourceLocation StartLoc = RSObjectRefCount::GetRSSetObjectFD(
1157      RSExportPrimitiveType::DataTypeRSFont)->getInnerLocStart();
1158
1159  if (DT == RSExportPrimitiveType::DataTypeIsStruct) {
1160    const clang::Type *T = RSExportType::GetTypeOfDecl(VD);
1161    clang::DeclRefExpr *RefRSVar =
1162        clang::DeclRefExpr::Create(C,
1163                                   clang::NestedNameSpecifierLoc(),
1164                                   clang::SourceLocation(),
1165                                   VD,
1166                                   false,
1167                                   Loc,
1168                                   T->getCanonicalTypeInternal(),
1169                                   clang::VK_RValue,
1170                                   NULL);
1171
1172    clang::Stmt *RSSetObjectOps =
1173        CreateStructRSSetObject(C, RefRSVar, InitExpr, StartLoc, Loc);
1174
1175    std::list<clang::Stmt*> StmtList;
1176    StmtList.push_back(RSSetObjectOps);
1177    AppendAfterStmt(C, mCS, DS, StmtList);
1178    return;
1179  }
1180
1181  clang::FunctionDecl *SetObjectFD = RSObjectRefCount::GetRSSetObjectFD(DT);
1182  slangAssert((SetObjectFD != NULL) &&
1183              "rsSetObject doesn't cover all RS object types");
1184
1185  clang::QualType SetObjectFDType = SetObjectFD->getType();
1186  clang::QualType SetObjectFDArgType[2];
1187  SetObjectFDArgType[0] = SetObjectFD->getParamDecl(0)->getOriginalType();
1188  SetObjectFDArgType[1] = SetObjectFD->getParamDecl(1)->getOriginalType();
1189
1190  clang::Expr *RefRSSetObjectFD =
1191      clang::DeclRefExpr::Create(C,
1192                                 clang::NestedNameSpecifierLoc(),
1193                                 clang::SourceLocation(),
1194                                 SetObjectFD,
1195                                 false,
1196                                 Loc,
1197                                 SetObjectFDType,
1198                                 clang::VK_RValue,
1199                                 NULL);
1200
1201  clang::Expr *RSSetObjectFP =
1202      clang::ImplicitCastExpr::Create(C,
1203                                      C.getPointerType(SetObjectFDType),
1204                                      clang::CK_FunctionToPointerDecay,
1205                                      RefRSSetObjectFD,
1206                                      NULL,
1207                                      clang::VK_RValue);
1208
1209  const clang::Type *T = RSExportType::GetTypeOfDecl(VD);
1210  clang::DeclRefExpr *RefRSVar =
1211      clang::DeclRefExpr::Create(C,
1212                                 clang::NestedNameSpecifierLoc(),
1213                                 clang::SourceLocation(),
1214                                 VD,
1215                                 false,
1216                                 Loc,
1217                                 T->getCanonicalTypeInternal(),
1218                                 clang::VK_RValue,
1219                                 NULL);
1220
1221  llvm::SmallVector<clang::Expr*, 2> ArgList;
1222  ArgList.push_back(new(C) clang::UnaryOperator(RefRSVar,
1223                                                clang::UO_AddrOf,
1224                                                SetObjectFDArgType[0],
1225                                                clang::VK_RValue,
1226                                                clang::OK_Ordinary,
1227                                                Loc));
1228  ArgList.push_back(InitExpr);
1229
1230  clang::CallExpr *RSSetObjectCall =
1231      new(C) clang::CallExpr(C,
1232                             RSSetObjectFP,
1233                             ArgList,
1234                             SetObjectFD->getCallResultType(),
1235                             clang::VK_RValue,
1236                             Loc);
1237
1238  std::list<clang::Stmt*> StmtList;
1239  StmtList.push_back(RSSetObjectCall);
1240  AppendAfterStmt(C, mCS, DS, StmtList);
1241
1242  return;
1243}
1244
1245void RSObjectRefCount::Scope::InsertLocalVarDestructors() {
1246  for (std::list<clang::VarDecl*>::const_iterator I = mRSO.begin(),
1247          E = mRSO.end();
1248        I != E;
1249        I++) {
1250    clang::VarDecl *VD = *I;
1251    clang::Stmt *RSClearObjectCall = ClearRSObject(VD, VD->getDeclContext());
1252    if (RSClearObjectCall) {
1253      DestructorVisitor DV((*mRSO.begin())->getASTContext(),
1254                           mCS,
1255                           RSClearObjectCall,
1256                           VD->getSourceRange().getBegin());
1257      DV.Visit(mCS);
1258      DV.InsertDestructors();
1259    }
1260  }
1261  return;
1262}
1263
1264clang::Stmt *RSObjectRefCount::Scope::ClearRSObject(
1265    clang::VarDecl *VD,
1266    clang::DeclContext *DC) {
1267  slangAssert(VD);
1268  clang::ASTContext &C = VD->getASTContext();
1269  clang::SourceLocation Loc = VD->getLocation();
1270  clang::SourceLocation StartLoc = VD->getInnerLocStart();
1271  const clang::Type *T = RSExportType::GetTypeOfDecl(VD);
1272
1273  // Reference expr to target RS object variable
1274  clang::DeclRefExpr *RefRSVar =
1275      clang::DeclRefExpr::Create(C,
1276                                 clang::NestedNameSpecifierLoc(),
1277                                 clang::SourceLocation(),
1278                                 VD,
1279                                 false,
1280                                 Loc,
1281                                 T->getCanonicalTypeInternal(),
1282                                 clang::VK_RValue,
1283                                 NULL);
1284
1285  if (T->isArrayType()) {
1286    return ClearArrayRSObject(C, DC, RefRSVar, StartLoc, Loc);
1287  }
1288
1289  RSExportPrimitiveType::DataType DT =
1290      RSExportPrimitiveType::GetRSSpecificType(T);
1291
1292  if (DT == RSExportPrimitiveType::DataTypeUnknown ||
1293      DT == RSExportPrimitiveType::DataTypeIsStruct) {
1294    return ClearStructRSObject(C, DC, RefRSVar, StartLoc, Loc);
1295  }
1296
1297  slangAssert((RSExportPrimitiveType::IsRSObjectType(DT)) &&
1298              "Should be RS object");
1299
1300  return ClearSingleRSObject(C, RefRSVar, Loc);
1301}
1302
1303bool RSObjectRefCount::InitializeRSObject(clang::VarDecl *VD,
1304                                          RSExportPrimitiveType::DataType *DT,
1305                                          clang::Expr **InitExpr) {
1306  slangAssert(VD && DT && InitExpr);
1307  const clang::Type *T = RSExportType::GetTypeOfDecl(VD);
1308
1309  // Loop through array types to get to base type
1310  while (T && T->isArrayType()) {
1311    T = T->getArrayElementTypeNoTypeQual();
1312  }
1313
1314  bool DataTypeIsStructWithRSObject = false;
1315  *DT = RSExportPrimitiveType::GetRSSpecificType(T);
1316
1317  if (*DT == RSExportPrimitiveType::DataTypeUnknown) {
1318    if (RSExportPrimitiveType::IsStructureTypeWithRSObject(T)) {
1319      *DT = RSExportPrimitiveType::DataTypeIsStruct;
1320      DataTypeIsStructWithRSObject = true;
1321    } else {
1322      return false;
1323    }
1324  }
1325
1326  bool DataTypeIsRSObject = false;
1327  if (DataTypeIsStructWithRSObject) {
1328    DataTypeIsRSObject = true;
1329  } else {
1330    DataTypeIsRSObject = RSExportPrimitiveType::IsRSObjectType(*DT);
1331  }
1332  *InitExpr = VD->getInit();
1333
1334  if (!DataTypeIsRSObject && *InitExpr) {
1335    // If we already have an initializer for a matrix type, we are done.
1336    return DataTypeIsRSObject;
1337  }
1338
1339  clang::Expr *ZeroInitializer =
1340      CreateZeroInitializerForRSSpecificType(*DT,
1341                                             VD->getASTContext(),
1342                                             VD->getLocation());
1343
1344  if (ZeroInitializer) {
1345    ZeroInitializer->setType(T->getCanonicalTypeInternal());
1346    VD->setInit(ZeroInitializer);
1347  }
1348
1349  return DataTypeIsRSObject;
1350}
1351
1352clang::Expr *RSObjectRefCount::CreateZeroInitializerForRSSpecificType(
1353    RSExportPrimitiveType::DataType DT,
1354    clang::ASTContext &C,
1355    const clang::SourceLocation &Loc) {
1356  clang::Expr *Res = NULL;
1357  switch (DT) {
1358    case RSExportPrimitiveType::DataTypeIsStruct:
1359    case RSExportPrimitiveType::DataTypeRSElement:
1360    case RSExportPrimitiveType::DataTypeRSType:
1361    case RSExportPrimitiveType::DataTypeRSAllocation:
1362    case RSExportPrimitiveType::DataTypeRSSampler:
1363    case RSExportPrimitiveType::DataTypeRSScript:
1364    case RSExportPrimitiveType::DataTypeRSMesh:
1365    case RSExportPrimitiveType::DataTypeRSPath:
1366    case RSExportPrimitiveType::DataTypeRSProgramFragment:
1367    case RSExportPrimitiveType::DataTypeRSProgramVertex:
1368    case RSExportPrimitiveType::DataTypeRSProgramRaster:
1369    case RSExportPrimitiveType::DataTypeRSProgramStore:
1370    case RSExportPrimitiveType::DataTypeRSFont: {
1371      //    (ImplicitCastExpr 'nullptr_t'
1372      //      (IntegerLiteral 0)))
1373      llvm::APInt Zero(C.getTypeSize(C.IntTy), 0);
1374      clang::Expr *Int0 = clang::IntegerLiteral::Create(C, Zero, C.IntTy, Loc);
1375      clang::Expr *CastToNull =
1376          clang::ImplicitCastExpr::Create(C,
1377                                          C.NullPtrTy,
1378                                          clang::CK_IntegralToPointer,
1379                                          Int0,
1380                                          NULL,
1381                                          clang::VK_RValue);
1382
1383      llvm::SmallVector<clang::Expr*, 1>InitList;
1384      InitList.push_back(CastToNull);
1385
1386      Res = new(C) clang::InitListExpr(C, Loc, InitList, Loc);
1387      break;
1388    }
1389    case RSExportPrimitiveType::DataTypeRSMatrix2x2:
1390    case RSExportPrimitiveType::DataTypeRSMatrix3x3:
1391    case RSExportPrimitiveType::DataTypeRSMatrix4x4: {
1392      // RS matrix is not completely an RS object. They hold data by themselves.
1393      // (InitListExpr rs_matrix2x2
1394      //   (InitListExpr float[4]
1395      //     (FloatingLiteral 0)
1396      //     (FloatingLiteral 0)
1397      //     (FloatingLiteral 0)
1398      //     (FloatingLiteral 0)))
1399      clang::QualType FloatTy = C.FloatTy;
1400      // Constructor sets value to 0.0f by default
1401      llvm::APFloat Val(C.getFloatTypeSemantics(FloatTy));
1402      clang::FloatingLiteral *Float0Val =
1403          clang::FloatingLiteral::Create(C,
1404                                         Val,
1405                                         /* isExact = */true,
1406                                         FloatTy,
1407                                         Loc);
1408
1409      unsigned N = 0;
1410      if (DT == RSExportPrimitiveType::DataTypeRSMatrix2x2)
1411        N = 2;
1412      else if (DT == RSExportPrimitiveType::DataTypeRSMatrix3x3)
1413        N = 3;
1414      else if (DT == RSExportPrimitiveType::DataTypeRSMatrix4x4)
1415        N = 4;
1416      unsigned N_2 = N * N;
1417
1418      // Assume we are going to be allocating 16 elements, since 4x4 is max.
1419      llvm::SmallVector<clang::Expr*, 16> InitVals;
1420      for (unsigned i = 0; i < N_2; i++)
1421        InitVals.push_back(Float0Val);
1422      clang::Expr *InitExpr =
1423          new(C) clang::InitListExpr(C, Loc, InitVals, Loc);
1424      InitExpr->setType(C.getConstantArrayType(FloatTy,
1425                                               llvm::APInt(32, N_2),
1426                                               clang::ArrayType::Normal,
1427                                               /* EltTypeQuals = */0));
1428      llvm::SmallVector<clang::Expr*, 1> InitExprVec;
1429      InitExprVec.push_back(InitExpr);
1430
1431      Res = new(C) clang::InitListExpr(C, Loc, InitExprVec, Loc);
1432      break;
1433    }
1434    case RSExportPrimitiveType::DataTypeUnknown:
1435    case RSExportPrimitiveType::DataTypeFloat16:
1436    case RSExportPrimitiveType::DataTypeFloat32:
1437    case RSExportPrimitiveType::DataTypeFloat64:
1438    case RSExportPrimitiveType::DataTypeSigned8:
1439    case RSExportPrimitiveType::DataTypeSigned16:
1440    case RSExportPrimitiveType::DataTypeSigned32:
1441    case RSExportPrimitiveType::DataTypeSigned64:
1442    case RSExportPrimitiveType::DataTypeUnsigned8:
1443    case RSExportPrimitiveType::DataTypeUnsigned16:
1444    case RSExportPrimitiveType::DataTypeUnsigned32:
1445    case RSExportPrimitiveType::DataTypeUnsigned64:
1446    case RSExportPrimitiveType::DataTypeBoolean:
1447    case RSExportPrimitiveType::DataTypeUnsigned565:
1448    case RSExportPrimitiveType::DataTypeUnsigned5551:
1449    case RSExportPrimitiveType::DataTypeUnsigned4444:
1450    case RSExportPrimitiveType::DataTypeMax: {
1451      slangAssert(false && "Not RS object type!");
1452    }
1453    // No default case will enable compiler detecting the missing cases
1454  }
1455
1456  return Res;
1457}
1458
1459void RSObjectRefCount::VisitDeclStmt(clang::DeclStmt *DS) {
1460  for (clang::DeclStmt::decl_iterator I = DS->decl_begin(), E = DS->decl_end();
1461       I != E;
1462       I++) {
1463    clang::Decl *D = *I;
1464    if (D->getKind() == clang::Decl::Var) {
1465      clang::VarDecl *VD = static_cast<clang::VarDecl*>(D);
1466      RSExportPrimitiveType::DataType DT =
1467          RSExportPrimitiveType::DataTypeUnknown;
1468      clang::Expr *InitExpr = NULL;
1469      if (InitializeRSObject(VD, &DT, &InitExpr)) {
1470        getCurrentScope()->addRSObject(VD);
1471        getCurrentScope()->AppendRSObjectInit(VD, DS, DT, InitExpr);
1472      }
1473    }
1474  }
1475  return;
1476}
1477
1478void RSObjectRefCount::VisitCompoundStmt(clang::CompoundStmt *CS) {
1479  if (!CS->body_empty()) {
1480    // Push a new scope
1481    Scope *S = new Scope(CS);
1482    mScopeStack.push(S);
1483
1484    VisitStmt(CS);
1485
1486    // Destroy the scope
1487    slangAssert((getCurrentScope() == S) && "Corrupted scope stack!");
1488    S->InsertLocalVarDestructors();
1489    mScopeStack.pop();
1490    delete S;
1491  }
1492  return;
1493}
1494
1495void RSObjectRefCount::VisitBinAssign(clang::BinaryOperator *AS) {
1496  clang::QualType QT = AS->getType();
1497
1498  if (CountRSObjectTypes(mCtx, QT.getTypePtr(), AS->getExprLoc())) {
1499    getCurrentScope()->ReplaceRSObjectAssignment(AS);
1500  }
1501
1502  return;
1503}
1504
1505void RSObjectRefCount::VisitStmt(clang::Stmt *S) {
1506  for (clang::Stmt::child_iterator I = S->child_begin(), E = S->child_end();
1507       I != E;
1508       I++) {
1509    if (clang::Stmt *Child = *I) {
1510      Visit(Child);
1511    }
1512  }
1513  return;
1514}
1515
1516// This function walks the list of global variables and (potentially) creates
1517// a single global static destructor function that properly decrements
1518// reference counts on the contained RS object types.
1519clang::FunctionDecl *RSObjectRefCount::CreateStaticGlobalDtor() {
1520  Init();
1521
1522  clang::DeclContext *DC = mCtx.getTranslationUnitDecl();
1523  clang::SourceLocation loc;
1524
1525  llvm::StringRef SR(".rs.dtor");
1526  clang::IdentifierInfo &II = mCtx.Idents.get(SR);
1527  clang::DeclarationName N(&II);
1528  clang::FunctionProtoType::ExtProtoInfo EPI;
1529  clang::QualType T = mCtx.getFunctionType(mCtx.VoidTy, NULL, 0, EPI);
1530  clang::FunctionDecl *FD = NULL;
1531
1532  // Generate rsClearObject() call chains for every global variable
1533  // (whether static or extern).
1534  std::list<clang::Stmt *> StmtList;
1535  for (clang::DeclContext::decl_iterator I = DC->decls_begin(),
1536          E = DC->decls_end(); I != E; I++) {
1537    clang::VarDecl *VD = llvm::dyn_cast<clang::VarDecl>(*I);
1538    if (VD) {
1539      if (CountRSObjectTypes(mCtx, VD->getType().getTypePtr(), loc)) {
1540        if (!FD) {
1541          // Only create FD if we are going to use it.
1542          FD = clang::FunctionDecl::Create(mCtx, DC, loc, loc, N, T, NULL);
1543        }
1544        // Make sure to create any helpers within the function's DeclContext,
1545        // not the one associated with the global translation unit.
1546        clang::Stmt *RSClearObjectCall = Scope::ClearRSObject(VD, FD);
1547        StmtList.push_back(RSClearObjectCall);
1548      }
1549    }
1550  }
1551
1552  // Nothing needs to be destroyed, so don't emit a dtor.
1553  if (StmtList.empty()) {
1554    return NULL;
1555  }
1556
1557  clang::CompoundStmt *CS = BuildCompoundStmt(mCtx, StmtList, loc);
1558
1559  FD->setBody(CS);
1560
1561  return FD;
1562}
1563
1564}  // namespace slang
1565