diff --git a/clang/include/clang/AST/ASTContext.h b/clang/include/clang/AST/ASTContext.h index 328205520b01453e3c0eff9eb77d9f9d331a55a9..079944080fa5515f5546e5cadd52e4d1d899915c 100644 --- a/clang/include/clang/AST/ASTContext.h +++ b/clang/include/clang/AST/ASTContext.h @@ -496,6 +496,10 @@ public: /// A mapping to contain the declaration and its desugared decls. mutable llvm::DenseMap> BSCDesugaredMap; + /// A mapping to contain the desugared declaration and its original function decl. + llvm::DenseMap BSCFuncDesugaredMap; + /// A mapping to contain the async function declaration and its suitability for inline. + llvm::DenseMap AsyncFuncIsInline; llvm::SmallVector InstantiationVec; #endif diff --git a/clang/lib/Sema/BSC/SemaBSCCoroutine.cpp b/clang/lib/Sema/BSC/SemaBSCCoroutine.cpp index a67c1c8dfea5da0973605bc68831a3551aff9036..f7a6aeda6d47e4b757d1e241a4b064f5d8b5c654 100644 --- a/clang/lib/Sema/BSC/SemaBSCCoroutine.cpp +++ b/clang/lib/Sema/BSC/SemaBSCCoroutine.cpp @@ -215,6 +215,18 @@ class LocalVarFinder : public StmtVisitor { public: LocalVarFinder(ASTContext &Context) : Context(Context) {} + void VisitFunctionDecl(FunctionDecl *FD) { + // Gather Function parameters + for (FunctionDecl::param_const_iterator pi = FD->param_begin(), + pe = FD->param_end(); + pi != pe; pi++) { + IdentifierNumber[(*pi)->getNameAsString()] = 1; + LocalVarList.push_back(std::make_pair( + (*pi)->getDeclName(), (*pi)->getType())); + } + Visit(FD->getBody()); + } + void VisitStmt(Stmt *S) { for (auto *C : S->children()) { if (C) { @@ -296,6 +308,38 @@ public: std::vector GetAwaitExpr() const { return Args; } }; +class ComplexityCalculator : public RecursiveASTVisitor { + unsigned int Count = 0; + unsigned int ParamCount = 0; + unsigned int ControlFlowCount = 0; + +public: + bool VisitDecl(Decl *D) { + if (isa(D)) + ParamCount++; + else + Count++; + return true; + } + + bool VisitStmt(Stmt *S) { + Count++; + if (isa(S)) + ControlFlowCount++; + return true; + } + + bool IsComplexity() { + if (ParamCount > 5) + return true; + if (ControlFlowCount > 5) + return true; + if (Count > 300) + return true; + return false; + } +}; + static bool hasAwaitExpr(Stmt *S) { if (S == nullptr) return false; @@ -503,8 +547,7 @@ static bool hasReturnStmt(Stmt *S) { } static bool isRefactorStmt(Stmt *S) { - if (isa(S) || isa(S) || isa(S) || - isa(S) || isa(S) || isa(S)) + if (isa(S)) return true; return false; @@ -560,7 +603,8 @@ static RecordDecl *buildOpaqueFutureRecordDecl(Sema &S, FunctionDecl *FD) { // build struct Future for async function static RecordDecl *buildFutureRecordDecl( Sema &S, FunctionDecl *FD, ArrayRef Args, - std::vector> LocalVarList) { + std::vector> LocalVarList, + bool IsRecursiveCall) { std::vector> paramList; DeclarationName funcName = FD->getDeclName(); SourceLocation SLoc = FD->getBeginLoc(); @@ -571,13 +615,6 @@ static RecordDecl *buildFutureRecordDecl( clang::TagDecl::TagKind::TTK_Struct); RD->startDefinition(); - // Gather Function parameters - for (FunctionDecl::param_const_iterator pi = FD->param_begin(); - pi != FD->param_end(); pi++) { - paramList.push_back(std::make_pair( - (*pi)->getDeclName(), (*pi)->getType())); - } - // Gather all awaited expressions for (unsigned I = 0; I != Args.size(); ++I) { auto *AE = cast(Args[I])->getSubExpr(); @@ -593,7 +630,7 @@ static RecordDecl *buildFutureRecordDecl( AE->getType(), AwaitFD->getReturnType().getQualifiers()); } else AEType = AE->getType(); - if (AwaitFD && AwaitFD == FD) { + if (IsRecursiveCall) { // A recursive await assert(CE); // This only happen in the recursive case, and I'm building the thing @@ -610,13 +647,6 @@ static RecordDecl *buildFutureRecordDecl( } } - for (std::vector>::iterator it = - paramList.begin(); - it != paramList.end(); it++) { - std::string VarName = it->first.getAsString(); - QualType VarType = it->second; - addAsyncRecordDecl(S.Context, VarName, VarType, SLoc, ELoc, RD); - } for (std::vector>::iterator it = LocalVarList.begin(); it != LocalVarList.end(); it++) { @@ -707,7 +737,7 @@ static FunctionDecl *buildFutureInitFunctionDefinition(Sema &S, RecordDecl *RD, SourceLocation SLoc = FD->getBeginLoc(); SourceLocation NLoc = FD->getNameInfo().getLoc(); SourceLocation ELoc = FD->getEndLoc(); - FunctionDecl::param_const_iterator pi; + FunctionDecl::param_const_iterator pi, pe; if (isa(FD)) { BSCMethodDecl *BMD = cast(FD); @@ -866,8 +896,9 @@ static FunctionDecl *buildFutureInitFunctionDefinition(Sema &S, RecordDecl *RD, CK_LValueToRValue, DataRef, nullptr, VK_PRValue, FPOptionsOverride()); pi = NewFD->param_begin(); - for (RecordDecl::field_iterator FieldIt = RD->field_begin(); - pi != NewFD->param_end(); ++pi, ++FieldIt) { + pe = NewFD->param_end(); + for (RecordDecl::field_iterator FieldIt = RD->field_begin(); pi != pe; + ++pi, ++FieldIt) { Expr *LHSExpr = S.BuildMemberExpr( DataRef, true, SourceLocation(), NestedNameSpecifierLoc(), SourceLocation(), *FieldIt, @@ -932,8 +963,8 @@ static FunctionDecl *buildFutureInitFunctionDeclaration(Sema &S, SourceLocation ELoc = FD->getEndLoc(); DeclarationName funcName = FD->getDeclName(); SmallVector ParamTys; - FunctionDecl::param_const_iterator pi; - for (pi = FD->param_begin(); pi != FD->param_end(); pi++) { + FunctionDecl::param_const_iterator pi, pe; + for (pi = FD->param_begin(), pe = FD->param_end(); pi != pe; pi++) { ParamTys.push_back((*pi)->getType()); } QualType FuncType = S.Context.getFunctionType(FuncRetType, ParamTys, {}); @@ -974,8 +1005,9 @@ buildFutureStructInitFunctionDefinition(Sema &S, RecordDecl *RD, SourceLocation ELoc = OriginFD->getEndLoc(); QualType FuncRetType = S.Context.getRecordType(RD); SmallVector ParamTys; - FunctionDecl::param_const_iterator pi; - for (pi = OriginFD->param_begin(); pi != OriginFD->param_end(); pi++) { + FunctionDecl::param_const_iterator pi, pe; + for (pi = OriginFD->param_begin(), pe = OriginFD->param_end(); pi != pe; + pi++) { ParamTys.push_back((*pi)->getType()); } @@ -1035,8 +1067,8 @@ buildFutureStructInitFunctionDefinition(Sema &S, RecordDecl *RD, RecordDecl::field_iterator FieldIt = RD->field_begin(), Field_end = RD->field_end(); llvm::SmallVector InitExprs; - for (pi = NewFD->param_begin(); - pi != NewFD->param_end() && FieldIt != Field_end; ++pi, ++FieldIt) { + for (pi = NewFD->param_begin(), pe = NewFD->param_end(); + pi != pe && FieldIt != Field_end; ++pi, ++FieldIt) { DeclarationName Name = FieldIt->getDeclName(); DeclarationNameInfo MemberNameInfo(Name, FieldIt->getLocation()); Expr *LHSExpr = S.BuildMemberExpr( @@ -1230,6 +1262,613 @@ private: }; } // namespace +namespace { +/** + * Transform the function body so it manages a single state + */ +class TransformToHasSingleState + : public TreeTransform { + typedef TreeTransform BaseTransform; + +public: + TransformToHasSingleState(Sema &SemaRef) : BaseTransform(SemaRef) {} + + // make sure redo semantic analysis + bool AlwaysRebuild() { return true; } + + StmtResult TransformIfStmt(IfStmt *S) { + bool HasStatement = false; + bool HasStatementElse = false; + IfStmt *If = S; + Stmt *TS = If->getThen(); + Stmt *ES = If->getElse(); + if (TS != nullptr) + HasStatement = (hasAwaitExpr(TS) || hasReturnStmt(TS)); + if (ES != nullptr) + HasStatementElse = (hasAwaitExpr(ES) || hasReturnStmt(ES)); + + if (HasStatementElse && !isRefactorStmt(ES)) { + std::vector Stmts; + Stmts.push_back(ES); + Sema::CompoundScopeRAII CompoundScope(SemaRef); + ES = BaseTransform::RebuildCompoundStmt(If->getBeginLoc(), Stmts, + If->getEndLoc(), false) + .getAs(); + If->setElse(ES); + } + + if (HasStatement && !isRefactorStmt(TS)) { + std::vector Stmts; + Stmts.push_back(TS); + Sema::CompoundScopeRAII CompoundScope(SemaRef); + TS = BaseTransform::RebuildCompoundStmt(If->getBeginLoc(), Stmts, + If->getEndLoc(), false) + .getAs(); + If->setThen(TS); + } + + return BaseTransform::TransformIfStmt(If); + } + + StmtResult TransformWhileStmt(WhileStmt *S) { + bool HasStatement = false; + WhileStmt *WS = S; + Stmt *Body = WS->getBody(); + + if (Body != nullptr) + HasStatement = (hasAwaitExpr(Body) || hasReturnStmt(Body)); + + if (HasStatement && !isRefactorStmt(Body)) { + std::vector Stmts; + Stmts.push_back(Body); + Sema::CompoundScopeRAII CompoundScope(SemaRef); + Body = BaseTransform::RebuildCompoundStmt(Body->getBeginLoc(), Stmts, + Body->getEndLoc(), false) + .getAs(); + WS->setBody(Body); + } + return BaseTransform::TransformWhileStmt(WS); + } + + StmtResult TransformDoStmt(DoStmt *S) { + bool HasStatement = false; + DoStmt *DS = S; + Stmt *Body = DS->getBody(); + + if (Body != nullptr) + HasStatement = (hasAwaitExpr(Body) || hasReturnStmt(Body)); + + if (HasStatement && !isRefactorStmt(Body)) { + std::vector Stmts; + Stmts.push_back(Body); + Sema::CompoundScopeRAII CompoundScope(SemaRef); + Body = BaseTransform::RebuildCompoundStmt(Body->getBeginLoc(), Stmts, + Body->getEndLoc(), false) + .getAs(); + DS->setBody(Body); + } + return BaseTransform::TransformDoStmt(DS); + } + + StmtResult TransformForStmt(ForStmt *S) { + bool HasStatement = false; + ForStmt *FS = S; + Stmt *Body = FS->getBody(); + + if (Body != nullptr) + HasStatement = (hasAwaitExpr(Body) || hasReturnStmt(Body)); + if (HasStatement && !isRefactorStmt(Body)) { + std::vector Stmts; + Stmts.push_back(Body); + Sema::CompoundScopeRAII CompoundScope(SemaRef); + Body = BaseTransform::RebuildCompoundStmt(Body->getBeginLoc(), Stmts, + Body->getEndLoc(), false) + .getAs(); + FS->setBody(Body); + } + return BaseTransform::TransformForStmt(FS); + } + + StmtResult TransformCaseStmt(CaseStmt *S) { + bool HasStatement = false; + CaseStmt *CS = S; + Stmt *SS = CS->getSubStmt(); + if (SS != nullptr) + HasStatement = (hasAwaitExpr(SS) || hasReturnStmt(SS)); + if (HasStatement && !isRefactorStmt(SS)) { + std::vector Stmts; + Stmts.push_back(SS); + Sema::CompoundScopeRAII CompoundScope(SemaRef); + SS = BaseTransform::RebuildCompoundStmt(SS->getBeginLoc(), Stmts, + SS->getEndLoc(), false) + .getAs(); + CS->setSubStmt(SS); + } + return BaseTransform::TransformCaseStmt(CS); + } + + StmtResult TransformDefaultStmt(DefaultStmt *S) { + bool HasStatement = false; + DefaultStmt *DS = S; + Stmt *SS = DS->getSubStmt(); + if (SS != nullptr) + HasStatement = (hasAwaitExpr(SS) || hasReturnStmt(SS)); + if (HasStatement && !isRefactorStmt(SS)) { + std::vector Stmts; + Stmts.push_back(SS); + Sema::CompoundScopeRAII CompoundScope(SemaRef); + SS = BaseTransform::RebuildCompoundStmt(SS->getBeginLoc(), Stmts, + SS->getEndLoc(), false) + .getAs(); + DS->setSubStmt(SS); + } + return BaseTransform::TransformDefaultStmt(DS); + } + + StmtResult TransformReturnStmt(ReturnStmt *S) { return S; } + + StmtResult TransformCompoundStmt(CompoundStmt *S) { + if (S == nullptr) + return S; + + std::vector Statements; + for (auto *C : S->children()) { + Stmt *SS = const_cast(C); + SS = BaseTransform::TransformStmt(SS).getAs(); + Statements.push_back(SS); + } + Sema::CompoundScopeRAII CompoundScope(SemaRef); + CompoundStmt *CS = BaseTransform::RebuildCompoundStmt( + S->getBeginLoc(), Statements, S->getEndLoc(), false) + .getAs(); + return CS; + } + + StmtResult TransformCompoundStmt(CompoundStmt *S, bool IsStmtExpr) { + return S; + } +}; +} // namespace + +namespace { +class TransformInlineAwaitExpr + : public TreeTransform { + typedef TreeTransform BaseTransform; + enum RetType { assign, unassign, ret, arg }; + FunctionDecl *FD; + std::vector AEExprs; + llvm::DenseMap VarMap; + int AwaitCount = 0; + int LabelIndex = 0; + RetType CurRetType = unassign; + bool HasAdded = false; + bool IsAddAwaitExpr = true; + std::vector> RetDecls; + std::vector RetExprs; + std::vector> LabelDecls; + std::vector> + ReturnContext; // {HasNextStmt, LabelIndex, CurType} + std::stack CurCS; + llvm::DenseMap> + DesugaredStmtsMap; + llvm::DenseSet FuncSet; + +public: + TransformInlineAwaitExpr(Sema &SemaRef, FunctionDecl *FD) + : BaseTransform(SemaRef), FD(FD) {} + + // make sure redo semantic analysis + bool AlwaysRebuild() { return true; } + + ExprResult TransformDeclRefExpr(DeclRefExpr *E) { + llvm::DenseMap::iterator I = + VarMap.find(E->getDecl()); + if (I != VarMap.end()) { + return SemaRef.BuildDeclRefExpr(I->second, E->getType(), + E->getValueKind(), E->getLocation()); + } + return E; + } + + void HandleFuncParams(CallExpr *CE, FunctionDecl *OriginFD) { + for (unsigned i = 0; i < CE->getNumArgs(); i++) { + if (!hasAwaitExpr(CE->getArg(i))) { + ParmVarDecl *PVD = OriginFD->getParamDecl(i); + VarDecl *VD = VarDecl::Create( + SemaRef.Context, SemaRef.CurContext, SourceLocation(), + SourceLocation(), PVD->getIdentifier(), PVD->getType(), + PVD->getTypeSourceInfo(), PVD->getStorageClass()); + Expr *Arg = BaseTransform::TransformExpr(CE->getArg(i)).get(); + SemaRef.AddInitializerToDecl(VD, Arg, + /*DirectInit=*/false); + DeclStmt *DS = SemaRef + .ActOnDeclStmt(SemaRef.ConvertDeclToDeclGroup(VD), + SourceLocation(), SourceLocation()) + .getAs(); + DesugaredStmtsMap[CurCS.top()].push_back(DS); + // Dealing with VarDecl with the same name. + VarMap[PVD] = VD; + } + } + } + + void HandleFuncBody(FunctionDecl *OriginFD) { + CompoundStmt *CS = dyn_cast(OriginFD->getBody()); + std::tuple TmpTuple(true, 0, CurRetType); + ReturnContext.push_back(TmpTuple); + CurRetType = unassign; + + for (auto *C : CS->children()) { + if (C == CS->body_back()) + std::get<0>(ReturnContext.back()) = false; + + if (dyn_cast(C)) { + BaseTransform::TransformStmt(C).getAs(); + } else { + + C = BaseTransform::TransformStmt(C).getAs(); + if (auto *RS = dyn_cast(C)) { + if (std::get<2>(ReturnContext.back()) == ret && !hasAwaitExpr(RS)) { + CurRetType = unassign; + DesugaredStmtsMap[CurCS.top()].push_back(RS); + } + } else if (!HasAdded) { + DesugaredStmtsMap[CurCS.top()].push_back(C); + } + } + } + } + + ExprResult TransformAwaitExpr(AwaitExpr *E) { + RetType RT = CurRetType; + Stmt *SE = BaseTransform::TransformStmt(E->getSubExpr()).getAs(); + CurRetType = RT; + if (CallExpr *CE = dyn_cast(SE)) { + FunctionDecl *D = CE->getDirectCallee(); + FunctionDecl *OriginFD = nullptr; + bool IsInline = true; + + if (D && SemaRef.Context.BSCFuncDesugaredMap.find(D) != + SemaRef.Context.BSCFuncDesugaredMap.end()) + OriginFD = SemaRef.Context.BSCFuncDesugaredMap[D]; + else + IsInline = false; + + if (!IsInline && D && D->isAsyncSpecified()) { + SmallVector Vec = SemaRef.Context.BSCDesugaredMap[D]; + for (size_t i = 0; i < Vec.size(); i++) { + if (auto RD = dyn_cast(Vec[i])) { + if (RD->getNameAsString() == ("_Future" + D->getNameAsString())){ + CE->setType(SemaRef.Context.getPointerType(SemaRef.Context.getRecordType(RD))); + E = dyn_cast( + SemaRef.BuildAwaitExpr(E->getBeginLoc(), CE).get()); + break; + } + } + } + } + + if (SemaRef.Context.AsyncFuncIsInline.count(OriginFD)) + IsInline = SemaRef.Context.AsyncFuncIsInline[OriginFD]; + + if (IsInline && OriginFD) { + // The following points are not suitable for inline: + // 1. More than 5 parameters + // 2. The function contains a large number of loops, conditional branches, etc. (more than 5) + // 3. If the function body is relatively large (with more than 300 AST nodes) + ComplexityCalculator CC = ComplexityCalculator(); + CC.TraverseDecl(OriginFD); + IsInline = !CC.IsComplexity(); + SemaRef.Context.AsyncFuncIsInline[OriginFD] = IsInline; + } + + // Recursive function skipping + if (IsInline && FuncSet.count(OriginFD)) + IsInline = false; + + if (IsInline && OriginFD->hasBody()) { + FuncSet.insert(OriginFD); + // Handle Function parameters + HandleFuncParams(CE, OriginFD); + + int LocalLabelIndex = LabelIndex; + // Handle Function body + HandleFuncBody(OriginFD); + + if (std::get<2>(ReturnContext.back()) == unassign && + LocalLabelIndex < LabelIndex) { + LabelDecl *LD = std::get<0>(LabelDecls.back()); + int num = std::get<1>(LabelDecls.back()); + bool CanSimplify = false; + if (auto *GS = dyn_cast_or_null( + DesugaredStmtsMap[CurCS.top()].back())) { + if (num == 1 && GS->getLabel() == LD) { + DesugaredStmtsMap[CurCS.top()].pop_back(); + CanSimplify = true; + } + } + if (!CanSimplify && !LD->getStmt()) { + Stmt::EmptyShell Empty; + NullStmt *Null = new (SemaRef.Context) NullStmt(Empty); + Null->setSemiLoc(SourceLocation()); + LabelStmt *LS = BaseTransform::RebuildLabelStmt( + SourceLocation(), LD, SourceLocation(), Null) + .getAs(); + DesugaredStmtsMap[CurCS.top()].push_back(LS); + } + } + ReturnContext.pop_back(); + FuncSet.erase(OriginFD); + } else { + AwaitCount++; + AEExprs.push_back(E); + if (CurRetType == unassign) + DesugaredStmtsMap[CurCS.top()].push_back(E); + } + } else { + AwaitCount++; + AEExprs.push_back(E); + } + return E; + } + + ExprResult TransformCallExpr(CallExpr *E) { + FunctionDecl *FD = E->getDirectCallee(); + SmallVector Args; + for (unsigned i = 0; i < E->getNumArgs(); i++) { + Expr *Arg = E->getArg(i); + if (hasAwaitExpr(Arg)) { + CurRetType = arg; + if (SemaRef.Context.BSCFuncDesugaredMap.find(FD) != + SemaRef.Context.BSCFuncDesugaredMap.end()) + FD = SemaRef.Context.BSCFuncDesugaredMap[FD]; + std::tuple TmpTuple( + FD->getParamDecl(i), CurCS.top(), false); + RetDecls.push_back(TmpTuple); + BaseTransform::TransformExpr(Arg).get(); + RetDecls.pop_back(); + } else { + Expr *NewArg = BaseTransform::TransformExpr(Arg).get(); + Args.push_back(NewArg); + } + } + if (Args.size() > 0) + return SemaRef.BuildCallExpr(nullptr, E->getCallee(), E->getBeginLoc(), + Args, E->getEndLoc()); + return E; + } + + Decl *TransformDefinition(SourceLocation Loc, Decl *D) { + if (VarDecl *VD = dyn_cast(D)) { + Expr *Init = const_cast(VD->getInit()); + int LocalLabelIndex = LabelIndex; + bool HasAwait = hasAwaitExpr(Init); + VarDecl *NewVD = VarDecl::Create( + SemaRef.Context, SemaRef.CurContext, VD->getBeginLoc(), + VD->getLocation(), VD->getIdentifier(), VD->getType(), + VD->getTypeSourceInfo(), VD->getStorageClass()); + VarMap[VD] = NewVD; + if (Init != nullptr) { + if (HasAwait) { + CurRetType = assign; + std::tuple TmpTuple( + NewVD, CurCS.top(), false); + RetDecls.push_back(TmpTuple); + } + Init = BaseTransform::TransformExpr(Init).get(); + HasAdded = false; + if (HasAwait) { + HasAdded = std::get<2>(RetDecls.back()); + RetDecls.pop_back(); + } + if (LocalLabelIndex < LabelIndex) { + LabelDecl *LD = std::get<0>(LabelDecls.back()); + int num = std::get<1>(LabelDecls.back()); + bool CanSimplify = false; + if (auto *GS = dyn_cast_or_null( + DesugaredStmtsMap[CurCS.top()].back())) { + if (num == 1 && GS->getLabel() == LD) { + DesugaredStmtsMap[CurCS.top()].pop_back(); + CanSimplify = true; + } + } + if (!CanSimplify && !LD->getStmt()) { + CurRetType = unassign; + Stmt::EmptyShell Empty; + NullStmt *Null = new (SemaRef.Context) NullStmt(Empty); + Null->setSemiLoc(SourceLocation()); + LabelStmt *LS = + BaseTransform::RebuildLabelStmt( + SourceLocation(), LD, SourceLocation(), Null) + .getAs(); + DesugaredStmtsMap[CurCS.top()].push_back(LS); + } + return D; + } + if (!HasAdded) { + SemaRef.AddInitializerToDecl(NewVD, Init, /*DirectInit=*/false); + return NewVD; + } + HasAdded = false; + } + return BaseTransform::TransformDefinition(Loc, NewVD); + } + + return BaseTransform::TransformDefinition(Loc, D); + } + + ExprResult TransformBinaryOperator(BinaryOperator *E) { + int LocalLabelIndex = LabelIndex; + bool HasAwait = hasAwaitExpr(E); + if (HasAwait) { + RetExprs.push_back(E); + CurRetType = assign; + } + Expr *BO = BaseTransform::TransformBinaryOperator(E).get(); + if (HasAwait) + RetExprs.pop_back(); + if (LocalLabelIndex < LabelIndex) { + LabelDecl *LD = std::get<0>(LabelDecls.back()); + int num = std::get<1>(LabelDecls.back()); + bool CanSimplify = false; + if (auto *GS = dyn_cast_or_null( + DesugaredStmtsMap[CurCS.top()].back())) { + if (num == 1 && GS->getLabel() == LD) { + DesugaredStmtsMap[CurCS.top()].pop_back(); + CanSimplify = true; + } + } + if (!CanSimplify && !LD->getStmt()) { + CurRetType = unassign; + Stmt::EmptyShell Empty; + NullStmt *Null = new (SemaRef.Context) NullStmt(Empty); + Null->setSemiLoc(SourceLocation()); + LabelStmt *LS = + BaseTransform::RebuildLabelStmt(SourceLocation(), LD, + SourceLocation(), Null) + .getAs(); + DesugaredStmtsMap[CurCS.top()].push_back(LS); + } + } + E = dyn_cast(BO); + return E; + } + + StmtResult TransformReturnStmt(ReturnStmt *S) { + bool IsReturn = false; + if (hasAwaitExpr(S)) { + CurRetType = ret; + IsReturn = true; + } + Expr *E = BaseTransform::TransformExpr(S->getRetValue()).get(); + if (hasAwaitExpr(S)) + CurRetType = unassign; + + if (IsReturn && DesugaredStmtsMap[CurCS.top()].size()) { + Stmt *LastStmt = DesugaredStmtsMap[CurCS.top()].back(); + assert(isa(LastStmt)); + if (auto *RS = dyn_cast(LastStmt)) + E = RS->getRetValue(); + } + + if (std::get<2>(ReturnContext.back()) == assign || + std::get<2>(ReturnContext.back()) == arg) { + if (RetDecls.size()) { + VarDecl *VD = std::get<0>(RetDecls.back()); + if (std::get<2>(ReturnContext.back()) == arg) { + VarDecl *OldVD = VD; + VD = VarDecl::Create(SemaRef.Context, SemaRef.CurContext, + SourceLocation(), SourceLocation(), + VD->getIdentifier(), VD->getType(), + VD->getTypeSourceInfo(), VD->getStorageClass()); + // Dealing with VarDecl with the same name. + VarMap[OldVD] = VD; + } + if (std::get<1>(ReturnContext.back()) == 0) { + DeclStmt *DS = SemaRef + .ActOnDeclStmt(SemaRef.ConvertDeclToDeclGroup(VD), + SourceLocation(), SourceLocation()) + .getAs(); + CompoundStmt *CS = std::get<1>(RetDecls.back()); + DesugaredStmtsMap[CS].insert(DesugaredStmtsMap[CS].begin(), DS); + } + if (IsReturn) + DesugaredStmtsMap[CurCS.top()].pop_back(); + Expr *DRE = SemaRef.BuildDeclRefExpr(VD, VD->getType(), VK_LValue, + SourceLocation()); + Stmt *BO = BaseTransform::RebuildBinaryOperator(SourceLocation(), + BO_Assign, DRE, E) + .getAs(); + std::get<2>(RetDecls.back()) = true; + DesugaredStmtsMap[CurCS.top()].push_back(BO); + } else if (RetExprs.size()) { + Stmt *BO = + BaseTransform::RebuildBinaryOperator(SourceLocation(), BO_Assign, + RetExprs.back()->getLHS(), E) + .getAs(); + DesugaredStmtsMap[CurCS.top()].push_back(BO); + } + } + // If the following conditions are met, labelStmt needs to be added: + // 1. It is called by other functions (not the outermost function) + // 2. It is not the last sentence of the called function, so it is necessary + // to obtain the `HasNextStmt` of the previous layer function through -2 + // 3. RetType is not used as a argument + if (ReturnContext.size() > 1 && + std::get<0>(ReturnContext[ReturnContext.size() - 2]) && + std::get<2>(ReturnContext.back()) != arg) { + if (std::get<1>(ReturnContext.back()) == 0) { + LabelIndex++; + std::get<1>(ReturnContext.back()) = LabelIndex; + LabelDecl *LD = LabelDecl::Create( + SemaRef.Context, FD, SourceLocation(), + &(SemaRef.Context.Idents) + .get("__NextStmt_" + std::to_string(LabelIndex))); + std::tuple LDTuple(LD, 0); + LabelDecls.push_back(LDTuple); + } + std::get<1>(LabelDecls.back())++; + Stmt *GS = new (SemaRef.Context) GotoStmt( + std::get<0>(LabelDecls.back()), SourceLocation(), SourceLocation()); + DesugaredStmtsMap[CurCS.top()].push_back(GS); + } + ReturnStmt *RS = ReturnStmt::Create(SemaRef.Context, SourceLocation(), + nullptr, nullptr); + RS->setRetValue(E); + return RS; + } + + StmtResult TransformCompoundStmt(CompoundStmt *S) { + return this->TransformCompoundStmt(S, false); + } + + StmtResult TransformCompoundStmt(CompoundStmt *S, bool IsStmtExpr) { + if (S == nullptr) + return S; + + std::vector Statements; + CurCS.push(S); + for (auto *C : S->children()) { + if (C == S->body_back()) + std::get<0>(ReturnContext.back()) = false; + C = BaseTransform::TransformStmt(C).getAs(); + if (DesugaredStmtsMap.count(S) && DesugaredStmtsMap[S].size()) { + for (auto Desugared : DesugaredStmtsMap[S]) { + Statements.push_back(Desugared); + } + DesugaredStmtsMap.erase(S); + } else { + Statements.push_back(C); + } + } + CurCS.pop(); + Sema::CompoundScopeRAII CompoundScope(SemaRef); + CompoundStmt *CS = + BaseTransform::RebuildCompoundStmt(S->getBeginLoc(), Statements, + S->getEndLoc(), IsStmtExpr) + .getAs(); + return CS; + } + + FunctionDecl *TransformFunctionDecl(FunctionDecl *D) { + // If transforming a declaration without body this may not be present + CompoundStmt *body = llvm::dyn_cast_if_present(D->getBody()); + if (body) { + std::tuple TmpTuple(true, 0, CurRetType); + ReturnContext.push_back(TmpTuple); + FuncSet.insert(D); + Stmt *FuncBody = BaseTransform::TransformStmt(body).getAs(); + D->setBody(FuncBody); + } + return D; + } + + int GetAwaitExprNum() const { return AwaitCount; } + + std::vector GetAwaitExpr() const { return AEExprs; } +}; +} // namespace + namespace { class TransformToReturnVoid : public TreeTransform { typedef TreeTransform BaseTransform; @@ -1242,8 +1881,8 @@ public: bool AlwaysRebuild() { return true; } FunctionDecl *TransformFunctionDecl(FunctionDecl *D) { - FunctionDecl *NewFD = D; if (D->getReturnType()->isVoidType()) { + SourceLocation ELoc = D->getEndLoc(); std::string ReturnStructName = "Void"; DeclContext::lookup_result ReturnDecls = SemaRef.Context.getTranslationUnitDecl()->lookup( @@ -1263,41 +1902,13 @@ public: assert(ReturnDecl && "struct Void not generated"); ReturnTy = SemaRef.Context.getRecordType(ReturnDecl); SmallVector ParamTys; - FunctionDecl::param_const_iterator pi; - for (pi = D->param_begin(); pi != D->param_end(); pi++) { + FunctionDecl::param_const_iterator pi, pe; + for (pi = D->param_begin(), pe = D->param_end(); pi != pe; pi++) { ParamTys.push_back((*pi)->getType()); } QualType FuncType = SemaRef.Context.getFunctionType(ReturnTy, ParamTys, {}); - SourceLocation SLoc = D->getBeginLoc(); - SourceLocation NLoc = D->getNameInfo().getLoc(); - SourceLocation ELoc = D->getEndLoc(); - TypeSourceInfo *Tinfo = D->getTypeSourceInfo(); - std::string FName = std::string(D->getIdentifier()->getName()); - - if (isa(D)) { - BSCMethodDecl *BMD = cast(D); - NewFD = buildAsyncBSCMethodDecl( - SemaRef.Context, D->getDeclContext(), SLoc, NLoc, ELoc, - &(SemaRef.Context.Idents).get(FName), FuncType, Tinfo, SC_None, - BMD->getExtendedType()); - } else { - NewFD = buildAsyncFuncDecl(SemaRef.Context, D->getDeclContext(), SLoc, - NLoc, &(SemaRef.Context.Idents).get(FName), - FuncType, Tinfo); - } - SmallVector ParmVarDecls; - for (const auto &I : D->parameters()) { - ParmVarDecl *PVD = ParmVarDecl::Create( - SemaRef.Context, NewFD, SourceLocation(), SourceLocation(), - &(SemaRef.Context.Idents).get(I->getName()), I->getType(), nullptr, - SC_None, nullptr); - ParmVarDecls.push_back(PVD); - } - NewFD->setParams(ParmVarDecls); - NewFD->setLexicalDeclContext(SemaRef.Context.getTranslationUnitDecl()); - CompoundStmt *body = llvm::dyn_cast_if_present(D->getBody()); // If transforming a declaration without body this may not be present @@ -1313,15 +1924,16 @@ public: Stmts.push_back(RS); Sema::CompoundScopeRAII CompoundScope(SemaRef); body = BaseTransform::RebuildCompoundStmt(SourceLocation(), Stmts, - SourceLocation(), false) + ELoc, false) .getAs(); } Stmt *FuncBody = BaseTransform::TransformStmt(body).getAs(); - NewFD->setBody(FuncBody); + D->setBody(FuncBody); + D->setType(FuncType); } } - return NewFD; + return D; } StmtResult TransformReturnStmt(ReturnStmt *S) { @@ -1407,15 +2019,19 @@ public: QualType QT = VD->getType(); if (VD->isExternallyVisible() || VD->isConstexpr() || - VD->isStaticLocal()) + VD->isStaticLocal()) { + DeclStmts.push_back(S); return S; + } // Do not need to transform constant variable with compile-time constant // initializier. const Expr *Culprit; if (QT.isConstQualified() && Init && !Init->isValueDependent() && - Init->isConstantInitializer(SemaRef.Context, false, &Culprit)) + Init->isConstantInitializer(SemaRef.Context, false, &Culprit)) { + DeclStmts.push_back(S); return S; + } RecordDecl::field_iterator LField, FieldIt; for (FieldIt = FutureRD->field_begin(); @@ -1666,7 +2282,7 @@ public: CIndex--; } else if (BOSize == 1) { Result = cast(BOStmts.front()); - } else { + } else if (BOSize > 1) { BinaryOperator *PreBO = BOStmts.front(); for (int I = 1; I < BOSize; I++) { BinaryOperator *BO = BaseTransform::RebuildBinaryOperator( @@ -1723,13 +2339,10 @@ public: namespace { /** - * Transform the function body so it manages a single state and the return - * statement wraps the results in PollResult + * Transform he return statement wraps the results in PollResult */ -class TransformToHasSingleStateAndReturnStatements - : public TreeTransform { - typedef TreeTransform - BaseTransform; +class TransformRSToCS : public TreeTransform { + typedef TreeTransform BaseTransform; TransformToAP DT; Expr *PDRE; RecordDecl *FutureRD; @@ -1737,159 +2350,35 @@ class TransformToHasSingleStateAndReturnStatements std::map IdentifierNumber; public: - TransformToHasSingleStateAndReturnStatements(Sema &SemaRef, TransformToAP DT, - Expr *PDRE, RecordDecl *FutureRD, - BSCMethodDecl *FD) + TransformRSToCS(Sema &SemaRef, TransformToAP DT, Expr *PDRE, + RecordDecl *FutureRD, BSCMethodDecl *FD) : BaseTransform(SemaRef), DT(DT), PDRE(PDRE), FutureRD(FutureRD), FD(FD) { } // make sure redo semantic analysis bool AlwaysRebuild() { return true; } - StmtResult TransformIfStmt(IfStmt *S) { - bool HasStatement = false; - bool HasStatementElse = false; - IfStmt *If = S; - Stmt *TS = If->getThen(); - Stmt *ES = If->getElse(); - if (TS != nullptr) HasStatement = (hasAwaitExpr(TS) || hasReturnStmt(TS)); - if (ES != nullptr) - HasStatementElse = (hasAwaitExpr(ES) || hasReturnStmt(ES)); - - if (HasStatementElse && !isRefactorStmt(ES)) { - std::vector Stmts; - Stmts.push_back(ES); - Sema::CompoundScopeRAII CompoundScope(SemaRef); - ES = BaseTransform::RebuildCompoundStmt(If->getBeginLoc(), Stmts, - If->getEndLoc(), false) - .getAs(); - If->setElse(ES); - } - - if (HasStatement && !isRefactorStmt(TS)) { - std::vector Stmts; - Stmts.push_back(TS); - Sema::CompoundScopeRAII CompoundScope(SemaRef); - TS = BaseTransform::RebuildCompoundStmt(If->getBeginLoc(), Stmts, - If->getEndLoc(), false) - .getAs(); - If->setThen(TS); - } - - return BaseTransform::TransformIfStmt(If); - } - - StmtResult TransformWhileStmt(WhileStmt *S) { - bool HasStatement = false; - WhileStmt *WS = S; - Stmt *Body = WS->getBody(); - - if (Body != nullptr) - HasStatement = (hasAwaitExpr(Body) || hasReturnStmt(Body)); - - if (HasStatement && !isRefactorStmt(Body)) { - std::vector Stmts; - Stmts.push_back(Body); - Sema::CompoundScopeRAII CompoundScope(SemaRef); - Body = BaseTransform::RebuildCompoundStmt(Body->getBeginLoc(), Stmts, - Body->getEndLoc(), false) - .getAs(); - WS->setBody(Body); - } - return BaseTransform::TransformWhileStmt(WS); - } - - StmtResult TransformDoStmt(DoStmt *S) { - bool HasStatement = false; - DoStmt *DS = S; - Stmt *Body = DS->getBody(); - - if (Body != nullptr) - HasStatement = (hasAwaitExpr(Body) || hasReturnStmt(Body)); - - if (HasStatement && !isRefactorStmt(Body)) { - std::vector Stmts; - Stmts.push_back(Body); - Sema::CompoundScopeRAII CompoundScope(SemaRef); - Body = BaseTransform::RebuildCompoundStmt(Body->getBeginLoc(), Stmts, - Body->getEndLoc(), false) - .getAs(); - DS->setBody(Body); - } - return BaseTransform::TransformDoStmt(DS); - } - - StmtResult TransformForStmt(ForStmt *S) { - bool HasStatement = false; - ForStmt *FS = S; - Stmt *Body = FS->getBody(); - - if (Body != nullptr) - HasStatement = (hasAwaitExpr(Body) || hasReturnStmt(Body)); - if (HasStatement && !isRefactorStmt(Body)) { - std::vector Stmts; - Stmts.push_back(Body); - Sema::CompoundScopeRAII CompoundScope(SemaRef); - Body = BaseTransform::RebuildCompoundStmt(Body->getBeginLoc(), Stmts, - Body->getEndLoc(), false) - .getAs(); - FS->setBody(Body); - } - return BaseTransform::TransformForStmt(FS); - } - - StmtResult TransformCaseStmt(CaseStmt *S) { - bool HasStatement = false; - CaseStmt *CS = S; - Stmt *SS = CS->getSubStmt(); - if (SS != nullptr) HasStatement = (hasAwaitExpr(SS) || hasReturnStmt(SS)); - if (HasStatement && !isRefactorStmt(SS)) { - std::vector Stmts; - Stmts.push_back(SS); - Sema::CompoundScopeRAII CompoundScope(SemaRef); - SS = BaseTransform::RebuildCompoundStmt(SS->getBeginLoc(), Stmts, - SS->getEndLoc(), false) - .getAs(); - CS->setSubStmt(SS); - } - return BaseTransform::TransformCaseStmt(CS); - } - - StmtResult TransformDefaultStmt(DefaultStmt *S) { - bool HasStatement = false; - DefaultStmt *DS = S; - Stmt *SS = DS->getSubStmt(); - if (SS != nullptr) HasStatement = (hasAwaitExpr(SS) || hasReturnStmt(SS)); - if (HasStatement && !isRefactorStmt(SS)) { - std::vector Stmts; - Stmts.push_back(SS); - Sema::CompoundScopeRAII CompoundScope(SemaRef); - SS = BaseTransform::RebuildCompoundStmt(SS->getBeginLoc(), Stmts, - SS->getEndLoc(), false) - .getAs(); - DS->setSubStmt(SS); - } - return BaseTransform::TransformDefaultStmt(DS); - } - StmtResult TransformCompoundStmt(CompoundStmt *S) { if (S == nullptr) return S; std::vector Statements; + std::vector DeclStmts = DT.GetDeclStmts(); + int size = DeclStmts.size(); for (auto *C : S->children()) { Stmt *SS = const_cast(C); std::tuple DRes = DT.GetDMap(SS); int DIndex = std::get<0>(DRes); if (DIndex != -1) { int DNum = std::get<1>(DRes); - std::vector DeclStmts = DT.GetDeclStmts(); - int size = DeclStmts.size(); for (int i = DIndex; i < DIndex + DNum; i++) { if (i < size) Statements.push_back(DeclStmts[i]); } } - SS = BaseTransform::TransformStmt(SS).getAs(); - Statements.push_back(SS); + auto it = std::find(DeclStmts.begin(), DeclStmts.end(), SS); + if (!isa(SS) || it != DeclStmts.end()) { + SS = BaseTransform::TransformStmt(SS).getAs(); + Statements.push_back(SS); + } } Sema::CompoundScopeRAII CompoundScope(SemaRef); CompoundStmt *CS = BaseTransform::RebuildCompoundStmt( @@ -2710,37 +3199,31 @@ static BSCMethodDecl *buildPollFunctionDeclaration(Sema &S, RecordDecl *RD, return NewFD->isInvalidDecl() ? nullptr : NewFD; } -static BSCMethodDecl *buildPollFunctionDefinition(Sema &S, RecordDecl *RD, - RecordDecl *PollResultRD, - FunctionDecl *FD, - RecordDecl *FatPointerRD, - int FutureStateNumber) { +static BSCMethodDecl * +buildPollFunctionDefinition(Sema &S, RecordDecl *RD, RecordDecl *PollResultRD, + FunctionDecl *FD, FunctionDecl *OriginFD, + RecordDecl *FatPointerRD, int FutureStateNumber) { SourceLocation SLoc = FD->getBeginLoc(); SourceLocation NLoc = FD->getNameInfo().getLoc(); SourceLocation ELoc = FD->getEndLoc(); + QualType FuncType = FD->getType(); QualType Ty = FD->getDeclaredReturnType(); S.PushFunctionScope(); - - // Enter the scope of this instantiation. We don't use - // PushDeclContext because we don't have a scope. - FunctionDecl *TransformedFD = nullptr; { - Sema::ContextRAII savedContext(S, FD); + Sema::ContextRAII savedContext(S, OriginFD); LocalInstantiationScope Scope(S); - - TransformedFD = TransformToReturnVoid(S).TransformFunctionDecl(FD); + FD = TransformToReturnVoid(S).TransformFunctionDecl(FD); } S.PopFunctionScopeInfo(); std::string FName = "poll"; - QualType FuncRetType = S.Context.getRecordType(PollResultRD); QualType ParamType = S.Context.getPointerType(S.Context.getRecordType(RD)); SmallVector ParamTys; ParamTys.push_back(ParamType); - QualType FuncType = S.Context.getFunctionType(FuncRetType, ParamTys, {}); + FuncType = S.Context.getFunctionType(FuncRetType, ParamTys, {}); QualType OriginType = S.Context.getFunctionType(Ty, ParamTys, {}); BSCMethodDecl *NewFD = buildAsyncBSCMethodDecl( @@ -2830,19 +3313,17 @@ static BSCMethodDecl *buildPollFunctionDefinition(Sema &S, RecordDecl *RD, int StmtSize = Stmts.size(); - NewFD->setType( - S.Context.getFunctionType(TransformedFD->getReturnType(), ParamTys, {})); + NewFD->setType(S.Context.getFunctionType(FD->getReturnType(), ParamTys, {})); TransformToAP DT = TransformToAP(S, FutureObj, RD, NewFD); - StmtResult MemberChangeRes = DT.TransformStmt(TransformedFD->getBody()); + StmtResult MemberChangeRes = DT.TransformStmt(FD->getBody()); Stmt *FuncBody = MemberChangeRes.get(); NewFD->setType(FuncType); - StmtResult SingleStateRes = - TransformToHasSingleStateAndReturnStatements(S, DT, FutureObj, RD, NewFD) - .TransformStmt(FuncBody); - FuncBody = SingleStateRes.get(); + FuncBody = TransformRSToCS(S, DT, FutureObj, RD, NewFD) + .TransformStmt(FuncBody) + .get(); StmtResult AEToCSRes = TransformAEToCS(S, LabelDecls, NewFD->getParamDecl(0), FutureObj, RD, NewFD) @@ -3109,13 +3590,64 @@ SmallVector Sema::ActOnAsyncFunctionDefinition(FunctionDecl *FD) { RecordDecl *FatPointerRD = FatPointerType->getAsRecordDecl(); - LocalVarFinder VarFinder = LocalVarFinder(Context); - VarFinder.Visit(FD->getBody()); - bool IsRecursiveCall = RecursiveCallVisitor(FD).VisitStmt(FD->getBody()); bool IsOptimization = FD->isStatic() && !IsRecursiveCall; - RecordDecl *RD = buildFutureRecordDecl(*this, FD, AwaitFinder.GetAwaitExpr(), - VarFinder.GetLocalVarList()); + + PushFunctionScope(); + // Enter the scope of this instantiation. We don't use + // PushDeclContext because we don't have a scope. + Stmt *FuncBody = FD->getBody(); + { + ContextRAII savedContext(*this, FD); + LocalInstantiationScope Scope(*this); + FuncBody = TransformToHasSingleState(*this).TransformStmt(FuncBody).get(); + } + PopFunctionScopeInfo(); + + SourceLocation SLoc = FD->getBeginLoc(); + SourceLocation NLoc = FD->getNameInfo().getLoc(); + SourceLocation ELoc = FD->getEndLoc(); + QualType FuncType = FD->getType(); + DeclarationName FDName = FD->getDeclName(); + TypeSourceInfo *Tinfo = FD->getTypeSourceInfo(); + FunctionDecl *TransformedFD = nullptr; + if (isa(FD)) { + BSCMethodDecl *BMD = cast(FD); + TransformedFD = buildAsyncBSCMethodDecl(Context, FD->getDeclContext(), SLoc, + NLoc, ELoc, FDName, FuncType, Tinfo, + SC_None, BMD->getExtendedType()); + } else { + TransformedFD = buildAsyncFuncDecl(Context, FD->getDeclContext(), SLoc, + NLoc, FDName, FuncType, Tinfo); + } + // SmallVector ParmVarDecls; + // for (const auto &I : FD->parameters()) { + // ParmVarDecl *PVD = ParmVarDecl::Create( + // Context, TransformedFD, SourceLocation(), SourceLocation(), + // &(Context.Idents).get(I->getName()), I->getType(), nullptr, SC_None, + // nullptr); + // ParmVarDecls.push_back(PVD); + // } + TransformedFD->setParams(FD->parameters()); + TransformedFD->setLexicalDeclContext(Context.getTranslationUnitDecl()); + TransformedFD->setBody(FuncBody); + + PushFunctionScope(); + TransformInlineAwaitExpr TIAE = + TransformInlineAwaitExpr(*this, TransformedFD); + { + ContextRAII savedContext(*this, FD); + LocalInstantiationScope Scope(*this); + TIAE.TransformFunctionDecl(TransformedFD); + } + PopFunctionScopeInfo(); + + LocalVarFinder VarFinder = LocalVarFinder(Context); + VarFinder.VisitFunctionDecl(TransformedFD); + + RecordDecl *RD = + buildFutureRecordDecl(*this, TransformedFD, TIAE.GetAwaitExpr(), + VarFinder.GetLocalVarList(), IsRecursiveCall); auto RDType = Context.getRecordType(RD); QualType PointerStructTy = Context.getPointerType(RDType); @@ -3124,7 +3656,7 @@ SmallVector Sema::ActOnAsyncFunctionDefinition(FunctionDecl *FD) { } // Handle declaration first. FunctionDecl *FutureInitDef = buildFutureInitFunctionDeclaration( - *this, FD, IsOptimization ? RDType : PointerStructTy); + *this, TransformedFD, IsOptimization ? RDType : PointerStructTy); if (!FutureInitDef) { return Decls; } @@ -3132,17 +3664,18 @@ SmallVector Sema::ActOnAsyncFunctionDefinition(FunctionDecl *FD) { Decls.push_back(FutureInitDef); Context.BSCDesugaredMap[FD].push_back(FutureInitDef); - const int FutureStateNumber = AwaitFinder.GetAwaitExprNum() + 1; + const int FutureStateNumber = TIAE.GetAwaitExprNum() + 1; Decls.push_back(RD); Context.BSCDesugaredMap[FD].push_back(RD); FunctionDecl *FutureInit = nullptr; if (IsOptimization) { - FutureInit = buildFutureStructInitFunctionDefinition(*this, RD, FD); - } else { FutureInit = - buildFutureInitFunctionDefinition(*this, RD, FD, FutureInitDef); + buildFutureStructInitFunctionDefinition(*this, RD, TransformedFD); + } else { + FutureInit = buildFutureInitFunctionDefinition(*this, RD, TransformedFD, + FutureInitDef); } if (!FutureInit) { @@ -3150,25 +3683,27 @@ SmallVector Sema::ActOnAsyncFunctionDefinition(FunctionDecl *FD) { } Decls.push_back(FutureInit); Context.BSCDesugaredMap[FD].push_back(FutureInit); + Context.BSCFuncDesugaredMap[FutureInit] = FD; BSCMethodDecl *FreeDecl = - buildFreeFunctionDefinition(*this, RD, FD, IsOptimization); + buildFreeFunctionDefinition(*this, RD, TransformedFD, IsOptimization); if (!FreeDecl) { return Decls; } Decls.push_back(FreeDecl); Context.BSCDesugaredMap[FD].push_back(FreeDecl); - BSCMethodDecl *PollDecl = buildPollFunctionDefinition( - *this, RD, PollResultRD, FD, FatPointerRD, FutureStateNumber); + BSCMethodDecl *PollDecl = + buildPollFunctionDefinition(*this, RD, PollResultRD, TransformedFD, FD, + FatPointerRD, FutureStateNumber); if (!PollDecl) { return Decls; } Decls.push_back(PollDecl); Context.BSCDesugaredMap[FD].push_back(PollDecl); - VarDecl *VtableDecl = - buildVtableInitDecl(*this, FD, Context.getRecordType(RD), ReturnTy, true); + VarDecl *VtableDecl = buildVtableInitDecl( + *this, TransformedFD, Context.getRecordType(RD), ReturnTy, true); if (!VtableDecl) { return Decls; } diff --git a/clang/lib/Serialization/ASTReaderStmt.cpp b/clang/lib/Serialization/ASTReaderStmt.cpp index 8842ad291d47242b4b2c2e770296a07b8c867b58..bcf72d58b3da3536a1278e1cee194260073ed6e6 100644 --- a/clang/lib/Serialization/ASTReaderStmt.cpp +++ b/clang/lib/Serialization/ASTReaderStmt.cpp @@ -3491,7 +3491,7 @@ Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) { CollapsedNum, Empty); break; } - + case STMT_OMP_MASKED_TASKLOOP_DIRECTIVE: { unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; diff --git a/clang/test/BSC/Positive/Coroutine/AwaitExpr/await-expr-nest-await/await-expr-nest-await.cbs b/clang/test/BSC/Positive/Coroutine/AwaitExpr/await-expr-nest-await/await-expr-nest-await.cbs index b396ba64bbfdb1f4fc30e18a7a503c9b5e0abc07..cb76db49618603630644d7be7e1a13b60762b2cd 100644 --- a/clang/test/BSC/Positive/Coroutine/AwaitExpr/await-expr-nest-await/await-expr-nest-await.cbs +++ b/clang/test/BSC/Positive/Coroutine/AwaitExpr/await-expr-nest-await/await-expr-nest-await.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -23,4 +24,29 @@ int main() { this->poll(); this->free(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: int result; +// CHECK-NEXT: int a; +// CHECK-NEXT: int a_1; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->a_1 = this->start; +// CHECK-NEXT: this->a = 0; +// CHECK-NEXT: this->result = 0; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->result; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/AwaitExpr/await-expr-num/await-expr-num.cbs b/clang/test/BSC/Positive/Coroutine/AwaitExpr/await-expr-num/await-expr-num.cbs index fe03758e09551cacf336a09a214dcf7fb8e1ffbd..2c940dc686240878bb3d02edb001ae8b23f95cbe 100644 --- a/clang/test/BSC/Positive/Coroutine/AwaitExpr/await-expr-num/await-expr-num.cbs +++ b/clang/test/BSC/Positive/Coroutine/AwaitExpr/await-expr-num/await-expr-num.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -55,3 +56,46 @@ int main() { this->poll(); return 0; } + +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: int result; +// CHECK-NEXT: int a; +// CHECK-NEXT: struct __Trait_Future_int Ft_1; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: case 1: +// CHECK-NEXT: goto __L1; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->a = 2; +// CHECK-NEXT: this->result = 0; +// CHECK-NEXT: if (this->start < 20) { +// CHECK-NEXT: this->Ft_1 = test2(1); +// CHECK-NEXT: __L1: +// CHECK-NEXT: ; +// CHECK-NEXT: int Res_1; +// CHECK-NEXT: struct PollResult_int PR_1 = this->Ft_1.vtable->poll(this->Ft_1.data); +// CHECK-NEXT: if (struct_PollResult_int_is_completed(&PR_1, &Res_1)) { +// CHECK-NEXT: if (this->Ft_1.data != 0) { +// CHECK-NEXT: this->Ft_1.vtable->free(this->Ft_1.data); +// CHECK-NEXT: this->Ft_1.data = (void *)0; +// CHECK-NEXT: } +// CHECK-NEXT: } else { +// CHECK-NEXT: this->__future_state = 1; +// CHECK-NEXT: return struct_PollResult_int_pending(); +// CHECK-NEXT: } +// CHECK-NEXT: this->start = Res_1; +// CHECK-NEXT: } +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->result + this->start; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } diff --git a/clang/test/BSC/Positive/Coroutine/AwaitExpr/await-expr-of-return/await-expr-of-return.cbs b/clang/test/BSC/Positive/Coroutine/AwaitExpr/await-expr-of-return/await-expr-of-return.cbs index 4752fa62176986ec3af9670a5c84547f792ee194..6b8b724779938ed38411e8c62a733b5a8d21c7e0 100644 --- a/clang/test/BSC/Positive/Coroutine/AwaitExpr/await-expr-of-return/await-expr-of-return.cbs +++ b/clang/test/BSC/Positive/Coroutine/AwaitExpr/await-expr-of-return/await-expr-of-return.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -33,3 +34,46 @@ int main() { this->poll(); return 0; } + +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: int a; +// CHECK-NEXT: int a_1; +// CHECK-NEXT: int b; +// CHECK-NEXT: int a_2; +// CHECK-NEXT: int a_3; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->a_1 = 2; +// CHECK-NEXT: this->a = 0; +// CHECK-NEXT: this->b = 2; +// CHECK-NEXT: if (this->a == 1) { +// CHECK-NEXT: if (this->b == 3) { +// CHECK-NEXT: this->a_2 = 3; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = 0; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } +// CHECK-NEXT: this->a_3 = 2; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN_1 = 0; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN_1); +// CHECK-NEXT: } +// CHECK-NEXT: } +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN_2 = this->start; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN_2); +// CHECK-NEXT: } +// CHECK-NEXT:} diff --git a/clang/test/BSC/Positive/Coroutine/AwaitExpr/await-expr-single-judgement/await-expr-single-judgement.cbs b/clang/test/BSC/Positive/Coroutine/AwaitExpr/await-expr-single-judgement/await-expr-single-judgement.cbs index 637b13afd21e99c62afb26c2893d8c4e2d51b1f0..369b58a3a1d62bf3aabe09ad25cff8c77594db2f 100644 --- a/clang/test/BSC/Positive/Coroutine/AwaitExpr/await-expr-single-judgement/await-expr-single-judgement.cbs +++ b/clang/test/BSC/Positive/Coroutine/AwaitExpr/await-expr-single-judgement/await-expr-single-judgement.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -16,7 +17,7 @@ async int read(int a) { async int f(int start) { int a = 3; if (a == 3) - for(int i=0;i<1; i++) + for(int i = 0; i < 1; i++) a = await read(1); else if (a == 4) { if (a == 4) @@ -42,4 +43,62 @@ int main() { trait Future *this = f(1); this->poll(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: int a; +// CHECK-NEXT: int i; +// CHECK-NEXT: int a_1; +// CHECK-NEXT: int a_2; +// CHECK-NEXT: int a_3; +// CHECK-NEXT: int b; +// CHECK-NEXT: int a_4; +// CHECK-NEXT: int a_5; +// CHECK-NEXT: int a_6; +// CHECK-NEXT: int a_7; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->a = 3; +// CHECK-NEXT: if (this->a == 3) +// CHECK-NEXT: for (this->i = 0; this->i < 1; this->i++) { +// CHECK-NEXT: this->a_1 = 1; +// CHECK-NEXT: this->a = 0; +// CHECK-NEXT: } +// CHECK-NEXT: else if (this->a == 4) { +// CHECK-NEXT: if (this->a == 4) { +// CHECK-NEXT: this->a_2 = 1; +// CHECK-NEXT: this->a = 0; +// CHECK-NEXT: } +// CHECK-NEXT: } else { +// CHECK-NEXT: this->a_3 = 1; +// CHECK-NEXT: this->a = 0; +// CHECK-NEXT: } +// CHECK-NEXT: this->b = 0; +// CHECK-NEXT: this->a_4 = 2; +// CHECK-NEXT: this->a = 0; +// CHECK-NEXT: while (this->b != this->a) +// CHECK-NEXT: { +// CHECK-NEXT: this->a_5 = 2; +// CHECK-NEXT: this->b = 0; +// CHECK-NEXT: } +// CHECK-NEXT: this->a_6 = 3; +// CHECK-NEXT: this->a = 0; +// CHECK-NEXT: do { +// CHECK-NEXT: this->a_7 = 3; +// CHECK-NEXT: this->b = 0; +// CHECK-NEXT: } while (this->b != this->a); +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->start; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/BenchMark/tcp_demo/tcp_demo.cbs b/clang/test/BSC/Positive/Coroutine/BenchMark/matrix_calculation/matrix_calculation.cbs similarity index 96% rename from clang/test/BSC/Positive/Coroutine/BenchMark/tcp_demo/tcp_demo.cbs rename to clang/test/BSC/Positive/Coroutine/BenchMark/matrix_calculation/matrix_calculation.cbs index 00c175a3fb5f4eab04c3bc8892aa737992de2f62..4f7637c9783c11c503358ffb3df19c5ad98674fc 100644 --- a/clang/test/BSC/Positive/Coroutine/BenchMark/tcp_demo/tcp_demo.cbs +++ b/clang/test/BSC/Positive/Coroutine/BenchMark/matrix_calculation/matrix_calculation.cbs @@ -54,13 +54,13 @@ void FileWriter::free(FileWriter *this) {} impl trait Future for FileWriter; -async void createMatrix(int matrix[ROW][COL]) { +async void createMatrix() { int i, j, k = 0; srand((unsigned)time(NULL)); for (i = 0; i < ROW; i++) { for (j = 0; j < COL; j++) { - matrix[i][j] = rand() %2; + // matrix[i][j] = rand() % 2; } } } @@ -84,8 +84,8 @@ async void matrixCalculation() { int result[ROW][COL]; char buffer[BUFFER_SIZE] = {0}; - await createMatrix(matrix1); - await createMatrix(matrix2); + await createMatrix(); + await createMatrix(); await multiMatrix(matrix1, matrix2, result); FILE *file = fopen("./matrix.txt", "w"); diff --git a/clang/test/BSC/Positive/Coroutine/BenchMark/tcp_demo/noise.cbs b/clang/test/BSC/Positive/Coroutine/BenchMark/matrix_calculation/noise.cbs similarity index 100% rename from clang/test/BSC/Positive/Coroutine/BenchMark/tcp_demo/noise.cbs rename to clang/test/BSC/Positive/Coroutine/BenchMark/matrix_calculation/noise.cbs diff --git a/clang/test/BSC/Positive/Coroutine/BenchMark/tcp_demo/noise.hbs b/clang/test/BSC/Positive/Coroutine/BenchMark/matrix_calculation/noise.hbs similarity index 100% rename from clang/test/BSC/Positive/Coroutine/BenchMark/tcp_demo/noise.hbs rename to clang/test/BSC/Positive/Coroutine/BenchMark/matrix_calculation/noise.hbs diff --git a/clang/test/BSC/Positive/Coroutine/BenchMark/tcp_demo/queue.hbs b/clang/test/BSC/Positive/Coroutine/BenchMark/matrix_calculation/queue.hbs similarity index 100% rename from clang/test/BSC/Positive/Coroutine/BenchMark/tcp_demo/queue.hbs rename to clang/test/BSC/Positive/Coroutine/BenchMark/matrix_calculation/queue.hbs diff --git a/clang/test/BSC/Positive/Coroutine/BenchMark/tcp_demo/scheduler.cbs b/clang/test/BSC/Positive/Coroutine/BenchMark/matrix_calculation/scheduler.cbs similarity index 100% rename from clang/test/BSC/Positive/Coroutine/BenchMark/tcp_demo/scheduler.cbs rename to clang/test/BSC/Positive/Coroutine/BenchMark/matrix_calculation/scheduler.cbs diff --git a/clang/test/BSC/Positive/Coroutine/BenchMark/tcp_demo/scheduler.hbs b/clang/test/BSC/Positive/Coroutine/BenchMark/matrix_calculation/scheduler.hbs similarity index 100% rename from clang/test/BSC/Positive/Coroutine/BenchMark/tcp_demo/scheduler.hbs rename to clang/test/BSC/Positive/Coroutine/BenchMark/matrix_calculation/scheduler.hbs diff --git a/clang/test/BSC/Positive/Coroutine/BenchMark/tcp_demo_rewrite/future.h b/clang/test/BSC/Positive/Coroutine/BenchMark/matrix_calculation_rewrite/future.h similarity index 100% rename from clang/test/BSC/Positive/Coroutine/BenchMark/tcp_demo_rewrite/future.h rename to clang/test/BSC/Positive/Coroutine/BenchMark/matrix_calculation_rewrite/future.h diff --git a/clang/test/BSC/Positive/Coroutine/BenchMark/tcp_demo_rewrite/tcp_demo.c b/clang/test/BSC/Positive/Coroutine/BenchMark/matrix_calculation_rewrite/matrix_calculation.c similarity index 100% rename from clang/test/BSC/Positive/Coroutine/BenchMark/tcp_demo_rewrite/tcp_demo.c rename to clang/test/BSC/Positive/Coroutine/BenchMark/matrix_calculation_rewrite/matrix_calculation.c diff --git a/clang/test/BSC/Positive/Coroutine/BenchMark/tcp_demo_rewrite/noise.c b/clang/test/BSC/Positive/Coroutine/BenchMark/matrix_calculation_rewrite/noise.c similarity index 100% rename from clang/test/BSC/Positive/Coroutine/BenchMark/tcp_demo_rewrite/noise.c rename to clang/test/BSC/Positive/Coroutine/BenchMark/matrix_calculation_rewrite/noise.c diff --git a/clang/test/BSC/Positive/Coroutine/BenchMark/tcp_demo_rewrite/noise.h b/clang/test/BSC/Positive/Coroutine/BenchMark/matrix_calculation_rewrite/noise.h similarity index 100% rename from clang/test/BSC/Positive/Coroutine/BenchMark/tcp_demo_rewrite/noise.h rename to clang/test/BSC/Positive/Coroutine/BenchMark/matrix_calculation_rewrite/noise.h diff --git a/clang/test/BSC/Positive/Coroutine/BenchMark/tcp_demo_rewrite/queue.h b/clang/test/BSC/Positive/Coroutine/BenchMark/matrix_calculation_rewrite/queue.h similarity index 100% rename from clang/test/BSC/Positive/Coroutine/BenchMark/tcp_demo_rewrite/queue.h rename to clang/test/BSC/Positive/Coroutine/BenchMark/matrix_calculation_rewrite/queue.h diff --git a/clang/test/BSC/Positive/Coroutine/BenchMark/tcp_demo_rewrite/scheduler.c b/clang/test/BSC/Positive/Coroutine/BenchMark/matrix_calculation_rewrite/scheduler.c similarity index 100% rename from clang/test/BSC/Positive/Coroutine/BenchMark/tcp_demo_rewrite/scheduler.c rename to clang/test/BSC/Positive/Coroutine/BenchMark/matrix_calculation_rewrite/scheduler.c diff --git a/clang/test/BSC/Positive/Coroutine/BenchMark/tcp_demo_rewrite/scheduler.h b/clang/test/BSC/Positive/Coroutine/BenchMark/matrix_calculation_rewrite/scheduler.h similarity index 100% rename from clang/test/BSC/Positive/Coroutine/BenchMark/tcp_demo_rewrite/scheduler.h rename to clang/test/BSC/Positive/Coroutine/BenchMark/matrix_calculation_rewrite/scheduler.h diff --git a/clang/test/BSC/Positive/Coroutine/Other/Definition/async_definition_1/async_definition_1.cbs b/clang/test/BSC/Positive/Coroutine/Other/Definition/async_definition_1/async_definition_1.cbs index 9b4436d85d8d79bbc245523b8e83e00d0810bab6..e8039de171f26a07e5c851b6295511910e8c14d7 100644 --- a/clang/test/BSC/Positive/Coroutine/Other/Definition/async_definition_1/async_definition_1.cbs +++ b/clang/test/BSC/Positive/Coroutine/Other/Definition/async_definition_1/async_definition_1.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -29,4 +30,57 @@ int main() { trait Future* this = f(); this->poll(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futureg { +// CHECK-NEXT: int a; +// CHECK-NEXT: int a_1; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: case 1: +// CHECK-NEXT: goto __L1; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->Ft_1 = __g(); +// CHECK-NEXT: __L1: +// CHECK-NEXT: ; +// CHECK-NEXT: int Res_1; +// CHECK-NEXT: struct PollResult_int PR_1 = struct__Futureg_poll(this->Ft_1); +// CHECK-NEXT: if (struct_PollResult_int_is_completed(&PR_1, &Res_1)) { +// CHECK-NEXT: { +// CHECK-NEXT: struct__Futureg_free(this->Ft_1); +// CHECK-NEXT: this->Ft_1 = (struct _Futureg *)0; +// CHECK-NEXT: } +// CHECK-NEXT: } else { +// CHECK-NEXT: this->__future_state = 1; +// CHECK-NEXT: return struct_PollResult_int_pending(); +// CHECK-NEXT: } +// CHECK-NEXT: this->a = Res_1; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->a; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } + +// CHECK: struct PollResult_int struct__Futureg_poll(struct _Futureg *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->a_1 = 1; +// CHECK-NEXT: this->a = 0; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = 0; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Other/DifferenctReturnType/async-different-return-type2/async-different-return-type2.cbs b/clang/test/BSC/Positive/Coroutine/Other/DifferenctReturnType/async-different-return-type2/async-different-return-type2.cbs index 8558d22d19fe1308c70ed6dd99a99e39e305f894..0a7f4023ae79418b46129d9500ee7bb7acc382c8 100644 --- a/clang/test/BSC/Positive/Coroutine/Other/DifferenctReturnType/async-different-return-type2/async-different-return-type2.cbs +++ b/clang/test/BSC/Positive/Coroutine/Other/DifferenctReturnType/async-different-return-type2/async-different-return-type2.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -32,4 +33,43 @@ int main() { this->poll(); this->free(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futureg { +// CHECK-NEXT: struct __Trait_Future_int a; +// CHECK-NEXT: struct __Trait_Future_int Ft_1; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult__Bool struct__Futureg_poll(struct _Futureg *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: case 1: +// CHECK-NEXT: goto __L1; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: struct __Trait_Future_int a = {__read(1), &__struct__Futureread_trait_Future}; +// CHECK-NEXT: this->a = a; +// CHECK-NEXT: this->Ft_1 = this->a; +// CHECK-NEXT: __L1: +// CHECK-NEXT: ; +// CHECK-NEXT: int Res_1; +// CHECK-NEXT: struct PollResult_int PR_1 = this->Ft_1.vtable->poll(this->Ft_1.data); +// CHECK-NEXT: if (struct_PollResult_int_is_completed(&PR_1, &Res_1)) { +// CHECK-NEXT: if (this->Ft_1.data != 0) { +// CHECK-NEXT: this->Ft_1.vtable->free(this->Ft_1.data); +// CHECK-NEXT: this->Ft_1.data = (void *)0; +// CHECK-NEXT: } +// CHECK-NEXT: } else { +// CHECK-NEXT: this->__future_state = 1; +// CHECK-NEXT: return struct_PollResult__Bool_pending(); +// CHECK-NEXT: } +// CHECK-NEXT: Res_1; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: _Bool __RES_RETURN = 0; +// CHECK-NEXT: return struct_PollResult__Bool_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Other/DifferenctReturnType/async-type-with-pointer/async-type-with-pointer.cbs b/clang/test/BSC/Positive/Coroutine/Other/DifferenctReturnType/async-type-with-pointer/async-type-with-pointer.cbs index 10829903686573f5eb4221cf87d1e8224e932d22..863fbcf58b13299252eb4764c06b87a70d3c0279 100644 --- a/clang/test/BSC/Positive/Coroutine/Other/DifferenctReturnType/async-type-with-pointer/async-type-with-pointer.cbs +++ b/clang/test/BSC/Positive/Coroutine/Other/DifferenctReturnType/async-type-with-pointer/async-type-with-pointer.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -31,4 +32,41 @@ int main() trait Future* this = f(); this->poll(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int a; +// CHECK-NEXT: int *b; +// CHECK-NEXT: int c; +// CHECK-NEXT: int c_1; +// CHECK-NEXT: int a_1; +// CHECK-NEXT: int c_2; +// CHECK-NEXT: int a_2; +// CHECK-NEXT: int *d; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int_P struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->a = 1; +// CHECK-NEXT: this->b = &this->a; +// CHECK-NEXT: if (this->a == 1) { +// CHECK-NEXT: if (*this->b == 3) { +// CHECK-NEXT: this->a_1 = 3; +// CHECK-NEXT: this->c_1 = 0; +// CHECK-NEXT: } +// CHECK-NEXT: this->a_2 = 2; +// CHECK-NEXT: this->c_2 = 0; +// CHECK-NEXT: } +// CHECK-NEXT: this->d = &this->c; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int *__RES_RETURN = this->d; +// CHECK-NEXT: return struct_PollResult_int_P_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Other/DifferenctReturnType/await-different-return-type/await-different-return-type.cbs b/clang/test/BSC/Positive/Coroutine/Other/DifferenctReturnType/await-different-return-type/await-different-return-type.cbs index c50186316d1fe9cc79a1b368cff91cb04fa8eaa6..12b0a47f46aa25ee971ec61e6280e89082507d86 100644 --- a/clang/test/BSC/Positive/Coroutine/Other/DifferenctReturnType/await-different-return-type/await-different-return-type.cbs +++ b/clang/test/BSC/Positive/Coroutine/Other/DifferenctReturnType/await-different-return-type/await-different-return-type.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -30,4 +31,43 @@ int main() { this->poll(); this->free(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futureg { +// CHECK-NEXT: struct __Trait_Future_int a; +// CHECK-NEXT: struct __Trait_Future_int Ft_1; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_struct_Void struct__Futureg_poll(struct _Futureg *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: case 1: +// CHECK-NEXT: goto __L1; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: struct __Trait_Future_int a = {__read(1), &__struct__Futureread_trait_Future}; +// CHECK-NEXT: this->a = a; +// CHECK-NEXT: this->Ft_1 = this->a; +// CHECK-NEXT: __L1: +// CHECK-NEXT: ; +// CHECK-NEXT: int Res_1; +// CHECK-NEXT: struct PollResult_int PR_1 = this->Ft_1.vtable->poll(this->Ft_1.data); +// CHECK-NEXT: if (struct_PollResult_int_is_completed(&PR_1, &Res_1)) { +// CHECK-NEXT: if (this->Ft_1.data != 0) { +// CHECK-NEXT: this->Ft_1.vtable->free(this->Ft_1.data); +// CHECK-NEXT: this->Ft_1.data = (void *)0; +// CHECK-NEXT: } +// CHECK-NEXT: } else { +// CHECK-NEXT: this->__future_state = 1; +// CHECK-NEXT: return struct_PollResult_struct_Void_pending(); +// CHECK-NEXT: } +// CHECK-NEXT: Res_1; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: struct Void __RES_RETURN = (struct Void){}; +// CHECK-NEXT: return struct_PollResult_struct_Void_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Other/DifferenctReturnType/typealias-return-type/typealias-return-type.cbs b/clang/test/BSC/Positive/Coroutine/Other/DifferenctReturnType/typealias-return-type/typealias-return-type.cbs index 16909322634f5fc17ad8deac6a3d1771374d0d8e..e08f45c9b0bc3af590d01c149475b0071d2a6968 100644 --- a/clang/test/BSC/Positive/Coroutine/Other/DifferenctReturnType/typealias-return-type/typealias-return-type.cbs +++ b/clang/test/BSC/Positive/Coroutine/Other/DifferenctReturnType/typealias-return-type/typealias-return-type.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -48,4 +49,38 @@ int main() { this->poll(); this->free(); return 0; -} \ No newline at end of file +} + +// CHECK: struct PollResult_unsigned_int struct__Futureh_poll(struct _Futureh *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: case 1: +// CHECK-NEXT: goto __L1; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->i = 0; +// CHECK-NEXT: this->i_1 = 0; +// CHECK-NEXT: this->Ft_1 = CallBack(); +// CHECK-NEXT: __L1: +// CHECK-NEXT: ; +// CHECK-NEXT: unsigned int Res_1; +// CHECK-NEXT: struct PollResult_unsigned_int PR_1 = this->Ft_1.vtable->poll(this->Ft_1.data); +// CHECK-NEXT: if (struct_PollResult_unsigned_int_is_completed(&PR_1, &Res_1)) { +// CHECK-NEXT: if (this->Ft_1.data != 0) { +// CHECK-NEXT: this->Ft_1.vtable->free(this->Ft_1.data); +// CHECK-NEXT: this->Ft_1.data = (void *)0; +// CHECK-NEXT: } +// CHECK-NEXT: } else { +// CHECK-NEXT: this->__future_state = 1; +// CHECK-NEXT: return struct_PollResult_unsigned_int_pending(); +// CHECK-NEXT: } +// CHECK-NEXT: this->i_1 = Res_1; +// CHECK-NEXT: this->i = this->i_1; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: UINT32 __RES_RETURN = this->i; +// CHECK-NEXT: return struct_PollResult_unsigned_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Other/FuncPointer/async-bscmethod-as-func-pointer/async-bscmethod-as-func-pointer.cbs b/clang/test/BSC/Positive/Coroutine/Other/FuncPointer/async-bscmethod-as-func-pointer/async-bscmethod-as-func-pointer.cbs index 840db488f31a1cf3c8816e4a42afbda7f5e49a00..d9ec3027fee27fb0ebf15d53d4f0e71784e13a22 100644 --- a/clang/test/BSC/Positive/Coroutine/Other/FuncPointer/async-bscmethod-as-func-pointer/async-bscmethod-as-func-pointer.cbs +++ b/clang/test/BSC/Positive/Coroutine/Other/FuncPointer/async-bscmethod-as-func-pointer/async-bscmethod-as-func-pointer.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -28,4 +29,60 @@ async int f(int start) { int main() { return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: int result; +// CHECK-NEXT: struct __Trait_Future_int Ft_1; +// CHECK-NEXT: struct __Trait_Future_int Ft_2; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: case 1: +// CHECK-NEXT: goto __L1; +// CHECK-NEXT: case 2: +// CHECK-NEXT: goto __L2; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->Ft_1 = CallBack(1); +// CHECK-NEXT: __L1: +// CHECK-NEXT: ; +// CHECK-NEXT: int Res_1; +// CHECK-NEXT: struct PollResult_int PR_1 = this->Ft_1.vtable->poll(this->Ft_1.data); +// CHECK-NEXT: if (struct_PollResult_int_is_completed(&PR_1, &Res_1)) { +// CHECK-NEXT: if (this->Ft_1.data != 0) { +// CHECK-NEXT: this->Ft_1.vtable->free(this->Ft_1.data); +// CHECK-NEXT: this->Ft_1.data = (void *)0; +// CHECK-NEXT: } +// CHECK-NEXT: } else { +// CHECK-NEXT: this->__future_state = 1; +// CHECK-NEXT: return struct_PollResult_int_pending(); +// CHECK-NEXT: } +// CHECK-NEXT: this->result = Res_1; +// CHECK-NEXT: this->Ft_2 = CallBack2(&this->result); +// CHECK-NEXT: __L2: +// CHECK-NEXT: ; +// CHECK-NEXT: int Res_2; +// CHECK-NEXT: struct PollResult_int PR_2 = this->Ft_2.vtable->poll(this->Ft_2.data); +// CHECK-NEXT: if (struct_PollResult_int_is_completed(&PR_2, &Res_2)) { +// CHECK-NEXT: if (this->Ft_2.data != 0) { +// CHECK-NEXT: this->Ft_2.vtable->free(this->Ft_2.data); +// CHECK-NEXT: this->Ft_2.data = (void *)0; +// CHECK-NEXT: } +// CHECK-NEXT: } else { +// CHECK-NEXT: this->__future_state = 2; +// CHECK-NEXT: return struct_PollResult_int_pending(); +// CHECK-NEXT: } +// CHECK-NEXT: this->result = Res_2; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->result; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Other/FuncPointer/async-func-as-func-pointer/async-func-as-func-pointer.cbs b/clang/test/BSC/Positive/Coroutine/Other/FuncPointer/async-func-as-func-pointer/async-func-as-func-pointer.cbs index c8bf451f701311268d3d66bcc7176f200a775f83..466b423d8c533c07f522427893932e751107edde 100644 --- a/clang/test/BSC/Positive/Coroutine/Other/FuncPointer/async-func-as-func-pointer/async-func-as-func-pointer.cbs +++ b/clang/test/BSC/Positive/Coroutine/Other/FuncPointer/async-func-as-func-pointer/async-func-as-func-pointer.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -21,4 +22,42 @@ async int f(int start) { int main() { return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: int result; +// CHECK-NEXT: struct __Trait_Future_int Ft_1; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: case 1: +// CHECK-NEXT: goto __L1; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->Ft_1 = CallBack(1); +// CHECK-NEXT: __L1: +// CHECK-NEXT: ; +// CHECK-NEXT: int Res_1; +// CHECK-NEXT: struct PollResult_int PR_1 = this->Ft_1.vtable->poll(this->Ft_1.data); +// CHECK-NEXT: if (struct_PollResult_int_is_completed(&PR_1, &Res_1)) { +// CHECK-NEXT: if (this->Ft_1.data != 0) { +// CHECK-NEXT: this->Ft_1.vtable->free(this->Ft_1.data); +// CHECK-NEXT: this->Ft_1.data = (void *)0; +// CHECK-NEXT: } +// CHECK-NEXT: } else { +// CHECK-NEXT: this->__future_state = 1; +// CHECK-NEXT: return struct_PollResult_int_pending(); +// CHECK-NEXT: } +// CHECK-NEXT: this->result = Res_1; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->result; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Other/LoopCall/LoopCall.cbs b/clang/test/BSC/Positive/Coroutine/Other/LoopCall/LoopCall.cbs new file mode 100644 index 0000000000000000000000000000000000000000..b9bf14a14d184f2e94799e29ef83ad21a56ce6bd --- /dev/null +++ b/clang/test/BSC/Positive/Coroutine/Other/LoopCall/LoopCall.cbs @@ -0,0 +1,81 @@ +// RUN: %clang %s -o %test.output +// RUN: %test.output +// RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s +// RUN: %clang %t-rw.c -o %t-rw.output +// RUN: %t-rw.output +// expected-no-diagnostics + +#include "future.hbs" +#include + +async int f2(int n); +async int f3(int n); +async int f1 (int n) { + if (n > 0 ) + await f2(n); + return 0; +} + +async int f2(int n) { + if (n < 0) + n = await f3(1); + return 1; +} + +async int f3(int n) { + if (n > 10) + n = await f1(2); + return 2; +} + +int main() { + trait Future* this = f3(12); + this->poll(); + this->free(); + return 0; +} + +// CHECK: struct _Futuref3 { +// CHECK-NEXT: int n; +// CHECK-NEXT: int n_1; +// CHECK-NEXT: struct _Futuref2 *Ft_1; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref3_poll(struct _Futuref3 *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: case 1: +// CHECK-NEXT: goto __L1; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: if (this->n > 10) { +// CHECK-NEXT: this->n_1 = 2; +// CHECK-NEXT: if (this->n_1 > 0) { +// CHECK-NEXT: this->Ft_1 = __f2(this->n); +// CHECK-NEXT: __L1: +// CHECK-NEXT: ; +// CHECK-NEXT: int Res_1; +// CHECK-NEXT: struct PollResult_int PR_1 = struct__Futuref2_poll(this->Ft_1); +// CHECK-NEXT: if (struct_PollResult_int_is_completed(&PR_1, &Res_1)) { +// CHECK-NEXT: { +// CHECK-NEXT: struct__Futuref2_free(this->Ft_1); +// CHECK-NEXT: this->Ft_1 = (struct _Futuref2 *)0; +// CHECK-NEXT: } +// CHECK-NEXT: } else { +// CHECK-NEXT: this->__future_state = 1; +// CHECK-NEXT: return struct_PollResult_int_pending(); +// CHECK-NEXT: } +// CHECK-NEXT: Res_1; +// CHECK-NEXT: } +// CHECK-NEXT: this->n = 0; +// CHECK-NEXT: } +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = 2; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Other/MemberFunc/async-instance-member-function/async-instance-member-function.cbs b/clang/test/BSC/Positive/Coroutine/Other/MemberFunc/async-instance-member-function/async-instance-member-function.cbs index 4cf83820a2d8bd7ddfdcdcc1b580ca04c2696fd7..9142bee2ac5ef3d7b0f96b66074e29311f2fb8f1 100644 --- a/clang/test/BSC/Positive/Coroutine/Other/MemberFunc/async-instance-member-function/async-instance-member-function.cbs +++ b/clang/test/BSC/Positive/Coroutine/Other/MemberFunc/async-instance-member-function/async-instance-member-function.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -32,4 +33,44 @@ int main() { this->poll(); this->free(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futureg { +// CHECK-NEXT: int *this; +// CHECK-NEXT: struct __Trait_Future_int a; +// CHECK-NEXT: struct __Trait_Future_int Ft_1; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_struct_Void struct__Futureg_poll(struct _Futureg *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: case 1: +// CHECK-NEXT: goto __L1; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: struct __Trait_Future_int a = {__read(1), &__struct__Futureread_trait_Future}; +// CHECK-NEXT: this->a = a; +// CHECK-NEXT: this->Ft_1 = this->a; +// CHECK-NEXT: __L1: +// CHECK-NEXT: ; +// CHECK-NEXT: int Res_1; +// CHECK-NEXT: struct PollResult_int PR_1 = this->Ft_1.vtable->poll(this->Ft_1.data); +// CHECK-NEXT: if (struct_PollResult_int_is_completed(&PR_1, &Res_1)) { +// CHECK-NEXT: if (this->Ft_1.data != 0) { +// CHECK-NEXT: this->Ft_1.vtable->free(this->Ft_1.data); +// CHECK-NEXT: this->Ft_1.data = (void *)0; +// CHECK-NEXT: } +// CHECK-NEXT: } else { +// CHECK-NEXT: this->__future_state = 1; +// CHECK-NEXT: return struct_PollResult_struct_Void_pending(); +// CHECK-NEXT: } +// CHECK-NEXT: Res_1; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: struct Void __RES_RETURN = (struct Void){}; +// CHECK-NEXT: return struct_PollResult_struct_Void_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Other/MemberFunc/async-member-function/async-member-function.cbs b/clang/test/BSC/Positive/Coroutine/Other/MemberFunc/async-member-function/async-member-function.cbs index 8800af524293ba6beebfc4a2d074bd80a8173a9d..4b769024364fc5f610cbfaa271fa811cd3fbd727 100644 --- a/clang/test/BSC/Positive/Coroutine/Other/MemberFunc/async-member-function/async-member-function.cbs +++ b/clang/test/BSC/Positive/Coroutine/Other/MemberFunc/async-member-function/async-member-function.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -30,4 +31,43 @@ int main() { this->poll(); this->free(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futureg { +// CHECK-NEXT: struct __Trait_Future_int a; +// CHECK-NEXT: struct __Trait_Future_int Ft_1; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_struct_Void struct__Futureg_poll(struct _Futureg *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: case 1: +// CHECK-NEXT: goto __L1; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: struct __Trait_Future_int a = {__read(1), &__struct__Futureread_trait_Future}; +// CHECK-NEXT: this->a = a; +// CHECK-NEXT: this->Ft_1 = this->a; +// CHECK-NEXT: __L1: +// CHECK-NEXT: ; +// CHECK-NEXT: int Res_1; +// CHECK-NEXT: struct PollResult_int PR_1 = this->Ft_1.vtable->poll(this->Ft_1.data); +// CHECK-NEXT: if (struct_PollResult_int_is_completed(&PR_1, &Res_1)) { +// CHECK-NEXT: if (this->Ft_1.data != 0) { +// CHECK-NEXT: this->Ft_1.vtable->free(this->Ft_1.data); +// CHECK-NEXT: this->Ft_1.data = (void *)0; +// CHECK-NEXT: } +// CHECK-NEXT: } else { +// CHECK-NEXT: this->__future_state = 1; +// CHECK-NEXT: return struct_PollResult_struct_Void_pending(); +// CHECK-NEXT: } +// CHECK-NEXT: Res_1; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: struct Void __RES_RETURN = (struct Void){}; +// CHECK-NEXT: return struct_PollResult_struct_Void_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Other/MemberFunc/static-async-for-trait-multi-pointer/static-async-for-trait-multi-pointer.cbs b/clang/test/BSC/Positive/Coroutine/Other/MemberFunc/static-async-for-trait-multi-pointer/static-async-for-trait-multi-pointer.cbs index 4408449a2e88ab6f2cdd4ea5bfe8fd21791626e9..8c2c0be9639e1f8b958252b3f5cb697faf5409fe 100644 --- a/clang/test/BSC/Positive/Coroutine/Other/MemberFunc/static-async-for-trait-multi-pointer/static-async-for-trait-multi-pointer.cbs +++ b/clang/test/BSC/Positive/Coroutine/Other/MemberFunc/static-async-for-trait-multi-pointer/static-async-for-trait-multi-pointer.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -30,4 +31,46 @@ int main() { this->poll(); this->free(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futureg { +// CHECK-NEXT: struct __Trait_Future_int a; +// CHECK-NEXT: struct __Trait_Future_int *b; +// CHECK-NEXT: int tmp; +// CHECK-NEXT: struct __Trait_Future_int Ft_1; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: case 1: +// CHECK-NEXT: goto __L1; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: struct __Trait_Future_int a = {__read(1), &__struct__Futureread_trait_Future}; +// CHECK-NEXT: this->a = a; +// CHECK-NEXT: this->b = &this->a; +// CHECK-NEXT: this->Ft_1 = *this->b; +// CHECK-NEXT: __L1: +// CHECK-NEXT: ; +// CHECK-NEXT: int Res_1; +// CHECK-NEXT: struct PollResult_int PR_1 = this->Ft_1.vtable->poll(this->Ft_1.data); +// CHECK-NEXT: if (struct_PollResult_int_is_completed(&PR_1, &Res_1)) { +// CHECK-NEXT: if (this->Ft_1.data != 0) { +// CHECK-NEXT: this->Ft_1.vtable->free(this->Ft_1.data); +// CHECK-NEXT: this->Ft_1.data = (void *)0; +// CHECK-NEXT: } +// CHECK-NEXT: } else { +// CHECK-NEXT: this->__future_state = 1; +// CHECK-NEXT: return struct_PollResult_int_pending(); +// CHECK-NEXT: } +// CHECK-NEXT: this->tmp = Res_1; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = 0; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Other/MemberFunc/static-async-member-function/static-async-member-function.cbs b/clang/test/BSC/Positive/Coroutine/Other/MemberFunc/static-async-member-function/static-async-member-function.cbs index 401ee3ffda010176e19339519f118d578daa0fa0..97c407b4696226f04c7539374716f929ca8bf6c8 100644 --- a/clang/test/BSC/Positive/Coroutine/Other/MemberFunc/static-async-member-function/static-async-member-function.cbs +++ b/clang/test/BSC/Positive/Coroutine/Other/MemberFunc/static-async-member-function/static-async-member-function.cbs @@ -48,18 +48,23 @@ int main() { //CHECK-NEXT: } //CHECK-NEXT: __L0: //CHECK-NEXT: ; -//CHECK-NEXT: this->Ft_1 = int___g(); +//CHECK-NEXT: struct __Trait_Future_int a = {__read(1), &__struct__Futureread_trait_Future}; +//CHECK-NEXT: this->a = a; +//CHECK-NEXT: this->Ft_1 = this->a; //CHECK-NEXT: __L1: //CHECK-NEXT: ; //CHECK-NEXT: int Res_1; -//CHECK-NEXT: struct PollResult_int PR_1 = struct__Futureg_poll(&this->Ft_1); +//CHECK-NEXT: struct PollResult_int PR_1 = this->Ft_1.vtable->poll(this->Ft_1.data); //CHECK-NEXT: if (struct_PollResult_int_is_completed(&PR_1, &Res_1)) { -//CHECK-NEXT: struct__Futureg_free(&this->Ft_1); +//CHECK-NEXT: if (this->Ft_1.data != 0) { +//CHECK-NEXT: this->Ft_1.vtable->free(this->Ft_1.data); +//CHECK-NEXT: this->Ft_1.data = (void *)0; +//CHECK-NEXT: } //CHECK-NEXT: } else { //CHECK-NEXT: this->__future_state = 1; //CHECK-NEXT: return struct_PollResult_int_pending(); //CHECK-NEXT: } -//CHECK-NEXT: Res_1; +//CHECK-NEXT: this->tmp = Res_1; //CHECK-NEXT: { //CHECK-NEXT: this->__future_state = -1; //CHECK-NEXT: int __RES_RETURN = 0; diff --git a/clang/test/BSC/Positive/Coroutine/Other/NonCallAwaitExpr/await-non-call/await-non-call.cbs b/clang/test/BSC/Positive/Coroutine/Other/NonCallAwaitExpr/await-non-call/await-non-call.cbs index ff94fbeb5de5524be04f058a76ef51667430b295..3216ab7c105a72ff49ef0de0ff2e8b1613ba5456 100644 --- a/clang/test/BSC/Positive/Coroutine/Other/NonCallAwaitExpr/await-non-call/await-non-call.cbs +++ b/clang/test/BSC/Positive/Coroutine/Other/NonCallAwaitExpr/await-non-call/await-non-call.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -31,4 +32,43 @@ int main() { this->poll(); this->free(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futureg { +// CHECK-NEXT: struct __Trait_Future_int a; +// CHECK-NEXT: struct __Trait_Future_int Ft_1; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futureg_poll(struct _Futureg *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: case 1: +// CHECK-NEXT: goto __L1; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: struct __Trait_Future_int a = {__read(1), &__struct__Futureread_trait_Future}; +// CHECK-NEXT: this->a = a; +// CHECK-NEXT: this->Ft_1 = this->a; +// CHECK-NEXT: __L1: +// CHECK-NEXT: ; +// CHECK-NEXT: int Res_1; +// CHECK-NEXT: struct PollResult_int PR_1 = this->Ft_1.vtable->poll(this->Ft_1.data); +// CHECK-NEXT: if (struct_PollResult_int_is_completed(&PR_1, &Res_1)) { +// CHECK-NEXT: if (this->Ft_1.data != 0) { +// CHECK-NEXT: this->Ft_1.vtable->free(this->Ft_1.data); +// CHECK-NEXT: this->Ft_1.data = (void *)0; +// CHECK-NEXT: } +// CHECK-NEXT: } else { +// CHECK-NEXT: this->__future_state = 1; +// CHECK-NEXT: return struct_PollResult_int_pending(); +// CHECK-NEXT: } +// CHECK-NEXT: Res_1; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = 0; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Other/RecursiveCall/recursive-async-call2/recursive-async-call2.cbs b/clang/test/BSC/Positive/Coroutine/Other/RecursiveCall/recursive-async-call2/recursive-async-call2.cbs new file mode 100644 index 0000000000000000000000000000000000000000..c79f9ba12f2dbd88f253cddf33a75c22824d0996 --- /dev/null +++ b/clang/test/BSC/Positive/Coroutine/Other/RecursiveCall/recursive-async-call2/recursive-async-call2.cbs @@ -0,0 +1,82 @@ +// RUN: %clang %s -o %test.output +// RUN: %test.output +// RUN: %clang -rewrite-bsc %S/../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h +// RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s +// RUN: %clang %t-rw.c -o %t-rw.output +// RUN: %t-rw.output +// expected-no-diagnostics + +#include "future.hbs" +#include + +async int f1(int n) { + if (n == 0) + return 1; + int m = await f1(n - 1); + return n * m; +} + +async void f2() { + int n = 5; + int m = await f1(n); + m = m - n; +} + +int main() { + trait Future* this = f2(); + this->poll(); + this->free(); + return 0; +} + +// CHECK: struct _Futuref2 { +// CHECK-NEXT: int n; +// CHECK-NEXT: int m; +// CHECK-NEXT: int n_1; +// CHECK-NEXT: int m_1; +// CHECK-NEXT: struct _Futuref1 *Ft_1; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_struct_Void struct__Futuref2_poll(struct _Futuref2 *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: case 1: +// CHECK-NEXT: goto __L1; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->n = 5; +// CHECK-NEXT: this->n_1 = this->n; +// CHECK-NEXT: if (this->n_1 == 0) { +// CHECK-NEXT: this->m = 1; +// CHECK-NEXT: goto __NextStmt_1; +// CHECK-NEXT: } +// CHECK-NEXT: this->Ft_1 = __f1(this->n_1 - 1); +// CHECK-NEXT: __L1: +// CHECK-NEXT: ; +// CHECK-NEXT: int Res_1; +// CHECK-NEXT: struct PollResult_int PR_1 = struct__Futuref1_poll(this->Ft_1); +// CHECK-NEXT: if (struct_PollResult_int_is_completed(&PR_1, &Res_1)) { +// CHECK-NEXT: { +// CHECK-NEXT: struct__Futuref1_free(this->Ft_1); +// CHECK-NEXT: this->Ft_1 = (struct _Futuref1 *)0; +// CHECK-NEXT: } +// CHECK-NEXT: } else { +// CHECK-NEXT: this->__future_state = 1; +// CHECK-NEXT: return struct_PollResult_struct_Void_pending(); +// CHECK-NEXT: } +// CHECK-NEXT: this->m_1 = Res_1; +// CHECK-NEXT: this->m = this->n_1 * this->m_1; +// CHECK-NEXT: goto __NextStmt_1; +// CHECK-NEXT: __NextStmt_1: +// CHECK-NEXT: ; +// CHECK-NEXT: this->m = this->m - this->n; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: struct Void __RES_RETURN = (struct Void){}; +// CHECK-NEXT: return struct_PollResult_struct_Void_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Other/async-func-pointer-2/async-func-pointer-2.cbs b/clang/test/BSC/Positive/Coroutine/Other/async-func-pointer-2/async-func-pointer-2.cbs index eb30c1a710999baa04a64d63e3a5395c444e6e5f..92ba955daaaa451cdda80e448f3e45fe79a436d1 100644 --- a/clang/test/BSC/Positive/Coroutine/Other/async-func-pointer-2/async-func-pointer-2.cbs +++ b/clang/test/BSC/Positive/Coroutine/Other/async-func-pointer-2/async-func-pointer-2.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -19,4 +20,40 @@ async void g() { int main() { return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futureg { +// CHECK-NEXT: struct __Trait_Future_int Ft_1; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_struct_Void struct__Futureg_poll(struct _Futureg *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: case 1: +// CHECK-NEXT: goto __L1; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->Ft_1 = pollFunc(); +// CHECK-NEXT: __L1: +// CHECK-NEXT: ; +// CHECK-NEXT: int Res_1; +// CHECK-NEXT: struct PollResult_int PR_1 = this->Ft_1.vtable->poll(this->Ft_1.data); +// CHECK-NEXT: if (struct_PollResult_int_is_completed(&PR_1, &Res_1)) { +// CHECK-NEXT: if (this->Ft_1.data != 0) { +// CHECK-NEXT: this->Ft_1.vtable->free(this->Ft_1.data); +// CHECK-NEXT: this->Ft_1.data = (void *)0; +// CHECK-NEXT: } +// CHECK-NEXT: } else { +// CHECK-NEXT: this->__future_state = 1; +// CHECK-NEXT: return struct_PollResult_struct_Void_pending(); +// CHECK-NEXT: } +// CHECK-NEXT: Res_1; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: struct Void __RES_RETURN = (struct Void){}; +// CHECK-NEXT: return struct_PollResult_struct_Void_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Other/async-func-pointer/async-func-pointer.cbs b/clang/test/BSC/Positive/Coroutine/Other/async-func-pointer/async-func-pointer.cbs index 20eb2d0eb3ecd40d3a246b729cae6c42207745bb..303603bf45a36e536015586d14d36349fa79ba36 100644 --- a/clang/test/BSC/Positive/Coroutine/Other/async-func-pointer/async-func-pointer.cbs +++ b/clang/test/BSC/Positive/Coroutine/Other/async-func-pointer/async-func-pointer.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -23,4 +24,41 @@ async void f() { // triger point 2, do not change int main() { return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: EQueueFunc f; +// CHECK-NEXT: struct __Trait_Future_int Ft_1; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_struct_Void struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: case 1: +// CHECK-NEXT: goto __L1; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->Ft_1 = this->f.func(); +// CHECK-NEXT: __L1: +// CHECK-NEXT: ; +// CHECK-NEXT: int Res_1; +// CHECK-NEXT: struct PollResult_int PR_1 = this->Ft_1.vtable->poll(this->Ft_1.data); +// CHECK-NEXT: if (struct_PollResult_int_is_completed(&PR_1, &Res_1)) { +// CHECK-NEXT: if (this->Ft_1.data != 0) { +// CHECK-NEXT: this->Ft_1.vtable->free(this->Ft_1.data); +// CHECK-NEXT: this->Ft_1.data = (void *)0; +// CHECK-NEXT: } +// CHECK-NEXT: } else { +// CHECK-NEXT: this->__future_state = 1; +// CHECK-NEXT: return struct_PollResult_struct_Void_pending(); +// CHECK-NEXT: } +// CHECK-NEXT: Res_1; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: struct Void __RES_RETURN = (struct Void){}; +// CHECK-NEXT: return struct_PollResult_struct_Void_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Other/async-func-volatile/async-func-volatile.cbs b/clang/test/BSC/Positive/Coroutine/Other/async-func-volatile/async-func-volatile.cbs index 239893b999d6d7ffd563e2d9326905bc1235a199..efc1727ea181f2204a6ac32b7b359ddd0cc5536d 100644 --- a/clang/test/BSC/Positive/Coroutine/Other/async-func-volatile/async-func-volatile.cbs +++ b/clang/test/BSC/Positive/Coroutine/Other/async-func-volatile/async-func-volatile.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -29,3 +30,30 @@ int main() this->poll(); return 0; } + +// CHECK: struct _Futuref { +// CHECK-NEXT: int a; +// CHECK-NEXT: int b; +// CHECK-NEXT: int n[10]; +// CHECK-NEXT: int i; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_volatile_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->a = 1; +// CHECK-NEXT: this->b = this->a - 1; +// CHECK-NEXT: for (this->i = 0; this->i < 10; this->i++) { +// CHECK-NEXT: this->n[this->i] = this->i + 100; +// CHECK-NEXT: } +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = 0; +// CHECK-NEXT: return struct_PollResult_volatile_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } diff --git a/clang/test/BSC/Positive/Coroutine/Other/async-func-with-owned/async-func-with-owned.cbs b/clang/test/BSC/Positive/Coroutine/Other/async-func-with-owned/async-func-with-owned.cbs index ac1f53b7cf205949a484a39fe3c0b3f5e99445f7..4d5d77e92ecf97b0614a5e186ca5a64b4a33c6a6 100644 --- a/clang/test/BSC/Positive/Coroutine/Other/async-func-with-owned/async-func-with-owned.cbs +++ b/clang/test/BSC/Positive/Coroutine/Other/async-func-with-owned/async-func-with-owned.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -40,4 +41,29 @@ async int foo() { int main() { return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futurefoo { +// CHECK-NEXT: struct Owned_int q; +// CHECK-NEXT: int a; +// CHECK-NEXT: int *p; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futurefoo_poll(struct _Futurefoo *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: struct Owned_int q = make_owned_int(2); +// CHECK-NEXT: this->q = q; +// CHECK-NEXT: this->a = 0; +// CHECK-NEXT: this->p = (int *)this->q.p; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->a; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Other/async-function-without-await-expression/async-function-without-await-expression.cbs b/clang/test/BSC/Positive/Coroutine/Other/async-function-without-await-expression/async-function-without-await-expression.cbs index 82817113169c5772978fd229d57004a415cda2b2..974f5e8377ed9c9e5bce6da7112ed243a9255282 100644 --- a/clang/test/BSC/Positive/Coroutine/Other/async-function-without-await-expression/async-function-without-await-expression.cbs +++ b/clang/test/BSC/Positive/Coroutine/Other/async-function-without-await-expression/async-function-without-await-expression.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -22,4 +23,18 @@ int main() { a->poll(); a->free(); return 0; -} \ No newline at end of file +} + +// CHECK: struct PollResult_int struct__Futureg_poll(struct _Futureg *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = 0; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Other/leaf-node-async-function/leaf-node-async-function.cbs b/clang/test/BSC/Positive/Coroutine/Other/leaf-node-async-function/leaf-node-async-function.cbs index e8454619052a9055bf4e93b44f9ec03bc17a6494..fddec2b2f46d80b68f4e3bc2a853304f0f453554 100644 --- a/clang/test/BSC/Positive/Coroutine/Other/leaf-node-async-function/leaf-node-async-function.cbs +++ b/clang/test/BSC/Positive/Coroutine/Other/leaf-node-async-function/leaf-node-async-function.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -30,3 +31,28 @@ int main() { this->free(); return 0; } + +// CHECK: struct _Futureg { +// CHECK-NEXT: int tmp; +// CHECK-NEXT: int a; +// CHECK-NEXT: int start; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futureg_poll(struct _Futureg *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->start = 3; +// CHECK-NEXT: this->start = 3; +// CHECK-NEXT: this->a = 42; +// CHECK-NEXT: this->tmp = this->a + this->start; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = 42; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Other/malloc-free-call/malloc-free-call.cbs b/clang/test/BSC/Positive/Coroutine/Other/malloc-free-call/malloc-free-call.cbs index 9c718035f194452ea8582a2644c0503eebbe877e..264396b3c1d4cf02481d529dd713f740174eddff 100644 --- a/clang/test/BSC/Positive/Coroutine/Other/malloc-free-call/malloc-free-call.cbs +++ b/clang/test/BSC/Positive/Coroutine/Other/malloc-free-call/malloc-free-call.cbs @@ -49,17 +49,13 @@ int main() { // CHECK-DAG: struct _Futuref { // CHECK-DAG: int n; // CHECK-DAG: int tmp1; +// CHECK-DAG: int a; // CHECK-DAG: int tmp2; -// CHECK-DAG: struct _Futureread *Ft_1; -// CHECK-DAG: struct _Futureread *Ft_2; +// CHECK-DAG: int a_1; // CHECK-DAG: int __future_state; // CHECK-DAG: }; -// CHECK: static struct PollResult_int struct_PollResult_int_pending(void); -// CHECK-EMPTY: -// CHECK-NEXT: static _Bool struct_PollResult_int_is_completed(struct PollResult_int *this, int *out); -// CHECK-EMPTY: -// CHECK-NEXT: static struct PollResult_int struct_PollResult_int_completed(int result); +// CHECK: static struct PollResult_int struct_PollResult_int_completed(int result); // CHECK-EMPTY: // CHECK-NEXT: struct _Futureread *__read(int a); // CHECK-EMPTY: @@ -109,14 +105,6 @@ int main() { // CHECK-NEXT: } // CHECK-EMPTY: // CHECK-NEXT: void struct__Futuref_free(struct _Futuref *this) { -// CHECK-NEXT: if (this->Ft_2 != 0) { -// CHECK-NEXT: struct__Futureread_free((void *)this->Ft_2); -// CHECK-NEXT: this->Ft_2 = (struct _Futureread *)(void *)0; -// CHECK-NEXT: } -// CHECK-NEXT: if (this->Ft_1 != 0) { -// CHECK-NEXT: struct__Futureread_free((void *)this->Ft_1); -// CHECK-NEXT: this->Ft_1 = (struct _Futureread *)(void *)0; -// CHECK-NEXT: } // CHECK-NEXT: if (this != 0) { // CHECK-NEXT: free((void *)this); // CHECK-NEXT: this = (struct _Futuref *)(void *)0; @@ -127,43 +115,13 @@ int main() { // CHECK-NEXT: switch (this->__future_state) { // CHECK-NEXT: case 0: // CHECK-NEXT: goto __L0; -// CHECK-NEXT: case 1: -// CHECK-NEXT: goto __L1; -// CHECK-NEXT: case 2: -// CHECK-NEXT: goto __L2; // CHECK-NEXT: } // CHECK-NEXT: __L0: // CHECK-NEXT: ; -// CHECK-NEXT: this->Ft_1 = __read(this->n - 1); -// CHECK-NEXT: __L1: -// CHECK-NEXT: ; -// CHECK-NEXT: int Res_1; -// CHECK-NEXT: struct PollResult_int PR_1 = struct__Futureread_poll(this->Ft_1); -// CHECK-NEXT: if (struct_PollResult_int_is_completed(&PR_1, &Res_1)) { -// CHECK-NEXT: { -// CHECK-NEXT: struct__Futureread_free(this->Ft_1); -// CHECK-NEXT: this->Ft_1 = (struct _Futureread *)0; -// CHECK-NEXT: } -// CHECK-NEXT: } else { -// CHECK-NEXT: this->__future_state = 1; -// CHECK-NEXT: return struct_PollResult_int_pending(); -// CHECK-NEXT: } -// CHECK-NEXT: this->tmp1 = Res_1; -// CHECK-NEXT: this->Ft_2 = __read(this->n); -// CHECK-NEXT: __L2: -// CHECK-NEXT: ; -// CHECK-NEXT: int Res_2; -// CHECK-NEXT: struct PollResult_int PR_2 = struct__Futureread_poll(this->Ft_2); -// CHECK-NEXT: if (struct_PollResult_int_is_completed(&PR_2, &Res_2)) { -// CHECK-NEXT: { -// CHECK-NEXT: struct__Futureread_free(this->Ft_2); -// CHECK-NEXT: this->Ft_2 = (struct _Futureread *)0; -// CHECK-NEXT: } -// CHECK-NEXT: } else { -// CHECK-NEXT: this->__future_state = 2; -// CHECK-NEXT: return struct_PollResult_int_pending(); -// CHECK-NEXT: } -// CHECK-NEXT: this->tmp2 = Res_2; +// CHECK-NEXT: this->a = this->n - 1; +// CHECK-NEXT: this->tmp1 = 0; +// CHECK-NEXT: this->a_1 = this->n; +// CHECK-NEXT: this->tmp2 = 0; // CHECK-NEXT: { // CHECK-NEXT: this->__future_state = -1; // CHECK-NEXT: int __RES_RETURN = this->tmp2 + this->tmp1 + 42; @@ -180,17 +138,6 @@ int main() { // CHECK-NEXT: return 0; // CHECK-NEXT: } // CHECK-EMPTY: -// CHECK-NEXT: static struct PollResult_int struct_PollResult_int_pending(void) { -// CHECK-NEXT: struct PollResult_int this; -// CHECK-NEXT: this.isPending = 1; -// CHECK-NEXT: return this; -// CHECK-NEXT: } -// CHECK-EMPTY: -// CHECK-NEXT: static _Bool struct_PollResult_int_is_completed(struct PollResult_int *this, int *out) { -// CHECK-NEXT: *out = this->res; -// CHECK-NEXT: return !this->isPending; -// CHECK-NEXT: } -// CHECK-EMPTY: // CHECK-NEXT: static struct PollResult_int struct_PollResult_int_completed(int result) { // CHECK-NEXT: struct PollResult_int this; // CHECK-NEXT: this.isPending = 0; diff --git a/clang/test/BSC/Positive/Coroutine/Other/static-async-function-opt/static-async-function-opt.cbs b/clang/test/BSC/Positive/Coroutine/Other/static-async-function-opt/static-async-function-opt.cbs index 60f744c93bc4c739aca217ec0df9d9b8cb23266d..8b4844baf18b617b7f0af088527584a522018eda 100644 --- a/clang/test/BSC/Positive/Coroutine/Other/static-async-function-opt/static-async-function-opt.cbs +++ b/clang/test/BSC/Positive/Coroutine/Other/static-async-function-opt/static-async-function-opt.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -27,6 +28,31 @@ async int g() { int main() { trait Future* this = g(); this->poll(); - this->free(); + this->free(); return 0; } + +// CHECK: struct _Futureg { +// CHECK-NEXT: int tmp; +// CHECK-NEXT: int a; +// CHECK-NEXT: int start; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futureg_poll(struct _Futureg *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->start = 3; +// CHECK-NEXT: this->start = 3; +// CHECK-NEXT: this->a = 42; +// CHECK-NEXT: this->tmp = this->a + this->start; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = 42; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } diff --git a/clang/test/BSC/Positive/Coroutine/Other/trait-inside-async/trait-inside-async.cbs b/clang/test/BSC/Positive/Coroutine/Other/trait-inside-async/trait-inside-async.cbs index 413d406b526e1a134fd16004d2cfff88281fc1bf..bcbca2ce4f81a20a36dfd2148ebea15eb9b7ce42 100644 --- a/clang/test/BSC/Positive/Coroutine/Other/trait-inside-async/trait-inside-async.cbs +++ b/clang/test/BSC/Positive/Coroutine/Other/trait-inside-async/trait-inside-async.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -29,4 +30,25 @@ async void f() { int main() { return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct __Trait_B_Vtable __struct_A_trait_B = {}; + +// CHECK: struct PollResult_struct_Void struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: bar((struct __Trait_B){.data = foo(), .vtable = &__struct_A_trait_B}); +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: struct Void __RES_RETURN = (struct Void){}; +// CHECK-NEXT: return struct_PollResult_struct_Void_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Other/unused-await-expression/unused-await-expression.cbs b/clang/test/BSC/Positive/Coroutine/Other/unused-await-expression/unused-await-expression.cbs index 1243340f2237dfc99ca941b5ca6eb4a9f8e49f23..0a0ab6494bc58a569d9d4b326643fc4578ad01bc 100644 --- a/clang/test/BSC/Positive/Coroutine/Other/unused-await-expression/unused-await-expression.cbs +++ b/clang/test/BSC/Positive/Coroutine/Other/unused-await-expression/unused-await-expression.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -22,4 +23,27 @@ int main() { trait Future* this = f(1); this->poll(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: int a; +// CHECK-NEXT: int a_1; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->a_1 = 1; +// CHECK-NEXT: this->a = 0; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->start; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Other/volatile-async-function1/volatile-async-function1.cbs b/clang/test/BSC/Positive/Coroutine/Other/volatile-async-function1/volatile-async-function1.cbs index d413fab776f6e6a824075675b8d2bef93fc5967f..587772cc2a60e5b13c33d9ca1f18748ad69084bb 100644 --- a/clang/test/BSC/Positive/Coroutine/Other/volatile-async-function1/volatile-async-function1.cbs +++ b/clang/test/BSC/Positive/Coroutine/Other/volatile-async-function1/volatile-async-function1.cbs @@ -1,6 +1,7 @@ // RUN: %clang %s -o %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // expected-no-diagnostics @@ -27,4 +28,121 @@ int main() trait Future* this = g(1); this->poll(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futureg { +// CHECK-NEXT: char x; +// CHECK-NEXT: char a; +// CHECK-NEXT: struct _Futureg *Ft_1; +// CHECK-NEXT: struct _Futureg *Ft_2; +// CHECK-NEXT: struct _Futureg *Ft_3; +// CHECK-NEXT: struct _Futureg *Ft_4; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_volatile_char struct__Futureg_poll(struct _Futureg *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: case 1: +// CHECK-NEXT: goto __L1; +// CHECK-NEXT: case 2: +// CHECK-NEXT: goto __L2; +// CHECK-NEXT: case 3: +// CHECK-NEXT: goto __L3; +// CHECK-NEXT: case 4: +// CHECK-NEXT: goto __L4; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->Ft_1 = __g(1); +// CHECK-NEXT: __L1: +// CHECK-NEXT: ; +// CHECK-NEXT: volatile char Res_1; +// CHECK-NEXT: struct PollResult_volatile_char PR_1 = struct__Futureg_poll(this->Ft_1); +// CHECK-NEXT: if (struct_PollResult_volatile_char_is_completed(&PR_1, &Res_1)) { +// CHECK-NEXT: { +// CHECK-NEXT: struct__Futureg_free(this->Ft_1); +// CHECK-NEXT: this->Ft_1 = (struct _Futureg *)0; +// CHECK-NEXT: } +// CHECK-NEXT: } else { +// CHECK-NEXT: this->__future_state = 1; +// CHECK-NEXT: return struct_PollResult_volatile_char_pending(); +// CHECK-NEXT: } +// CHECK-NEXT: this->a = Res_1; +// CHECK-NEXT: switch (1) { +// CHECK-NEXT: case 1: +// CHECK-NEXT: { +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: this->Ft_2 = __g(2); +// CHECK-NEXT: __L2: +// CHECK-NEXT: ; +// CHECK-NEXT: volatile char Res_2; +// CHECK-NEXT: struct PollResult_volatile_char PR_2 = struct__Futureg_poll(this->Ft_2); +// CHECK-NEXT: if (struct_PollResult_volatile_char_is_completed(&PR_2, &Res_2)) { +// CHECK-NEXT: { +// CHECK-NEXT: struct__Futureg_free(this->Ft_2); +// CHECK-NEXT: this->Ft_2 = (struct _Futureg *)0; +// CHECK-NEXT: } +// CHECK-NEXT: } else { +// CHECK-NEXT: this->__future_state = 2; +// CHECK-NEXT: return struct_PollResult_volatile_char_pending(); +// CHECK-NEXT: } +// CHECK-NEXT: char __RES_RETURN = Res_2; +// CHECK-NEXT: return struct_PollResult_volatile_char_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } +// CHECK-NEXT: break; +// CHECK-NEXT: case 2: +// CHECK-NEXT: { +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: this->Ft_3 = __g(3); +// CHECK-NEXT: __L3: +// CHECK-NEXT: ; +// CHECK-NEXT: volatile char Res_3; +// CHECK-NEXT: struct PollResult_volatile_char PR_3 = struct__Futureg_poll(this->Ft_3); +// CHECK-NEXT: if (struct_PollResult_volatile_char_is_completed(&PR_3, &Res_3)) { +// CHECK-NEXT: { +// CHECK-NEXT: struct__Futureg_free(this->Ft_3); +// CHECK-NEXT: this->Ft_3 = (struct _Futureg *)0; +// CHECK-NEXT: } +// CHECK-NEXT: } else { +// CHECK-NEXT: this->__future_state = 3; +// CHECK-NEXT: return struct_PollResult_volatile_char_pending(); +// CHECK-NEXT: } +// CHECK-NEXT: char __RES_RETURN_1 = Res_3; +// CHECK-NEXT: return struct_PollResult_volatile_char_completed(__RES_RETURN_1); +// CHECK-NEXT: } +// CHECK-NEXT: } +// CHECK-NEXT: break; +// CHECK-NEXT: default: +// CHECK-NEXT: { +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: this->Ft_4 = __g(4); +// CHECK-NEXT: __L4: +// CHECK-NEXT: ; +// CHECK-NEXT: volatile char Res_4; +// CHECK-NEXT: struct PollResult_volatile_char PR_4 = struct__Futureg_poll(this->Ft_4); +// CHECK-NEXT: if (struct_PollResult_volatile_char_is_completed(&PR_4, &Res_4)) { +// CHECK-NEXT: { +// CHECK-NEXT: struct__Futureg_free(this->Ft_4); +// CHECK-NEXT: this->Ft_4 = (struct _Futureg *)0; +// CHECK-NEXT: } +// CHECK-NEXT: } else { +// CHECK-NEXT: this->__future_state = 4; +// CHECK-NEXT: return struct_PollResult_volatile_char_pending(); +// CHECK-NEXT: } +// CHECK-NEXT: char __RES_RETURN_2 = Res_4; +// CHECK-NEXT: return struct_PollResult_volatile_char_completed(__RES_RETURN_2); +// CHECK-NEXT: } +// CHECK-NEXT: } +// CHECK-NEXT: } +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: char __RES_RETURN_3 = 0; +// CHECK-NEXT: return struct_PollResult_volatile_char_completed(__RES_RETURN_3); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Other/volatile-async-function2/volatile-async-function2.cbs b/clang/test/BSC/Positive/Coroutine/Other/volatile-async-function2/volatile-async-function2.cbs index 56431a72222ede56a729b3408a903276512efa2c..a47defc2716e387fcb6e50887eb697028ba70dc1 100644 --- a/clang/test/BSC/Positive/Coroutine/Other/volatile-async-function2/volatile-async-function2.cbs +++ b/clang/test/BSC/Positive/Coroutine/Other/volatile-async-function2/volatile-async-function2.cbs @@ -1,6 +1,7 @@ // RUN: %clang %s -o %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // expected-no-diagnostics @@ -23,3 +24,89 @@ int main() this->poll(); return 0; } + +// CHECK: struct _Futureg { +// CHECK-NEXT: int x; +// CHECK-NEXT: int a; +// CHECK-NEXT: struct _Futureg *Ft_1; +// CHECK-NEXT: struct _Futureg *Ft_2; +// CHECK-NEXT: struct _Futureg *Ft_3; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_volatile_int struct__Futureg_poll(struct _Futureg *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: case 1: +// CHECK-NEXT: goto __L1; +// CHECK-NEXT: case 2: +// CHECK-NEXT: goto __L2; +// CHECK-NEXT: case 3: +// CHECK-NEXT: goto __L3; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->Ft_1 = __g(1); +// CHECK-NEXT: __L1: +// CHECK-NEXT: ; +// CHECK-NEXT: volatile int Res_1; +// CHECK-NEXT: struct PollResult_volatile_int PR_1 = struct__Futureg_poll(this->Ft_1); +// CHECK-NEXT: if (struct_PollResult_volatile_int_is_completed(&PR_1, &Res_1)) { +// CHECK-NEXT: { +// CHECK-NEXT: struct__Futureg_free(this->Ft_1); +// CHECK-NEXT: this->Ft_1 = (struct _Futureg *)0; +// CHECK-NEXT: } +// CHECK-NEXT: } else { +// CHECK-NEXT: this->__future_state = 1; +// CHECK-NEXT: return struct_PollResult_volatile_int_pending(); +// CHECK-NEXT: } +// CHECK-NEXT: this->a = Res_1; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = 0; +// CHECK-NEXT: return struct_PollResult_volatile_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: if (1) { +// CHECK-NEXT: if (3) { +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: this->Ft_2 = __g(3); +// CHECK-NEXT: __L2: +// CHECK-NEXT: ; +// CHECK-NEXT: volatile int Res_2; +// CHECK-NEXT: struct PollResult_volatile_int PR_2 = struct__Futureg_poll(this->Ft_2); +// CHECK-NEXT: if (struct_PollResult_volatile_int_is_completed(&PR_2, &Res_2)) { +// CHECK-NEXT: { +// CHECK-NEXT: struct__Futureg_free(this->Ft_2); +// CHECK-NEXT: this->Ft_2 = (struct _Futureg *)0; +// CHECK-NEXT: } +// CHECK-NEXT: } else { +// CHECK-NEXT: this->__future_state = 2; +// CHECK-NEXT: return struct_PollResult_volatile_int_pending(); +// CHECK-NEXT: } +// CHECK-NEXT: int __RES_RETURN_1 = Res_2; +// CHECK-NEXT: return struct_PollResult_volatile_int_completed(__RES_RETURN_1); +// CHECK-NEXT: } +// CHECK-NEXT: } +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: this->Ft_3 = __g(2); +// CHECK-NEXT: __L3: +// CHECK-NEXT: ; +// CHECK-NEXT: volatile int Res_3; +// CHECK-NEXT: struct PollResult_volatile_int PR_3 = struct__Futureg_poll(this->Ft_3); +// CHECK-NEXT: if (struct_PollResult_volatile_int_is_completed(&PR_3, &Res_3)) { +// CHECK-NEXT: { +// CHECK-NEXT: struct__Futureg_free(this->Ft_3); +// CHECK-NEXT: this->Ft_3 = (struct _Futureg *)0; +// CHECK-NEXT: } +// CHECK-NEXT: } else { +// CHECK-NEXT: this->__future_state = 3; +// CHECK-NEXT: return struct_PollResult_volatile_int_pending(); +// CHECK-NEXT: } +// CHECK-NEXT: int __RES_RETURN_2 = Res_3; +// CHECK-NEXT: return struct_PollResult_volatile_int_completed(__RES_RETURN_2); +// CHECK-NEXT: } +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/Common/auto-storage-class/auto-storage-class.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/Common/auto-storage-class/auto-storage-class.cbs index aaa84fef51f7c235344e464592d60c3d4043c094..f850c91a3f92f04fd242094444a57eb29951004b 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/Common/auto-storage-class/auto-storage-class.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/Common/auto-storage-class/auto-storage-class.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -29,4 +30,37 @@ int main() { trait Future* this = f(1); this->poll(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: int j; +// CHECK-NEXT: int j_1; +// CHECK-NEXT: int j_2; +// CHECK-NEXT: int result; +// CHECK-NEXT: int a; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->j = 1; +// CHECK-NEXT: { +// CHECK-NEXT: this->j_1 = 2; +// CHECK-NEXT: { +// CHECK-NEXT: this->j_2 = 3; +// CHECK-NEXT: } +// CHECK-NEXT: } +// CHECK-NEXT: this->a = 1; +// CHECK-NEXT: this->result = 0; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->result; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/Common/await-expr-for/await-expr-for.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/Common/await-expr-for/await-expr-for.cbs index 06788df0909381e3282c44ab8c5eac40d04b5c7e..3a0a1704ffa543de0a3f567a167a79be2474e1e4 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/Common/await-expr-for/await-expr-for.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/Common/await-expr-for/await-expr-for.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -25,4 +26,32 @@ int main() { trait Future* this = f(1); this->poll(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: int result; +// CHECK-NEXT: int i; +// CHECK-NEXT: int a; +// CHECK-NEXT: int a_1; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->result = this->start; +// CHECK-NEXT: for (this->i = 0; this->i < this->start; this->i++) { +// CHECK-NEXT: this->a_1 = 1; +// CHECK-NEXT: this->a = 0; +// CHECK-NEXT: } +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->result; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/Common/func-invoke/func-invoke.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/Common/func-invoke/func-invoke.cbs index fd8ba3b8ee151dc158ccf81993ecba5a71ed6707..2a624e18d42548e432c78ebcfe6a341a48d8869d 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/Common/func-invoke/func-invoke.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/Common/func-invoke/func-invoke.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -27,4 +28,28 @@ int main() { trait Future* this = f(1); this->poll(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: int result; +// CHECK-NEXT: int a; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->start = test(); +// CHECK-NEXT: this->a = 1; +// CHECK-NEXT: this->result = 0; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->result + this->start; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/Common/register-storage-class/register-storage-class.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/Common/register-storage-class/register-storage-class.cbs index 5003292c3673a639159908a3830c68f47c0fc934..a8a604b2b40a2a62535e593967b387c1e1563612 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/Common/register-storage-class/register-storage-class.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/Common/register-storage-class/register-storage-class.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -25,4 +26,33 @@ int main() { trait Future* this = f(1); this->poll(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: char a; +// CHECK-NEXT: double b; +// CHECK-NEXT: int c; +// CHECK-NEXT: int result; +// CHECK-NEXT: int a_1; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->a = 'S'; +// CHECK-NEXT: this->b = 10; +// CHECK-NEXT: this->c = 8; +// CHECK-NEXT: this->a_1 = 1; +// CHECK-NEXT: this->result = 0; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->result; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/Common/static-storage-class/static-storage-class.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/Common/static-storage-class/static-storage-class.cbs index afb9f58a1b3411f9c1ea711dcb83e49b377419f7..9b252b95062cdd73672c12324e62109d6251fbfe 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/Common/static-storage-class/static-storage-class.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/Common/static-storage-class/static-storage-class.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -28,4 +29,31 @@ int main() { trait Future* this = f(1); this->poll(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: int result; +// CHECK-NEXT: int a; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: while (count--) +// CHECK-NEXT: { +// CHECK-NEXT: this->start++; +// CHECK-NEXT: } +// CHECK-NEXT: this->a = 2; +// CHECK-NEXT: this->result = 0; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->result + 5 + this->start; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/Enum/enum1/enum1.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/Enum/enum1/enum1.cbs index 9936e388f35ec5db004cbf8afcbc489233374c54..f6b66c5341eed1d87b447c23e4aaece052711853 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/Enum/enum1/enum1.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/Enum/enum1/enum1.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -26,4 +27,28 @@ int main() { trait Future* this = f(1); this->poll(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: int result; +// CHECK-NEXT: int a; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->start = Mon; +// CHECK-NEXT: this->a = 1; +// CHECK-NEXT: this->result = 0; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->result; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/array-decl/array-decl.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/array-decl/array-decl.cbs index 2bcdd5b6bccb9ccbc7486bcf80601fd09ab0ac7a..8d3af62a657b6cd982f9035430c65758138acccc 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/array-decl/array-decl.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/array-decl/array-decl.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -33,4 +34,69 @@ int main() { trait Future* this = f(1); this->poll(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: int result; +// CHECK-NEXT: char str[10]; +// CHECK-NEXT: int ia[10]; +// CHECK-NEXT: int ia1[10]; +// CHECK-NEXT: int ia2[10]; +// CHECK-NEXT: struct Addr addr[10]; +// CHECK-NEXT: int a; +// CHECK-NEXT: int a_1; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->result = this->start; +// CHECK-NEXT: char str[10] = "hello"; +// CHECK-NEXT: char *__ASSIGNED_ARRAY_PTR_char = (char *)str; +// CHECK-NEXT: char *__ARRAY_PTR_char = (char *)this->str; +// CHECK-NEXT: for (int I = 0; I < 10; ++I) { +// CHECK-NEXT: *__ARRAY_PTR_char++ = *__ASSIGNED_ARRAY_PTR_char++; +// CHECK-NEXT: } +// CHECK-NEXT: __ARRAY_PTR_char = /*implicit*/(char *)0; +// CHECK-NEXT: int ia[10] = {0}; +// CHECK-NEXT: int *__ASSIGNED_ARRAY_PTR_int = (int *)ia; +// CHECK-NEXT: int *__ARRAY_PTR_int = (int *)this->ia; +// CHECK-NEXT: for (int I = 0; I < 10; ++I) { +// CHECK-NEXT: *__ARRAY_PTR_int++ = *__ASSIGNED_ARRAY_PTR_int++; +// CHECK-NEXT: } +// CHECK-NEXT: __ARRAY_PTR_int = /*implicit*/(int *)0; +// CHECK-NEXT: int ia1[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; +// CHECK-NEXT: __ASSIGNED_ARRAY_PTR_int = (int *)ia1; +// CHECK-NEXT: __ARRAY_PTR_int = (int *)this->ia1; +// CHECK-NEXT: for (int I = 0; I < 10; ++I) { +// CHECK-NEXT: *__ARRAY_PTR_int++ = *__ASSIGNED_ARRAY_PTR_int++; +// CHECK-NEXT: } +// CHECK-NEXT: __ARRAY_PTR_int = /*implicit*/(int *)0; +// CHECK-NEXT: int ia2[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; +// CHECK-NEXT: __ASSIGNED_ARRAY_PTR_int = (int *)ia2; +// CHECK-NEXT: __ARRAY_PTR_int = (int *)this->ia2; +// CHECK-NEXT: for (int I = 0; I < 10; ++I) { +// CHECK-NEXT: *__ARRAY_PTR_int++ = *__ASSIGNED_ARRAY_PTR_int++; +// CHECK-NEXT: } +// CHECK-NEXT: __ARRAY_PTR_int = /*implicit*/(int *)0; +// CHECK-NEXT: struct Addr addr[10] = {}; +// CHECK-NEXT: struct Addr *__ASSIGNED_ARRAY_PTR_struct_Addr = (struct Addr *)addr; +// CHECK-NEXT: struct Addr *__ARRAY_PTR_struct_Addr = (struct Addr *)this->addr; +// CHECK-NEXT: for (int I = 0; I < 10; ++I) { +// CHECK-NEXT: *__ARRAY_PTR_struct_Addr++ = *__ASSIGNED_ARRAY_PTR_struct_Addr++; +// CHECK-NEXT: } +// CHECK-NEXT: __ARRAY_PTR_struct_Addr = /*implicit*/(struct Addr *)0; +// CHECK-NEXT: this->a_1 = 1; +// CHECK-NEXT: this->a = 0; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->result; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/array-decl1/array-decl1.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/array-decl1/array-decl1.cbs index e4f2fc618df5fed5369ca5e8108d436244278750..b214f5d0ed6b06459ec87bc096f1b89ed93bb19c 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/array-decl1/array-decl1.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/array-decl1/array-decl1.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -24,4 +25,37 @@ int main() { trait Future* this = f(1); this->poll(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: int array[5]; +// CHECK-NEXT: int length; +// CHECK-NEXT: int result; +// CHECK-NEXT: int a; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: int array[5] = {1, 2, 3, 4, 5}; +// CHECK-NEXT: int *__ASSIGNED_ARRAY_PTR_int = (int *)array; +// CHECK-NEXT: int *__ARRAY_PTR_int = (int *)this->array; +// CHECK-NEXT: for (int I = 0; I < 5; ++I) { +// CHECK-NEXT: *__ARRAY_PTR_int++ = *__ASSIGNED_ARRAY_PTR_int++; +// CHECK-NEXT: } +// CHECK-NEXT: __ARRAY_PTR_int = /*implicit*/(int *)0; +// CHECK-NEXT: this->length = sizeof (this->array) / sizeof (this->array[0]); +// CHECK-NEXT: this->a = 1; +// CHECK-NEXT: this->result = 0; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->result; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/base-type-decl/base-type-decl.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/base-type-decl/base-type-decl.cbs index a43e7f70631561c1cb27d54a63e377864c73f5ca..58ae9875119caf3d4fcc76867c516e251a3c6a54 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/base-type-decl/base-type-decl.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/base-type-decl/base-type-decl.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -38,4 +39,53 @@ int main() { trait Future* this = f(1); this->poll(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: int result; +// CHECK-NEXT: char x; +// CHECK-NEXT: short s; +// CHECK-NEXT: int d; +// CHECK-NEXT: float ff; +// CHECK-NEXT: double dd; +// CHECK-NEXT: int i; +// CHECK-NEXT: unsigned char ux; +// CHECK-NEXT: signed char sx; +// CHECK-NEXT: unsigned int ud; +// CHECK-NEXT: unsigned short us; +// CHECK-NEXT: unsigned long ul; +// CHECK-NEXT: long double ld; +// CHECK-NEXT: int a; +// CHECK-NEXT: int a_1; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->result = this->start; +// CHECK-NEXT: this->x = 5; +// CHECK-NEXT: this->s = 6; +// CHECK-NEXT: this->d = 3; +// CHECK-NEXT: this->ff = 4.; +// CHECK-NEXT: this->dd = 5.; +// CHECK-NEXT: this->i = (int)this->dd; +// CHECK-NEXT: this->ux = 5; +// CHECK-NEXT: this->sx = 5; +// CHECK-NEXT: this->ud = 5; +// CHECK-NEXT: this->us = 5; +// CHECK-NEXT: this->ul = 5; +// CHECK-NEXT: this->ld = 3.3999999999999999; +// CHECK-NEXT: this->a_1 = 1; +// CHECK-NEXT: this->a = 0; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->result; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/const-decl/const-decl.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/const-decl/const-decl.cbs index 072aea9ae03adec844eee4b692d2963375d3009c..3845912d96f194963b1856422a959c13b80bf477 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/const-decl/const-decl.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/const-decl/const-decl.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -41,8 +42,6 @@ int main() { // CHECK-NEXT: switch (this->__future_state) { // CHECK-NEXT: case 0: // CHECK-NEXT: goto __L0; -// CHECK-NEXT: case 1: -// CHECK-NEXT: goto __L1; // CHECK-NEXT: } // CHECK-NEXT: __L0: // CHECK-NEXT: ; @@ -52,22 +51,11 @@ int main() { // CHECK-NEXT: const double myDouble = 3.1415899999999999; // CHECK-NEXT: const struct Addr addr = {1, "hello"}; // CHECK-NEXT: this->newStart = this->start; -// CHECK-NEXT: this->Ft_1 = __read(this->newStart); -// CHECK-NEXT: __L1: -// CHECK-NEXT: ; -// CHECK-NEXT: int Res_1; -// CHECK-NEXT: struct PollResult_int PR_1 = this->Ft_1.vtable->poll(this->Ft_1.data); -// CHECK-NEXT: if (struct_PollResult_int_is_completed(&PR_1, &Res_1)) { -// CHECK-NEXT: if (this->Ft_1.data != 0) { -// CHECK-NEXT: this->Ft_1.vtable->free(this->Ft_1.data); -// CHECK-NEXT: this->Ft_1.data = (void *)0; -// CHECK-NEXT: } -// CHECK-NEXT: } else { -// CHECK-NEXT: this->__future_state = 1; -// CHECK-NEXT: return struct_PollResult_int_pending(); +// CHECK-NEXT: this->a = this->newStart; +// CHECK-NEXT: this->result = 0; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->result + 5 + this->start; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); // CHECK-NEXT: } -// CHECK-NEXT: this->result = Res_1; -// CHECK-NEXT: this->__future_state = -1; -// CHECK-NEXT: int __RES_RETURN = this->result + 5 + this->start; -// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); // CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/constexpr-decl/constexpr-decl.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/constexpr-decl/constexpr-decl.cbs index bb9dc7645fc280c3a2c5bf8fab48c949ad6671f5..c5bcc8fffe1467ecd1f7ec32d90f0f7de1f7b030 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/constexpr-decl/constexpr-decl.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/constexpr-decl/constexpr-decl.cbs @@ -39,7 +39,7 @@ int main() { // CHECK: struct _Futuref { // CHECK-NEXT: int start; // CHECK-NEXT: int result; -// CHECK-NEXT: struct _Futureread *Ft_1; +// CHECK-NEXT: int a; // CHECK-NEXT: int __future_state; // CHECK-NEXT: }; @@ -47,30 +47,15 @@ int main() { // CHECK-NEXT: switch (this->__future_state) { // CHECK-NEXT: case 0: // CHECK-NEXT: goto __L0; -// CHECK-NEXT: case 1: -// CHECK-NEXT: goto __L1; // CHECK-NEXT: } // CHECK-NEXT: __L0: // CHECK-NEXT: ; // CHECK-NEXT: long myLong = 100000L; // CHECK-NEXT: unsigned int myUnsignedInt = 10U; // CHECK-NEXT: int myInt = 2; -// CHECK-NEXT: static struct Addr addr = {2, "hello"}; -// CHECK-NEXT: this->Ft_1 = __read(2); -// CHECK-NEXT: __L1: -// CHECK-NEXT: ; -// CHECK-NEXT: int Res_1; -// CHECK-NEXT: struct PollResult_int PR_1 = struct__Futureread_poll(this->Ft_1); -// CHECK-NEXT: if (struct_PollResult_int_is_completed(&PR_1, &Res_1)) { -// CHECK-NEXT: { -// CHECK-NEXT: struct__Futureread_free(this->Ft_1); -// CHECK-NEXT: this->Ft_1 = (struct _Futureread *)0; -// CHECK-NEXT: } -// CHECK-NEXT: } else { -// CHECK-NEXT: this->__future_state = 1; -// CHECK-NEXT: return struct_PollResult_int_pending(); -// CHECK-NEXT: } -// CHECK-NEXT: this->result = Res_1; +// CHECK-NEXT: static struct Addr addr = {myInt, "hello"}; +// CHECK-NEXT: this->a = myInt; +// CHECK-NEXT: this->result = 0; // CHECK-NEXT: { // CHECK-NEXT: this->__future_state = -1; // CHECK-NEXT: int __RES_RETURN = this->result + 5 + this->start; diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/extern-decl/extern-decl.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/extern-decl/extern-decl.cbs index 5d321060ff4229f18c64f0bd2f35b71f8818b804..645b312b74baaf0fbc9a2128dc941092cad3238e 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/extern-decl/extern-decl.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/extern-decl/extern-decl.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -30,3 +31,30 @@ int main() { this->poll(); return 0; } + +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: int x; +// CHECK-NEXT: int a; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: extern int p; +// CHECK-NEXT: extern int t; +// CHECK-NEXT: p = 3; +// CHECK-NEXT: t = 4; +// CHECK-NEXT: this->a = 2; +// CHECK-NEXT: this->x = 0; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = 42; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/global-decl/global-decl.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/global-decl/global-decl.cbs index 52a0f55c3a30b452d78d582d20111e3be6e38edf..ce8d14e80c997e53c0ae2c2d62658e63e37c941d 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/global-decl/global-decl.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/global-decl/global-decl.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -25,4 +26,28 @@ int main() { trait Future* this = f(1); this->poll(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: int result; +// CHECK-NEXT: int a; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: g = 6; +// CHECK-NEXT: this->a = 1; +// CHECK-NEXT: this->result = 0; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->result + g; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/literal-quantity-decl/literal-quantity-decl.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/literal-quantity-decl/literal-quantity-decl.cbs index efb34b0cb129fb2a6ab9b46917411ce541062604..a4dc3c1bcb58772cca75645d431cca8c5b68f510 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/literal-quantity-decl/literal-quantity-decl.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/literal-quantity-decl/literal-quantity-decl.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -26,4 +27,35 @@ int main() { trait Future* this = f(1); this->poll(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: long myLong; +// CHECK-NEXT: unsigned int myUnsignedInt; +// CHECK-NEXT: float myFloat; +// CHECK-NEXT: double myDouble; +// CHECK-NEXT: int result; +// CHECK-NEXT: int a; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->myLong = 100000L; +// CHECK-NEXT: this->myUnsignedInt = 10U; +// CHECK-NEXT: this->myFloat = 3.1400001F; +// CHECK-NEXT: this->myDouble = 3.1415899999999999; +// CHECK-NEXT: this->a = 2; +// CHECK-NEXT: this->result = 0; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->result + 5 + this->start; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/multi-decl/multi-decl.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/multi-decl/multi-decl.cbs index 208c9a331bdd26c9d8916c8977486d3127d9bf3b..a58fada8e3b144bcb3d9fa2ca53aa93435c3ee6f 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/multi-decl/multi-decl.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/multi-decl/multi-decl.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -27,4 +28,42 @@ int main() { trait Future* this = f(1); this->poll(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: int result; +// CHECK-NEXT: int b; +// CHECK-NEXT: int c; +// CHECK-NEXT: int d; +// CHECK-NEXT: int u; +// CHECK-NEXT: int v; +// CHECK-NEXT: int i; +// CHECK-NEXT: int a; +// CHECK-NEXT: int a_1; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: int b; +// CHECK-NEXT: this->result = this->start; +// CHECK-NEXT: int d; +// CHECK-NEXT: this->c = 1; +// CHECK-NEXT: int v; +// CHECK-NEXT: this->u = 3; +// CHECK-NEXT: for (this->i = 0; this->i < this->start; this->i++) { +// CHECK-NEXT: this->a_1 = this->i; +// CHECK-NEXT: this->a = 0; +// CHECK-NEXT: } +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->result; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/multi-dimension-array-decl/multi-dimension-array-decl.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/multi-dimension-array-decl/multi-dimension-array-decl.cbs index 0fbbc8b907337a799c945372a374d699f6657f5b..1fe646d215f18c5a68ba9676d1d09fad0f1a7a52 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/multi-dimension-array-decl/multi-dimension-array-decl.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/multi-dimension-array-decl/multi-dimension-array-decl.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -27,4 +28,35 @@ int main() { trait Future* this = f(); this->poll(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int a[5][3][2]; +// CHECK-NEXT: struct Addr addr[2][3][4][5]; +// CHECK-NEXT: int x; +// CHECK-NEXT: int a_1; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: int a[5][3][2] = {0}; +// CHECK-NEXT: int *__ASSIGNED_ARRAY_PTR_int = (int *)a; +// CHECK-NEXT: int *__ARRAY_PTR_int = (int *)this->a; +// CHECK-NEXT: for (int I = 0; I < 30; ++I) { +// CHECK-NEXT: *__ARRAY_PTR_int++ = *__ASSIGNED_ARRAY_PTR_int++; +// CHECK-NEXT: } +// CHECK-NEXT: __ARRAY_PTR_int = /*implicit*/(int *)0; +// CHECK-NEXT: this->a_1 = 2; +// CHECK-NEXT: this->x = 0; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = 42; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/pointer-decl/pointer-decl.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/pointer-decl/pointer-decl.cbs index c5b9c93763fa934b48894243ee0057edf4d5a8f2..12238d120974b0df85f042b188f082e9c347c774 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/pointer-decl/pointer-decl.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/pointer-decl/pointer-decl.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -33,4 +34,37 @@ int main() { trait Future* this = f(1); this->poll(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: double dd; +// CHECK-NEXT: int i; +// CHECK-NEXT: int *p; +// CHECK-NEXT: int **pp; +// CHECK-NEXT: char *cp; +// CHECK-NEXT: int a; +// CHECK-NEXT: int a_1; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->dd = 5.; +// CHECK-NEXT: this->i = (int)this->dd; +// CHECK-NEXT: this->p = &this->i; +// CHECK-NEXT: this->pp = &this->p; +// CHECK-NEXT: this->cp = (char *)&this->i; +// CHECK-NEXT: this->a_1 = 1; +// CHECK-NEXT: this->a = 0; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->a; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/static-decl/static-decl.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/static-decl/static-decl.cbs index 1b99924cd331e3368af53014588b9e648f8a0ef7..e6286f4c350210410ce20d74e55f381afd1edbf6 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/static-decl/static-decl.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/static-decl/static-decl.cbs @@ -43,7 +43,7 @@ int main() { // CHECK: struct _Futuref { // CHECK-NEXT: int start; // CHECK-NEXT: int result; -// CHECK-NEXT: struct _Futureread *Ft_1; +// CHECK-NEXT: int a; // CHECK-NEXT: int __future_state; // CHECK-NEXT: }; @@ -51,8 +51,6 @@ int main() { // CHECK-NEXT: switch (this->__future_state) { // CHECK-NEXT: case 0: // CHECK-NEXT: goto __L0; -// CHECK-NEXT: case 1: -// CHECK-NEXT: goto __L1; // CHECK-NEXT: } // CHECK-NEXT: __L0: // CHECK-NEXT: ; @@ -64,21 +62,8 @@ int main() { // CHECK-NEXT: static double myDouble = 3.1415899999999999; // CHECK-NEXT: static struct Addr addr = {myFirstInt1, "hello"}; // CHECK-NEXT: static int myInt = myFirstInt; -// CHECK-NEXT: this->Ft_1 = __read(myInt); -// CHECK-NEXT: __L1: -// CHECK-NEXT: ; -// CHECK-NEXT: int Res_1; -// CHECK-NEXT: struct PollResult_int PR_1 = struct__Futureread_poll(this->Ft_1); -// CHECK-NEXT: if (struct_PollResult_int_is_completed(&PR_1, &Res_1)) { -// CHECK-NEXT: { -// CHECK-NEXT: struct__Futureread_free(this->Ft_1); -// CHECK-NEXT: this->Ft_1 = (struct _Futureread *)0; -// CHECK-NEXT: } -// CHECK-NEXT: } else { -// CHECK-NEXT: this->__future_state = 1; -// CHECK-NEXT: return struct_PollResult_int_pending(); -// CHECK-NEXT: } -// CHECK-NEXT: this->result = Res_1; +// CHECK-NEXT: this->a = myInt; +// CHECK-NEXT: this->result = 0; // CHECK-NEXT: { // CHECK-NEXT: this->__future_state = -1; // CHECK-NEXT: int __RES_RETURN = this->result + 5 + this->start; diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/string-decl/string-decl.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/string-decl/string-decl.cbs index ba53625b1fea4b77774f1575cd5871f341779216..46827d194df0e5223e61b67cff30bb3927d909e2 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/string-decl/string-decl.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/string-decl/string-decl.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -25,4 +26,51 @@ int main() { trait Future* this = f(1); this->poll(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: char str1[14]; +// CHECK-NEXT: char str2[7]; +// CHECK-NEXT: char str3[7]; +// CHECK-NEXT: int result; +// CHECK-NEXT: int a; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: char str1[14] = "runoob"; +// CHECK-NEXT: char *__ASSIGNED_ARRAY_PTR_char = (char *)str1; +// CHECK-NEXT: char *__ARRAY_PTR_char = (char *)this->str1; +// CHECK-NEXT: for (int I = 0; I < 14; ++I) { +// CHECK-NEXT: *__ARRAY_PTR_char++ = *__ASSIGNED_ARRAY_PTR_char++; +// CHECK-NEXT: } +// CHECK-NEXT: __ARRAY_PTR_char = /*implicit*/(char *)0; +// CHECK-NEXT: char str2[7] = {'R', 'U', 'N', 'O', 'O', 'B', '\x00'}; +// CHECK-NEXT: __ASSIGNED_ARRAY_PTR_char = (char *)str2; +// CHECK-NEXT: __ARRAY_PTR_char = (char *)this->str2; +// CHECK-NEXT: for (int I = 0; I < 7; ++I) { +// CHECK-NEXT: *__ARRAY_PTR_char++ = *__ASSIGNED_ARRAY_PTR_char++; +// CHECK-NEXT: } +// CHECK-NEXT: __ARRAY_PTR_char = /*implicit*/(char *)0; +// CHECK-NEXT: char str3[7] = "RUNOOB"; +// CHECK-NEXT: __ASSIGNED_ARRAY_PTR_char = (char *)str3; +// CHECK-NEXT: __ARRAY_PTR_char = (char *)this->str3; +// CHECK-NEXT: for (int I = 0; I < 7; ++I) { +// CHECK-NEXT: *__ARRAY_PTR_char++ = *__ASSIGNED_ARRAY_PTR_char++; +// CHECK-NEXT: } +// CHECK-NEXT: __ARRAY_PTR_char = /*implicit*/(char *)0; +// CHECK-NEXT: this->a = 1; +// CHECK-NEXT: this->result = 0; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->result; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/struct-decl/struct-decl.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/struct-decl/struct-decl.cbs index 69baf3bbfb693eedb5753e6dc52385f4c283cf84..d202bff7e2b2781a2d0e95deb8cf0e567b9de08c 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/struct-decl/struct-decl.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/struct-decl/struct-decl.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -32,4 +33,39 @@ int main() { trait Future* this = f(1); this->poll(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: int result; +// CHECK-NEXT: struct Addr addr; +// CHECK-NEXT: char *tt; +// CHECK-NEXT: struct Addr addcp; +// CHECK-NEXT: struct Addr *ptr; +// CHECK-NEXT: int a; +// CHECK-NEXT: int a_1; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->result = this->start; +// CHECK-NEXT: struct Addr addr = {.a = 1, .addr = "hello"}; +// CHECK-NEXT: this->addr = addr; +// CHECK-NEXT: this->tt = "hello"; +// CHECK-NEXT: struct Addr addcp = {.a = 1, .addr = this->tt}; +// CHECK-NEXT: this->addcp = addcp; +// CHECK-NEXT: this->ptr = &this->addr; +// CHECK-NEXT: this->a_1 = 1; +// CHECK-NEXT: this->a = 0; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->result; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/typedef-decl/typedef-decl.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/typedef-decl/typedef-decl.cbs index 730f2efb1c15d8a66edb2f118326587e98625112..d182b33618cf7e7d80953ebac521e89bd7adf726 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/typedef-decl/typedef-decl.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/typedef-decl/typedef-decl.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -31,4 +32,27 @@ int main() { trait Future* this = f(1); this->poll(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: int a; +// CHECK-NEXT: int a_1; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->a_1 = 1; +// CHECK-NEXT: this->a = 0; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->a; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/uninit-array-decl/uninit-array-decl.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/uninit-array-decl/uninit-array-decl.cbs index 7ca284832b47c5faadc0dc42d9be802d3f289485..bfb3e71d23b2fdfed63a3b61fbeb05535e9f01be 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/uninit-array-decl/uninit-array-decl.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/uninit-array-decl/uninit-array-decl.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -35,4 +36,45 @@ int main() { trait Future* this = f(); this->poll(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int a; +// CHECK-NEXT: int b; +// CHECK-NEXT: int c[10]; +// CHECK-NEXT: float f[10]; +// CHECK-NEXT: struct Addr addr[10]; +// CHECK-NEXT: int cc[10]; +// CHECK-NEXT: int n[10]; +// CHECK-NEXT: int i; +// CHECK-NEXT: int x; +// CHECK-NEXT: int a_1; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->a = 1 , this->b = 2; +// CHECK-NEXT: int cc[10] = {0}; +// CHECK-NEXT: int *__ASSIGNED_ARRAY_PTR_int = (int *)cc; +// CHECK-NEXT: int *__ARRAY_PTR_int = (int *)this->cc; +// CHECK-NEXT: for (int I = 0; I < 10; ++I) { +// CHECK-NEXT: *__ARRAY_PTR_int++ = *__ASSIGNED_ARRAY_PTR_int++; +// CHECK-NEXT: } +// CHECK-NEXT: __ARRAY_PTR_int = /*implicit*/(int *)0; +// CHECK-NEXT: for (this->i = 0; this->i < 10; this->i++) { +// CHECK-NEXT: this->n[this->i] = this->i + 100; +// CHECK-NEXT: } +// CHECK-NEXT: this->a_1 = 2; +// CHECK-NEXT: this->x = 0; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = 42; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/uninit-array-decl1/uninit-array-decl1.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/uninit-array-decl1/uninit-array-decl1.cbs index bf465432ee00dd5bc527203e15bae3fb5c443184..3707b58a325d81a2ba05c0d30ad16751054a9806 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/uninit-array-decl1/uninit-array-decl1.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/uninit-array-decl1/uninit-array-decl1.cbs @@ -52,7 +52,7 @@ int main() { // CHECK-NEXT: int n[10]; // CHECK-NEXT: int i; // CHECK-NEXT: int x; -// CHECK-NEXT: struct _Futureread *Ft_1; +// CHECK-NEXT: int a_1; // CHECK-NEXT: int __future_state; // CHECK-NEXT: }; @@ -60,17 +60,9 @@ int main() { // CHECK-NEXT: switch (this->__future_state) { // CHECK-NEXT: case 0: // CHECK-NEXT: goto __L0; -// CHECK-NEXT: case 1: -// CHECK-NEXT: goto __L1; // CHECK-NEXT: } // CHECK-NEXT: __L0: // CHECK-NEXT: ; -// CHECK-NEXT: int a; -// CHECK-NEXT: float b; -// CHECK-NEXT: char c; -// CHECK-NEXT: char *p; -// CHECK-NEXT: float f[10]; -// CHECK-NEXT: struct Addr addr[10]; // CHECK-NEXT: this->a = 1; // CHECK-NEXT: int cc[10][3] = {0}; // CHECK-NEXT: int *__ASSIGNED_ARRAY_PTR_int = (int *)cc; @@ -79,25 +71,11 @@ int main() { // CHECK-NEXT: *__ARRAY_PTR_int++ = *__ASSIGNED_ARRAY_PTR_int++; // CHECK-NEXT: } // CHECK-NEXT: __ARRAY_PTR_int = /*implicit*/(int *)0; -// CHECK-NEXT: int n[10]; // CHECK-NEXT: for (this->i = 0; this->i < 10; this->i++) { // CHECK-NEXT: this->n[this->i] = this->i + 100; // CHECK-NEXT: } -// CHECK-NEXT: this->Ft_1 = __read(2); -// CHECK-NEXT: __L1: -// CHECK-NEXT: ; -// CHECK-NEXT: int Res_1; -// CHECK-NEXT: struct PollResult_int PR_1 = struct__Futureread_poll(this->Ft_1); -// CHECK-NEXT: if (struct_PollResult_int_is_completed(&PR_1, &Res_1)) { -// CHECK-NEXT: { -// CHECK-NEXT: struct__Futureread_free(this->Ft_1); -// CHECK-NEXT: this->Ft_1 = (struct _Futureread *)0; -// CHECK-NEXT: } -// CHECK-NEXT: } else { -// CHECK-NEXT: this->__future_state = 1; -// CHECK-NEXT: return struct_PollResult_int_pending(); -// CHECK-NEXT: } -// CHECK-NEXT: this->x = Res_1; +// CHECK-NEXT: this->a_1 = 2; +// CHECK-NEXT: this->x = 0; // CHECK-NEXT: { // CHECK-NEXT: this->__future_state = -1; // CHECK-NEXT: int __RES_RETURN = 42; diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/var-decl-multi-same-local-name/var-decl-multi-same-local-name.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/var-decl-multi-same-local-name/var-decl-multi-same-local-name.cbs index 935864d681fd269fd90660acfbcb8c041cbb7a8f..dfb2bca50f57d622e405e235242d370b4774fdaf 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/var-decl-multi-same-local-name/var-decl-multi-same-local-name.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/MultiDecl/var-decl-multi-same-local-name/var-decl-multi-same-local-name.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -38,91 +39,49 @@ int main() { return 0; } -// CHECK:struct _FuturegetData { -// CHECK-NEXT: int res; -// CHECK-NEXT: int start; -// CHECK-NEXT: int a; -// CHECK-NEXT: int start_1; -// CHECK-NEXT: int start_2; -// CHECK-NEXT: int a_1; -// CHECK-NEXT: int start_3; -// CHECK-NEXT: struct __Trait_Future_int Ft_1; -// CHECK-NEXT: struct __Trait_Future_int Ft_2; -// CHECK-NEXT: struct __Trait_Future_int Ft_3; -// CHECK-NEXT: struct __Trait_Future_int Ft_4; -// CHECK-NEXT: int __future_state; -// CHECK-NEXT: }; +// CHECK: struct _FuturegetData { +// CHECK-NEXT: int res; +// CHECK-NEXT: int start; +// CHECK-NEXT: int a; +// CHECK-NEXT: int a_1; +// CHECK-NEXT: int start_1; +// CHECK-NEXT: int a_2; +// CHECK-NEXT: int start_2; +// CHECK-NEXT: int a_3; +// CHECK-NEXT: int a_4; +// CHECK-NEXT: int start_3; +// CHECK-NEXT: int a_5; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; -// CHECK:struct PollResult_int struct__FuturegetData_poll(struct _FuturegetData *this) { -// CHECK-NEXT: switch (this->__future_state) { -// CHECK-NEXT: case 0: -// CHECK-NEXT: goto __L0; -// CHECK-NEXT: case 1: -// CHECK-NEXT: goto __L1; -// CHECK-NEXT: case 2: -// CHECK-NEXT: goto __L2; -// CHECK-NEXT: case 3: -// CHECK-NEXT: goto __L3; -// CHECK-NEXT: case 4: -// CHECK-NEXT: goto __L4; -// CHECK-NEXT: } -// CHECK-NEXT: __L0: -// CHECK-NEXT: ; -// CHECK-NEXT: this->res = 0; -// CHECK-NEXT: if (this->res == 0) { -// CHECK-NEXT: this->Ft_1 = read(2); -// CHECK-NEXT: __L1: -// CHECK-NEXT: ; -// CHECK-NEXT: int Res_1; -// CHECK-NEXT: struct PollResult_int PR_1 = this->Ft_1.vtable->poll(this->Ft_1.data); -// CHECK-NEXT: if (struct_PollResult_int_is_completed(&PR_1, &Res_1)) { -// CHECK-NEXT: } else { -// CHECK-NEXT: this->__future_state = 1; -// CHECK-NEXT: return struct_PollResult_int_pending(); -// CHECK-NEXT: } -// CHECK-NEXT: this->start = Res_1; -// CHECK-NEXT: this->a = 3; -// CHECK-NEXT: if (this->a == 3) { -// CHECK-NEXT: this->Ft_2 = read(3); -// CHECK-NEXT: __L2: -// CHECK-NEXT: ; -// CHECK-NEXT: int Res_2; -// CHECK-NEXT: struct PollResult_int PR_2 = this->Ft_2.vtable->poll(this->Ft_2.data); -// CHECK-NEXT: if (struct_PollResult_int_is_completed(&PR_2, &Res_2)) { -// CHECK-NEXT: } else { -// CHECK-NEXT: this->__future_state = 2; -// CHECK-NEXT: return struct_PollResult_int_pending(); -// CHECK-NEXT: } -// CHECK-NEXT: this->start_1 = Res_2; -// CHECK-NEXT: } -// CHECK-NEXT: } else { -// CHECK-NEXT: this->Ft_3 = read(2); -// CHECK-NEXT: __L3: -// CHECK-NEXT: ; -// CHECK-NEXT: int Res_3; -// CHECK-NEXT: struct PollResult_int PR_3 = this->Ft_3.vtable->poll(this->Ft_3.data); -// CHECK-NEXT: if (struct_PollResult_int_is_completed(&PR_3, &Res_3)) { -// CHECK-NEXT: } else { -// CHECK-NEXT: this->__future_state = 3; -// CHECK-NEXT: return struct_PollResult_int_pending(); -// CHECK-NEXT: } -// CHECK-NEXT: this->start_2 = Res_3; -// CHECK-NEXT: this->a_1 = 3; -// CHECK-NEXT: if (this->a_1 == 3) { -// CHECK-NEXT: this->Ft_4 = read(3); -// CHECK-NEXT: __L4: -// CHECK-NEXT: ; -// CHECK-NEXT: int Res_4; -// CHECK-NEXT: struct PollResult_int PR_4 = this->Ft_4.vtable->poll(this->Ft_4.data); -// CHECK-NEXT: if (struct_PollResult_int_is_completed(&PR_4, &Res_4)) { -// CHECK-NEXT: } else { -// CHECK-NEXT: this->__future_state = 4; -// CHECK-NEXT: return struct_PollResult_int_pending(); -// CHECK-NEXT: } -// CHECK-NEXT: this->start_3 = Res_4; -// CHECK-NEXT: } -// CHECK-NEXT: } -// CHECK-NEXT: this->__future_state = -1; -// CHECK-NEXT: int __RES_RETURN = this->res; -// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); -// CHECK-NEXT: } \ No newline at end of file +// CHECK: struct PollResult_int struct__FuturegetData_poll(struct _FuturegetData *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->res = 0; +// CHECK-NEXT: if (this->res == 0) { +// CHECK-NEXT: this->a = 2; +// CHECK-NEXT: this->start = 0; +// CHECK-NEXT: this->a_1 = 3; +// CHECK-NEXT: if (this->a_1 == 3) { +// CHECK-NEXT: this->a_2 = 3; +// CHECK-NEXT: this->start_1 = 0; +// CHECK-NEXT: } +// CHECK-NEXT: } else { +// CHECK-NEXT: this->a_3 = 2; +// CHECK-NEXT: this->start_2 = 0; +// CHECK-NEXT: this->a_4 = 3; +// CHECK-NEXT: if (this->a_4 == 3) { +// CHECK-NEXT: this->a_5 = 3; +// CHECK-NEXT: this->start_3 = 0; +// CHECK-NEXT: } +// CHECK-NEXT: } +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->res; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/Pointer/arithmetic-op-of-c-pointer/arithmetic-op-of-c-pointer.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/Pointer/arithmetic-op-of-c-pointer/arithmetic-op-of-c-pointer.cbs index 51756caa6067460bcdc7487fd390414c47693974..cbd983882596354f93931ac5dc3639da87e0091b 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/Pointer/arithmetic-op-of-c-pointer/arithmetic-op-of-c-pointer.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/Pointer/arithmetic-op-of-c-pointer/arithmetic-op-of-c-pointer.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -33,4 +34,44 @@ int main() { trait Future* this = f(1); this->poll(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: int *nptr; +// CHECK-NEXT: int var[3]; +// CHECK-NEXT: int i; +// CHECK-NEXT: int *ptr; +// CHECK-NEXT: int result; +// CHECK-NEXT: int a; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->nptr = ((void *)0); +// CHECK-NEXT: int var[3] = {10, 100, 200}; +// CHECK-NEXT: int *__ASSIGNED_ARRAY_PTR_int = (int *)var; +// CHECK-NEXT: int *__ARRAY_PTR_int = (int *)this->var; +// CHECK-NEXT: for (int I = 0; I < 3; ++I) { +// CHECK-NEXT: *__ARRAY_PTR_int++ = *__ASSIGNED_ARRAY_PTR_int++; +// CHECK-NEXT: } +// CHECK-NEXT: __ARRAY_PTR_int = /*implicit*/(int *)0; +// CHECK-NEXT: int i; +// CHECK-NEXT: this->ptr = &this->var[MAX - 1]; +// CHECK-NEXT: for (this->i = MAX; this->i > 0; this->i--) { +// CHECK-NEXT: this->ptr--; +// CHECK-NEXT: } +// CHECK-NEXT: this->a = 1; +// CHECK-NEXT: this->result = 0; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->result; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/Pointer/c-pointer-to-pointer/c-pointer-to-pointer.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/Pointer/c-pointer-to-pointer/c-pointer-to-pointer.cbs index 16b4e354e7e70ef11afc8044ddc89102b5c86ddf..4b86d5776eaa457d0959785509f74313ceb203fe 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/Pointer/c-pointer-to-pointer/c-pointer-to-pointer.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/Pointer/c-pointer-to-pointer/c-pointer-to-pointer.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -28,4 +29,33 @@ int main() { trait Future* this = f(1); this->poll(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: int V; +// CHECK-NEXT: int *ptr1; +// CHECK-NEXT: int **ptr2; +// CHECK-NEXT: int result; +// CHECK-NEXT: int a; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->V = 100; +// CHECK-NEXT: this->ptr1 = &this->V; +// CHECK-NEXT: this->ptr2 = &this->ptr1; +// CHECK-NEXT: this->a = 1; +// CHECK-NEXT: this->result = 0; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->result; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/Pointer/func-pointer/func-pointer.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/Pointer/func-pointer/func-pointer.cbs index 83528cf3697b7c72652137247766f192dac50c28..e6e5474dff654987069171b77e41b7f262f900f4 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/Pointer/func-pointer/func-pointer.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/Pointer/func-pointer/func-pointer.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -32,4 +33,36 @@ int main() { trait Future* this = f(1); this->poll(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: int (*p)(int, int); +// CHECK-NEXT: int a; +// CHECK-NEXT: int b; +// CHECK-NEXT: int c; +// CHECK-NEXT: int d; +// CHECK-NEXT: int result; +// CHECK-NEXT: int a_1; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->p = &max; +// CHECK-NEXT: int d; +// CHECK-NEXT: this->a = 1 , this->b = 2 , this->c = 3; +// CHECK-NEXT: this->d = this->p(this->p(this->a, this->b), this->c); +// CHECK-NEXT: this->a_1 = 1; +// CHECK-NEXT: this->result = 0; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->d; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/Struct/struct-init/struct-init.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/Struct/struct-init/struct-init.cbs index 002b728f876044b8498d37b6dab456202257451b..118845a994411eecc0020d7604dfa91de97aae1a 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/Struct/struct-init/struct-init.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/Struct/struct-init/struct-init.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -33,4 +34,32 @@ int main() { trait Future* this = f(1); this->poll(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: struct Books book1; +// CHECK-NEXT: struct Books book; +// CHECK-NEXT: struct Books *pbook; +// CHECK-NEXT: int result; +// CHECK-NEXT: int a; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: struct Books book = {"C language", "RUNOOB", "programming language", 123456}; +// CHECK-NEXT: this->book = book; +// CHECK-NEXT: this->a = 1; +// CHECK-NEXT: this->result = 0; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->result; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/Union/union-init/union-init.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/Union/union-init/union-init.cbs index a7d2a4642572df23efbae6b6462e833c6b714f3a..be8284baeab675dc69b391be397eca9a155e3f64 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/Union/union-init/union-init.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/DeclStmt/Union/union-init/union-init.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -32,4 +33,30 @@ int main() { trait Future* this = f(1); this->poll(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: union Data data; +// CHECK-NEXT: int result; +// CHECK-NEXT: int a; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->data.i = 10; +// CHECK-NEXT: this->data.f = 220.5; +// CHECK-NEXT: this->a = 1; +// CHECK-NEXT: this->result = 0; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->result; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/Other/CallChaining/call-chainingcbs b/clang/test/BSC/Positive/Coroutine/Treetransform/Other/CallChaining/call-chainingcbs new file mode 100644 index 0000000000000000000000000000000000000000..21231ed20c0a2816236e8d2fc8ca412ec24c430e --- /dev/null +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/Other/CallChaining/call-chainingcbs @@ -0,0 +1,99 @@ +// RUN: %clang %s -o %test.output +// RUN: %test.output +// RUN: %clang -rewrite-bsc %S/../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h +// RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s +// RUN: %clang %t-rw.c -o %t-rw.output +// RUN: %t-rw.output +// expected-no-diagnostics + +typedef struct Yielder { + _Bool yielded; +} Yielder; + +Yielder yield() { + Yielder y; + y.yielded = 0; + return y; +} + +struct PollResult<_Bool> Yielder::poll(Yielder *this) { + if (this->yielded) { + return PollResult<_Bool>::completed(this->yielded); + } else { + this->yielded = 1; + return PollResult<_Bool>::pending(); + } +} + +void Yielder::free(Yielder* this) {} + +impl trait Future<_Bool> for Yielder; + +async void f1() { + int a = 1; + await yield(); + int a1 = 2; +} + +async void f2() { + int a = 2; + await f1(); + int c = 3; +} + +async void f3() { + int a = 4; + await f2(); + int c = 5; +} + +int main() { + trait Future *t = f3(); + t->poll(); +} + +// CHECK: struct _Futuref3 { +// CHECK-NEXT: int a; +// CHECK-NEXT: int a_1; +// CHECK-NEXT: int a_2; +// CHECK-NEXT: int a1; +// CHECK-NEXT: int c; +// CHECK-NEXT: int c_1; +// CHECK-NEXT: Yielder Ft_1; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_struct_Void struct__Futuref3_poll(struct _Futuref3 *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: case 1: +// CHECK-NEXT: goto __L1; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->a = 4; +// CHECK-NEXT: this->a_1 = 2; +// CHECK-NEXT: this->a_2 = 1; +// CHECK-NEXT: this->Ft_1 = yield(); +// CHECK-NEXT: __L1: +// CHECK-NEXT: ; +// CHECK-NEXT: _Bool Res_1; +// CHECK-NEXT: struct PollResult__Bool PR_1 = Yielder_poll(&this->Ft_1); +// CHECK-NEXT: if (struct_PollResult__Bool_is_completed(&PR_1, &Res_1)) { +// CHECK-NEXT: Yielder_free(&this->Ft_1); +// CHECK-NEXT: } else { +// CHECK-NEXT: this->__future_state = 1; +// CHECK-NEXT: return struct_PollResult_struct_Void_pending(); +// CHECK-NEXT: } +// CHECK-NEXT: Res_1; +// CHECK-NEXT: this->a1 = 2; +// CHECK-NEXT: this->c = 3; +// CHECK-NEXT: this->c_1 = 5; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: struct Void __RES_RETURN = (struct Void){}; +// CHECK-NEXT: return struct_PollResult_struct_Void_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Judgement/await-expr-if/await-expr-if.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Judgement/await-expr-if/await-expr-if.cbs index a83fda910ffb6052c9253163435782ed112fecfc..f3c11fbdaa8823c8b33596419b0e465c97917968 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Judgement/await-expr-if/await-expr-if.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Judgement/await-expr-if/await-expr-if.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -32,4 +33,42 @@ int main() { trait Future* this = f(1); this->poll(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: int result; +// CHECK-NEXT: int a1; +// CHECK-NEXT: int a; +// CHECK-NEXT: int a2; +// CHECK-NEXT: int a_1; +// CHECK-NEXT: int a3; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->result = this->start; +// CHECK-NEXT: if (this->start > 2 && this->start < 5) { +// CHECK-NEXT: if (this->start > -5) { +// CHECK-NEXT: this->a = 3; +// CHECK-NEXT: this->a1 = 0; +// CHECK-NEXT: } +// CHECK-NEXT: } else if (this->start < 0) { +// CHECK-NEXT: this->a_1 = 3; +// CHECK-NEXT: this->a2 = 0; +// CHECK-NEXT: } else { +// CHECK-NEXT: this->a3 = this->result + 1; +// CHECK-NEXT: } +// CHECK-NEXT: this->result += this->start; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->result; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Judgement/if-else-statement/if-else-statement.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Judgement/if-else-statement/if-else-statement.cbs index 55391a965fd9adc8cb67fe1df3d11b2fcb44bc7e..d953403145cf27e06e1f00a9420d236535f63537 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Judgement/if-else-statement/if-else-statement.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Judgement/if-else-statement/if-else-statement.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -26,4 +27,32 @@ int main() { trait Future* this = f(1); this->poll(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: int x; +// CHECK-NEXT: int result; +// CHECK-NEXT: int a; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->x = 3; +// CHECK-NEXT: if (this->x < 20) { +// CHECK-NEXT: this->a = 1; +// CHECK-NEXT: this->result = 0; +// CHECK-NEXT: } else +// CHECK-NEXT: this->result = this->x; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->result; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Judgement/if-nested-if-statement/if-nested-if-statement.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Judgement/if-nested-if-statement/if-nested-if-statement.cbs index 0525e0f7e5b08b87b38516fab9c113a011f9ba05..da4a6d7163781329b878882f420926d5882dd090 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Judgement/if-nested-if-statement/if-nested-if-statement.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Judgement/if-nested-if-statement/if-nested-if-statement.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -27,4 +28,34 @@ int main() { trait Future* this = f(1); this->poll(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: int x; +// CHECK-NEXT: int result; +// CHECK-NEXT: int a; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->x = 3; +// CHECK-NEXT: if (this->x < 20) { +// CHECK-NEXT: if (this->x > 0) { +// CHECK-NEXT: this->a = 1; +// CHECK-NEXT: this->result = 0; +// CHECK-NEXT: } +// CHECK-NEXT: } else +// CHECK-NEXT: this->result = this->x; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->result; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Judgement/if-statement-uninitialized-static/if-statement-uninitialized-static.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Judgement/if-statement-uninitialized-static/if-statement-uninitialized-static.cbs index 9b548e9ddb1a029aefb772f997c1d1a30a6e7512..9000ef567a32fcd727be183db8b42e6caadcfe8b 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Judgement/if-statement-uninitialized-static/if-statement-uninitialized-static.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Judgement/if-statement-uninitialized-static/if-statement-uninitialized-static.cbs @@ -35,4 +35,25 @@ int main() { // CHECK-NEXT: struct _Futuref fi = {}; // CHECK-NEXT: fi.__future_state = 0; // CHECK-NEXT: return fi; +// CHECK-NEXT: } + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: if (1) { +// CHECK-NEXT: this->a = 0; +// CHECK-NEXT: this->ret = 0; +// CHECK-NEXT: } else { +// CHECK-NEXT: this->a_1 = 0; +// CHECK-NEXT: this->ret = 0; +// CHECK-NEXT: } +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->ret; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } // CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Judgement/if-statement-uninitialized/if-statement-uninitialized.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Judgement/if-statement-uninitialized/if-statement-uninitialized.cbs index a29d791b9ab73e6718ed53fa52b1afad6b6df7c0..6d4f04e300162cd6c72833ff698d665f35988474 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Judgement/if-statement-uninitialized/if-statement-uninitialized.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Judgement/if-statement-uninitialized/if-statement-uninitialized.cbs @@ -39,3 +39,24 @@ int main() { // CHECK-NEXT: data->__future_state = 0; // CHECK-NEXT: return data; // CHECK-NEXT: } + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: if (1) { +// CHECK-NEXT: this->a = 0; +// CHECK-NEXT: this->ret = 0; +// CHECK-NEXT: } else { +// CHECK-NEXT: this->a_1 = 0; +// CHECK-NEXT: this->ret = 0; +// CHECK-NEXT: } +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->ret; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Judgement/if-statement/if-statement.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Judgement/if-statement/if-statement.cbs index 415b61a989c17c9df304eafc609012444d12ed5d..7457dbc5508b1627f8fab63edbe658e155d0c636 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Judgement/if-statement/if-statement.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Judgement/if-statement/if-statement.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -26,4 +27,31 @@ int main() { trait Future* this = f(1); this->poll(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: int x; +// CHECK-NEXT: int result; +// CHECK-NEXT: int a; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->x = 3; +// CHECK-NEXT: if (this->x < 20) { +// CHECK-NEXT: this->a = 1; +// CHECK-NEXT: this->result = 0; +// CHECK-NEXT: } +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->result; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Judgement/switch-nested-switch-statement/switch-nested-switch-statement.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Judgement/switch-nested-switch-statement/switch-nested-switch-statement.cbs index cf57a985248d16919931007e008362ba532631b0..9dabdab947a77a519600d2bcf9f63b44da6ac8e8 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Judgement/switch-nested-switch-statement/switch-nested-switch-statement.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Judgement/switch-nested-switch-statement/switch-nested-switch-statement.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -44,4 +45,50 @@ int main() { trait Future* this = f(1); this->poll(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: char grade; +// CHECK-NEXT: int class; +// CHECK-NEXT: int result; +// CHECK-NEXT: int a; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->grade = 'B'; +// CHECK-NEXT: this->class = -1; +// CHECK-NEXT: this->a = 1; +// CHECK-NEXT: this->result = 0; +// CHECK-NEXT: switch (this->grade) { +// CHECK-NEXT: case 'A': +// CHECK-NEXT: this->result = 1; +// CHECK-NEXT: switch (this->class) { +// CHECK-NEXT: case -1: +// CHECK-NEXT: this->result = -1; +// CHECK-NEXT: } +// CHECK-NEXT: break; +// CHECK-NEXT: case 'B': +// CHECK-NEXT: case 'C': +// CHECK-NEXT: this->result = 2; +// CHECK-NEXT: break; +// CHECK-NEXT: case 'D': +// CHECK-NEXT: case 'F': +// CHECK-NEXT: this->result = 3; +// CHECK-NEXT: break; +// CHECK-NEXT: default: +// CHECK-NEXT: this->result = -1; +// CHECK-NEXT: } +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->result; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Judgement/switch-statement/switch-statement.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Judgement/switch-statement/switch-statement.cbs index 70cabcd33673f96a4cbe3a73f5264da602e99052..e61c34498535e4c04270175a3b4800ab68a17749 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Judgement/switch-statement/switch-statement.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Judgement/switch-statement/switch-statement.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -38,4 +39,44 @@ int main() { trait Future* this = f(1); this->poll(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: char grade; +// CHECK-NEXT: int result; +// CHECK-NEXT: int a; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->grade = 'B'; +// CHECK-NEXT: this->a = 1; +// CHECK-NEXT: this->result = 0; +// CHECK-NEXT: switch (this->grade) { +// CHECK-NEXT: case 'A': +// CHECK-NEXT: this->result = 1; +// CHECK-NEXT: break; +// CHECK-NEXT: case 'B': +// CHECK-NEXT: case 'C': +// CHECK-NEXT: this->result = 2; +// CHECK-NEXT: break; +// CHECK-NEXT: case 'D': +// CHECK-NEXT: case 'F': +// CHECK-NEXT: this->result = 3; +// CHECK-NEXT: break; +// CHECK-NEXT: default: +// CHECK-NEXT: this->result = -1; +// CHECK-NEXT: } +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->result; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/Other/LabelStmt/label-stmt/label-stmt.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/Other/LabelStmt/label-stmt/label-stmt.cbs index 6cbec0afbf9b7586983f8dcb22093c3960df0466..9414dc0779adfe74162b75b6d0e2c6e1a9fbdbbe 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/Other/LabelStmt/label-stmt/label-stmt.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/Other/LabelStmt/label-stmt/label-stmt.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -25,7 +26,7 @@ ERR: return result; ERR2: result = result + 1; - return result; + return result; } int main() { @@ -34,45 +35,43 @@ int main() { return 0; } +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: int result; +// CHECK-NEXT: int a; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + // CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { // CHECK-NEXT: switch (this->__future_state) { // CHECK-NEXT: case 0: // CHECK-NEXT: goto __L0; -// CHECK-NEXT: case 1: -// CHECK-NEXT: goto __L1; // CHECK-NEXT: } // CHECK-NEXT: __L0: // CHECK-NEXT: ; -// CHECK-NEXT: this->Ft_1 = __read(1); -// CHECK-NEXT: __L1: -// CHECK-NEXT: ; -// CHECK-NEXT: int Res_1; -// CHECK-NEXT: struct PollResult_int PR_1 = this->Ft_1.vtable->poll(this->Ft_1.data); -// CHECK-NEXT: if (struct_PollResult_int_is_completed(&PR_1, &Res_1)) { -// CHECK-NEXT: if (this->Ft_1.data != 0) { -// CHECK-NEXT: this->Ft_1.vtable->free(this->Ft_1.data); -// CHECK-NEXT: this->Ft_1.data = (void *)0; -// CHECK-NEXT: } -// CHECK-NEXT: } else { -// CHECK-NEXT: this->__future_state = 1; -// CHECK-NEXT: return struct_PollResult_int_pending(); -// CHECK-NEXT: } -// CHECK-NEXT: this->result = Res_1; +// CHECK-NEXT: this->a = 1; +// CHECK-NEXT: this->result = 0; // CHECK-NEXT: if (this->result != 0) { // CHECK-NEXT: goto ERR; // CHECK-NEXT: } else if (this->result != 1) { // CHECK-NEXT: goto ERR2; // CHECK-NEXT: } -// CHECK-NEXT: this->__future_state = -1; -// CHECK-NEXT: int __RES_RETURN = this->result; -// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->result; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } // CHECK-NEXT: ERR: -// CHECK-NEXT: this->__future_state = -1; -// CHECK-NEXT: int __RES_RETURN_1 = this->result; -// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN_1); +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN_1 = this->result; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN_1); +// CHECK-NEXT: } // CHECK-NEXT: ERR2: // CHECK-NEXT: this->result = this->result + 1; -// CHECK-NEXT: this->__future_state = -1; -// CHECK-NEXT: int __RES_RETURN_2 = this->result; -// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN_2); +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN_2 = this->result; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN_2); +// CHECK-NEXT: } // CHECK-NEXT: } diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Loop/do-while-loop/do-while-loop.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Loop/do-while-loop/do-while-loop.cbs index 38a870f07735bd999ff4c707c8d7e23f0915f894..ea54647ec0f91d415a0d729e45dbbaccd8ac2760 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Loop/do-while-loop/do-while-loop.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Loop/do-while-loop/do-while-loop.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -27,4 +28,33 @@ int main() { trait Future* this = f(1); this->poll(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: int i; +// CHECK-NEXT: int a; +// CHECK-NEXT: int result; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->i = 0; +// CHECK-NEXT: do { +// CHECK-NEXT: this->a = this->i; +// CHECK-NEXT: this->start = 0; +// CHECK-NEXT: this->i++; +// CHECK-NEXT: } while (this->i < 3); +// CHECK-NEXT: this->result = this->start; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->result; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Loop/for-loop/for-loop.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Loop/for-loop/for-loop.cbs index 3e675f749ec434247323ed0913262f0e1176126e..36af570affce768467b7dcd64c681e09e026f374 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Loop/for-loop/for-loop.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Loop/for-loop/for-loop.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -25,4 +26,31 @@ int main() { trait Future* this = f(1); this->poll(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: int i; +// CHECK-NEXT: int a; +// CHECK-NEXT: int result; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: for (this->i = 0; this->i < 3; this->i++) { +// CHECK-NEXT: this->a = this->i; +// CHECK-NEXT: this->start = 0; +// CHECK-NEXT: } +// CHECK-NEXT: this->result = this->start; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->result; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Loop/loop-nested/loop-nested.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Loop/loop-nested/loop-nested.cbs index 65e7e0824428df2fb78419ad2fef87281c2a0eeb..cd147ce8e8540866803f9d1fc42fb83488cbd1d9 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Loop/loop-nested/loop-nested.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Loop/loop-nested/loop-nested.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -29,4 +30,36 @@ int main() { trait Future* this = f(1); this->poll(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: int i; +// CHECK-NEXT: int a; +// CHECK-NEXT: int j; +// CHECK-NEXT: int result; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->i = 0; +// CHECK-NEXT: do { +// CHECK-NEXT: this->a = this->i; +// CHECK-NEXT: this->start = 0; +// CHECK-NEXT: this->i++; +// CHECK-NEXT: for (this->j = 0; this->j < 3; this->j++) +// CHECK-NEXT: this->start++; +// CHECK-NEXT: } while (this->i < 3); +// CHECK-NEXT: this->result = this->start; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->result; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Loop/while-loop/while-loop.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Loop/while-loop/while-loop.cbs index 86475c47c909425bec189e814f365df82cf5f095..0fdf018787012d42864cb3090731658c53784431 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Loop/while-loop/while-loop.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Loop/while-loop/while-loop.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -28,4 +29,34 @@ int main() { trait Future* this = f(1); this->poll(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: int i; +// CHECK-NEXT: int a; +// CHECK-NEXT: int result; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->i = 0; +// CHECK-NEXT: while (this->i < 3) +// CHECK-NEXT: { +// CHECK-NEXT: this->a = this->i; +// CHECK-NEXT: this->start = 0; +// CHECK-NEXT: this->i++; +// CHECK-NEXT: } +// CHECK-NEXT: this->result = this->start; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->result; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Operators/arithmetic-op/arithmetic-op.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Operators/arithmetic-op/arithmetic-op.cbs index 3c591e2f1fe4166ec0763691ae4d354865e9fb45..b66ae4d66767816c613cd780fdfdf1e0ec6bd603 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Operators/arithmetic-op/arithmetic-op.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Operators/arithmetic-op/arithmetic-op.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -32,4 +33,39 @@ int main() { trait Future* this = f(1); this->poll(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: int x; +// CHECK-NEXT: int y; +// CHECK-NEXT: int c; +// CHECK-NEXT: int result; +// CHECK-NEXT: int a; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->x = 3; +// CHECK-NEXT: this->y = 5; +// CHECK-NEXT: this->c = this->x + this->y; +// CHECK-NEXT: this->c = this->x - this->y; +// CHECK-NEXT: this->c = this->x * this->y; +// CHECK-NEXT: this->c = this->x / this->y; +// CHECK-NEXT: this->c = this->x % this->y; +// CHECK-NEXT: this->c = this->y++; +// CHECK-NEXT: this->c = this->y--; +// CHECK-NEXT: this->a = 1; +// CHECK-NEXT: this->result = 0; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->result; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Operators/assign-op/assign-op.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Operators/assign-op/assign-op.cbs index 85806cdd1ec90b9c894c06c167b35163588e3658..03f27585b68482b1dd8a0f2218977defa8f02be5 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Operators/assign-op/assign-op.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Operators/assign-op/assign-op.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -36,4 +37,45 @@ int main() { trait Future* this = f(1); this->poll(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: unsigned int x; +// CHECK-NEXT: int z; +// CHECK-NEXT: int a; +// CHECK-NEXT: int a_1; +// CHECK-NEXT: int result; +// CHECK-NEXT: int a_2; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->x = 3; +// CHECK-NEXT: this->z = this->x; +// CHECK-NEXT: this->z += this->x; +// CHECK-NEXT: this->z -= this->x; +// CHECK-NEXT: this->z *= this->x; +// CHECK-NEXT: this->z /= this->x; +// CHECK-NEXT: this->z %= this->x; +// CHECK-NEXT: this->z <<= this->x; +// CHECK-NEXT: this->z >>= this->x; +// CHECK-NEXT: this->z &= this->x; +// CHECK-NEXT: this->z ^= this->x; +// CHECK-NEXT: this->z |= this->x; +// CHECK-NEXT: this->a_1 = 1; +// CHECK-NEXT: this->a = 0; +// CHECK-NEXT: this->a_2 = 1; +// CHECK-NEXT: this->result = 0; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->result; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Operators/bit-op/bit-op.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Operators/bit-op/bit-op.cbs index 1cbcabc3ed38172daa27cfffe34b670cd278cc3f..649a4cf0cabd559d3ffb05b9ed938dce274f8a2a 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Operators/bit-op/bit-op.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Operators/bit-op/bit-op.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -32,4 +33,42 @@ int main() { trait Future* this = f(1); this->poll(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: unsigned int x; +// CHECK-NEXT: unsigned int y; +// CHECK-NEXT: int z; +// CHECK-NEXT: int a; +// CHECK-NEXT: int a_1; +// CHECK-NEXT: int result; +// CHECK-NEXT: int a_2; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->x = 3; +// CHECK-NEXT: this->y = 4; +// CHECK-NEXT: this->z = this->x & this->y; +// CHECK-NEXT: this->z = this->x | this->y; +// CHECK-NEXT: this->z = this->x ^ this->y; +// CHECK-NEXT: this->z = ~this->y; +// CHECK-NEXT: this->z = this->x << this->y; +// CHECK-NEXT: this->z = this->x >> this->y; +// CHECK-NEXT: this->a_1 = 1; +// CHECK-NEXT: this->a = 0; +// CHECK-NEXT: this->a_2 = 1; +// CHECK-NEXT: this->result = 0; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->result; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Operators/logocal-op/logocal-op.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Operators/logocal-op/logocal-op.cbs index f798ec9c01614eb80c7101b244e263debe00fc6c..5f29bbadfa081ae26a18cdc46586af5ba50e18f4 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Operators/logocal-op/logocal-op.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Operators/logocal-op/logocal-op.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -29,4 +30,40 @@ int main() { trait Future* this = f(1); this->poll(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: int x; +// CHECK-NEXT: int y; +// CHECK-NEXT: int z; +// CHECK-NEXT: int a; +// CHECK-NEXT: int a_1; +// CHECK-NEXT: int result; +// CHECK-NEXT: int a_2; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->x = 3; +// CHECK-NEXT: this->y = 4; +// CHECK-NEXT: this->z = this->x && this->y; +// CHECK-NEXT: this->z = this->x || this->y; +// CHECK-NEXT: this->z = !(this->x && this->y); +// CHECK-NEXT: this->a_1 = 1; +// CHECK-NEXT: this->a = 0; +// CHECK-NEXT: this->a_2 = 1; +// CHECK-NEXT: this->result = 0; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->result; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Operators/other-op/other-op.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Operators/other-op/other-op.cbs index 761326d797b38a075ab14cefc7e6e6243c56927f..2e85edbee6b2b7d36eaeeeff5f7db1909fe932df 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Operators/other-op/other-op.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Operators/other-op/other-op.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -28,4 +29,37 @@ int main() { trait Future* this = f(1); this->poll(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: int x; +// CHECK-NEXT: int z; +// CHECK-NEXT: int *ptr; +// CHECK-NEXT: int a; +// CHECK-NEXT: int a_1; +// CHECK-NEXT: int result; +// CHECK-NEXT: int a_2; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->x = 3; +// CHECK-NEXT: this->ptr = &this->x; +// CHECK-NEXT: this->z = (this->x == 3) ? 20 : 30; +// CHECK-NEXT: this->a_1 = 1; +// CHECK-NEXT: this->a = 0; +// CHECK-NEXT: this->a_2 = 1; +// CHECK-NEXT: this->result = 0; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->result; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Operators/relational-op/relational-op.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Operators/relational-op/relational-op.cbs index d0c976b8fffc9d0333932716ef1f7ab88ed2d280..6ff008cf94185e9fcdf2beda07fa98f3c27833dd 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Operators/relational-op/relational-op.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/Other/Operators/relational-op/relational-op.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -32,4 +33,42 @@ int main() { trait Future* this = f(1); this->poll(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: int x; +// CHECK-NEXT: int y; +// CHECK-NEXT: int z; +// CHECK-NEXT: int a; +// CHECK-NEXT: int a_1; +// CHECK-NEXT: int result; +// CHECK-NEXT: int a_2; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->x = 3; +// CHECK-NEXT: this->y = 4; +// CHECK-NEXT: this->z = this->x == this->y; +// CHECK-NEXT: this->z = this->x != this->y; +// CHECK-NEXT: this->z = this->x > this->y; +// CHECK-NEXT: this->z = this->x < this->y; +// CHECK-NEXT: this->z = this->x >= this->y; +// CHECK-NEXT: this->z = this->x <= this->y; +// CHECK-NEXT: this->a_1 = 1; +// CHECK-NEXT: this->a = 0; +// CHECK-NEXT: this->a_2 = 1; +// CHECK-NEXT: this->result = 0; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->result; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/ReturnStmt/async-func-return-const-int/async-func-return-const-int.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/ReturnStmt/async-func-return-const-int/async-func-return-const-int.cbs index a5d4afbbc582114e2f16eeb96c47f83486ad3fd7..afb413ea66bf63661768bbef825087185298d588 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/ReturnStmt/async-func-return-const-int/async-func-return-const-int.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/ReturnStmt/async-func-return-const-int/async-func-return-const-int.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -31,4 +32,43 @@ int main() { trait Future* this = f(1); this->poll(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: int a; +// CHECK-NEXT: int a_1; +// CHECK-NEXT: int b; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->a_1 = 1; +// CHECK-NEXT: this->a = 0; +// CHECK-NEXT: this->b = 2; +// CHECK-NEXT: if (this->a == 1) { +// CHECK-NEXT: if (this->b == 3) { +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = -1; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN_1 = 2; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN_1); +// CHECK-NEXT: } +// CHECK-NEXT: } +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN_2 = -1; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN_2); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/ReturnStmt/async-func-return-type/async-func-return-type.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/ReturnStmt/async-func-return-type/async-func-return-type.cbs index bba2a1cc9331b618f33395d0e2d61c4a3107fa7b..b67b9a9380e3668e99be15029e603ae713e2d65d 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/ReturnStmt/async-func-return-type/async-func-return-type.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/ReturnStmt/async-func-return-type/async-func-return-type.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -93,3 +94,79 @@ int main() { return 0; } +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: int a; +// CHECK-NEXT: int a_1; +// CHECK-NEXT: int b; +// CHECK-NEXT: struct __Trait_Future_int Ft_1; +// CHECK-NEXT: struct __Trait_Future_int Ft_2; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: case 1: +// CHECK-NEXT: goto __L1; +// CHECK-NEXT: case 2: +// CHECK-NEXT: goto __L2; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->a_1 = 1; +// CHECK-NEXT: this->a = 0; +// CHECK-NEXT: this->b = 2; +// CHECK-NEXT: if (this->a == 1) { +// CHECK-NEXT: this->Ft_1 = test1(2); +// CHECK-NEXT: __L1: +// CHECK-NEXT: ; +// CHECK-NEXT: int Res_1; +// CHECK-NEXT: struct PollResult_int PR_1 = this->Ft_1.vtable->poll(this->Ft_1.data); +// CHECK-NEXT: if (struct_PollResult_int_is_completed(&PR_1, &Res_1)) { +// CHECK-NEXT: if (this->Ft_1.data != 0) { +// CHECK-NEXT: this->Ft_1.vtable->free(this->Ft_1.data); +// CHECK-NEXT: this->Ft_1.data = (void *)0; +// CHECK-NEXT: } +// CHECK-NEXT: } else { +// CHECK-NEXT: this->__future_state = 1; +// CHECK-NEXT: return struct_PollResult_int_pending(); +// CHECK-NEXT: } +// CHECK-NEXT: this->b = Res_1; +// CHECK-NEXT: if (this->b == 3) { +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = 1; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } else { +// CHECK-NEXT: this->Ft_2 = test2(3); +// CHECK-NEXT: __L2: +// CHECK-NEXT: ; +// CHECK-NEXT: int Res_2; +// CHECK-NEXT: struct PollResult_int PR_2 = this->Ft_2.vtable->poll(this->Ft_2.data); +// CHECK-NEXT: if (struct_PollResult_int_is_completed(&PR_2, &Res_2)) { +// CHECK-NEXT: if (this->Ft_2.data != 0) { +// CHECK-NEXT: this->Ft_2.vtable->free(this->Ft_2.data); +// CHECK-NEXT: this->Ft_2.data = (void *)0; +// CHECK-NEXT: } +// CHECK-NEXT: } else { +// CHECK-NEXT: this->__future_state = 2; +// CHECK-NEXT: return struct_PollResult_int_pending(); +// CHECK-NEXT: } +// CHECK-NEXT: this->b = Res_2; +// CHECK-NEXT: } +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN_1 = 3; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN_1); +// CHECK-NEXT: } +// CHECK-NEXT: } +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN_2 = -1; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN_2); +// CHECK-NEXT: } +// CHECK-NEXT: } + diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/ReturnStmt/async-func-return-void/async-func-return-void.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/ReturnStmt/async-func-return-void/async-func-return-void.cbs index 6b6625d2c9b080d700c68d81ecefd1852f8cc6aa..0d1dee8820938fa773ab2d32bb933d5ea34527b5 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/ReturnStmt/async-func-return-void/async-func-return-void.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/ReturnStmt/async-func-return-void/async-func-return-void.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -24,4 +25,32 @@ int main() { trait Future* this = f(1); this->poll(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: int result; +// CHECK-NEXT: int i; +// CHECK-NEXT: int a; +// CHECK-NEXT: int a_1; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_struct_Void struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->result = this->start; +// CHECK-NEXT: for (this->i = 0; this->i < this->start; this->i++) { +// CHECK-NEXT: this->a_1 = 1; +// CHECK-NEXT: this->a = 0; +// CHECK-NEXT: } +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: struct Void __RES_RETURN = (struct Void){}; +// CHECK-NEXT: return struct_PollResult_struct_Void_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/ReturnStmt/async-func-return-void1/async-func-return-void1.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/ReturnStmt/async-func-return-void1/async-func-return-void1.cbs new file mode 100644 index 0000000000000000000000000000000000000000..f0066a7285132bf13a8d1adb83f68f1e41aade7c --- /dev/null +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/ReturnStmt/async-func-return-void1/async-func-return-void1.cbs @@ -0,0 +1,94 @@ +// RUN: %clang %s -o %test.output +// RUN: %test.output +// RUN: %clang -rewrite-bsc %S/../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h +// RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s +// RUN: %clang %t-rw.c -o %t-rw.output +// RUN: %t-rw.output +// expected-no-diagnostics + +#include "future.hbs" +#include + +async int read(int a) { + int b = a; + return b; +} + +async void f2(int a) { + a = a + 1; + await read(a); + if (a > 0) { + int b = a + 5; + return; + } + + if (a < -3) { + int b = await read(a); + return; + } + + int b = a + 3; + return; +} + +async int f1() { + int a = 5; + await f2(a); + int b = a + 5; + return b; +} + +int main() { + trait Future* this = f1(); + this->poll(); + return 0; +} + +// CHECK: struct _Futuref1 { +// CHECK-NEXT: int a; +// CHECK-NEXT: int a_1; +// CHECK-NEXT: int a_2; +// CHECK-NEXT: int b; +// CHECK-NEXT: int b_1; +// CHECK-NEXT: int b_2; +// CHECK-NEXT: int a_3; +// CHECK-NEXT: int b_3; +// CHECK-NEXT: int b_4; +// CHECK-NEXT: int b_5; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref1_poll(struct _Futuref1 *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->a = 5; +// CHECK-NEXT: this->a_1 = this->a; +// CHECK-NEXT: this->a_1 = this->a_1 + 1; +// CHECK-NEXT: this->a_2 = this->a_1; +// CHECK-NEXT: this->b = this->a_2; +// CHECK-NEXT: if (this->a_1 > 0) { +// CHECK-NEXT: this->b_1 = this->a_1 + 5; +// CHECK-NEXT: goto __NextStmt_2; +// CHECK-NEXT: } +// CHECK-NEXT: if (this->a_1 < -3) { +// CHECK-NEXT: this->a_3 = this->a_1; +// CHECK-NEXT: this->b_3 = this->a_3; +// CHECK-NEXT: this->b_2 = this->b_3; +// CHECK-NEXT: goto __NextStmt_2; +// CHECK-NEXT: } +// CHECK-NEXT: this->b_4 = this->a_1 + 3; +// CHECK-NEXT: goto __NextStmt_2; +// CHECK-NEXT: __NextStmt_2: +// CHECK-NEXT: ; +// CHECK-NEXT: this->b_5 = this->a + 5; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->b_5; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/ReturnStmt/await-expr-return-type/await-expr-return-type.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/ReturnStmt/await-expr-return-type/await-expr-return-type.cbs index a021e7b2fecdaf3039856f3f58d240821fae5ad8..7d7356afa4095d0c03693fa5f2b18e9fc848a983 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/ReturnStmt/await-expr-return-type/await-expr-return-type.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/ReturnStmt/await-expr-return-type/await-expr-return-type.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -23,4 +24,31 @@ int main() { trait Future* this = f(1); this->poll(); return 0; -} \ No newline at end of file +} + +// CHECK: struct _Futuref { +// CHECK-NEXT: int start; +// CHECK-NEXT: int r1; +// CHECK-NEXT: int a; +// CHECK-NEXT: int result; +// CHECK-NEXT: int a_1; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref_poll(struct _Futuref *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->a = 1; +// CHECK-NEXT: this->r1 = 0; +// CHECK-NEXT: this->a_1 = 1; +// CHECK-NEXT: this->result = 0; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->r1 * this->result + this->start; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/ReturnStmt/await-expr-return-type1/await-expr-return-type1.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/ReturnStmt/await-expr-return-type1/await-expr-return-type1.cbs index d9792b2ed5785d3c41b142acdd20ac0ca8c492c6..78b90e05e1aaa3ddf1ef2b997cd852824ade9539 100644 --- a/clang/test/BSC/Positive/Coroutine/Treetransform/ReturnStmt/await-expr-return-type1/await-expr-return-type1.cbs +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/ReturnStmt/await-expr-return-type1/await-expr-return-type1.cbs @@ -2,6 +2,7 @@ // RUN: %test.output // RUN: %clang -rewrite-bsc %S/../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h // RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s // RUN: %clang %t-rw.c -o %t-rw.output // RUN: %t-rw.output // expected-no-diagnostics @@ -27,3 +28,29 @@ int main() { g(); return 0; } + +// CHECK: struct _Futureg { +// CHECK-NEXT: int result; +// CHECK-NEXT: int result_1; +// CHECK-NEXT: int start; +// CHECK-NEXT: int a; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futureg_poll(struct _Futureg *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->start = 2; +// CHECK-NEXT: this->a = 1; +// CHECK-NEXT: this->result_1 = 0; +// CHECK-NEXT: this->result = this->start * this->result_1; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->result + 5; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } diff --git a/clang/test/BSC/Positive/Coroutine/Treetransform/ReturnStmt/return-await-expr/return-await-expr.cbs b/clang/test/BSC/Positive/Coroutine/Treetransform/ReturnStmt/return-await-expr/return-await-expr.cbs new file mode 100644 index 0000000000000000000000000000000000000000..516e526840a610adfd5bed7871d412763499d0f1 --- /dev/null +++ b/clang/test/BSC/Positive/Coroutine/Treetransform/ReturnStmt/return-await-expr/return-await-expr.cbs @@ -0,0 +1,101 @@ +// RUN: %clang %s -o %test.output +// RUN: %test.output +// RUN: %clang -rewrite-bsc %S/../../../../../../../lib/Headers/bsc_include/future.hbs -o %T/future.h +// RUN: %clang -rewrite-bsc %s -o %t-rw.c +// RUN: FileCheck --input-file=%t-rw.c %s +// RUN: %clang %t-rw.c -o %t-rw.output +// RUN: %t-rw.output +// expected-no-diagnostics + +#include "future.hbs" +#include + +async int read(int a) { + int b = a; + return b; +} + +async int f2(int a) { + a = a + 1; + await read(a); + if (a > 0) { + int b = a + 5; + return await read(b); + } + + if (a < -3) { + int b = await read(a); + return 2; + } + + int b = a + 3; + return 2; +} + +async int f1() { + int a = 5; + int b = await f2(a); + b = a + 5; + return b; +} + +int main() { + trait Future* this = f1(); + this->poll(); + return 0; +} + +// CHECK: struct _Futuref1 { +// CHECK-NEXT: int a; +// CHECK-NEXT: int b; +// CHECK-NEXT: int a_1; +// CHECK-NEXT: int a_2; +// CHECK-NEXT: int b_1; +// CHECK-NEXT: int b_2; +// CHECK-NEXT: int a_3; +// CHECK-NEXT: int b_3; +// CHECK-NEXT: int b_4; +// CHECK-NEXT: int a_4; +// CHECK-NEXT: int b_5; +// CHECK-NEXT: int b_6; +// CHECK-NEXT: int __future_state; +// CHECK-NEXT: }; + +// CHECK: struct PollResult_int struct__Futuref1_poll(struct _Futuref1 *this) { +// CHECK-NEXT: switch (this->__future_state) { +// CHECK-NEXT: case 0: +// CHECK-NEXT: goto __L0; +// CHECK-NEXT: } +// CHECK-NEXT: __L0: +// CHECK-NEXT: ; +// CHECK-NEXT: this->a = 5; +// CHECK-NEXT: this->a_1 = this->a; +// CHECK-NEXT: this->a_1 = this->a_1 + 1; +// CHECK-NEXT: this->a_2 = this->a_1; +// CHECK-NEXT: this->b_1 = this->a_2; +// CHECK-NEXT: if (this->a_1 > 0) { +// CHECK-NEXT: this->b_2 = this->a_1 + 5; +// CHECK-NEXT: this->a_3 = this->b_2; +// CHECK-NEXT: this->b_3 = this->a_3; +// CHECK-NEXT: this->b = this->b_3; +// CHECK-NEXT: goto __NextStmt_2; +// CHECK-NEXT: } +// CHECK-NEXT: if (this->a_1 < -3) { +// CHECK-NEXT: this->a_4 = this->a_1; +// CHECK-NEXT: this->b_5 = this->a_4; +// CHECK-NEXT: this->b_4 = this->b_5; +// CHECK-NEXT: this->b = 2; +// CHECK-NEXT: goto __NextStmt_2; +// CHECK-NEXT: } +// CHECK-NEXT: this->b_6 = this->a_1 + 3; +// CHECK-NEXT: this->b = 2; +// CHECK-NEXT: goto __NextStmt_2; +// CHECK-NEXT: __NextStmt_2: +// CHECK-NEXT: ; +// CHECK-NEXT: this->b = this->a + 5; +// CHECK-NEXT: { +// CHECK-NEXT: this->__future_state = -1; +// CHECK-NEXT: int __RES_RETURN = this->b; +// CHECK-NEXT: return struct_PollResult_int_completed(__RES_RETURN); +// CHECK-NEXT: } +// CHECK-NEXT: } \ No newline at end of file diff --git a/clang/test/BSC/Positive/Coroutine/Atmoic/rewrite_atmoic.cbs b/clang/test/BSC/Positive/Driver/rewrite-bsc/Atmoic/rewrite_atmoic.cbs similarity index 100% rename from clang/test/BSC/Positive/Coroutine/Atmoic/rewrite_atmoic.cbs rename to clang/test/BSC/Positive/Driver/rewrite-bsc/Atmoic/rewrite_atmoic.cbs diff --git a/clang/test/BSC/Positive/OperatorOverload/deref/deref.cbs b/clang/test/BSC/Positive/OperatorOverload/deref/deref.cbs index e73b847fa9c69d78ce49d6fcbf20c19dbd09bb9a..7d5c074b35722f0f827c8ba5a086a5fe718c8c78 100644 --- a/clang/test/BSC/Positive/OperatorOverload/deref/deref.cbs +++ b/clang/test/BSC/Positive/OperatorOverload/deref/deref.cbs @@ -156,8 +156,8 @@ int main() { } // CHECK: #include -// CHECK-EMPTY: -// CHECK-EMPTY: +// CHECK-EMPTY: +// CHECK-EMPTY: // CHECK: struct E; // CHECK-NEXT: struct F; // CHECK-NEXT: struct G; @@ -196,21 +196,21 @@ int main() { // CHECK: struct RcRecord_int { // CHECK-NEXT: struct Rc_int rc; // CHECK-NEXT: }; -// CHECK-EMPTY: +// CHECK-EMPTY: // CHECK: static struct Rc_int struct_Rc_int_new(int data); -// CHECK-EMPTY: +// CHECK-EMPTY: // CHECK: static void struct_Rc_int_D( struct Rc_int this); -// CHECK-EMPTY: +// CHECK-EMPTY: // CHECK: static int * deref_int( struct Rc_int * rc); -// CHECK-EMPTY: +// CHECK-EMPTY: // CHECK: static void struct_RcRecord_int_D( struct RcRecord_int this); -// CHECK-EMPTY: +// CHECK-EMPTY: // CHECK: static struct Rc_int deref5_int( struct RcRecord_int *rcRecord); -// CHECK-EMPTY: +// CHECK-EMPTY: // CHECK: int *deref1(struct F *f) { // CHECK-NEXT: return &(f->e.a); // CHECK-NEXT: } -// CHECK-EMPTY: +// CHECK-EMPTY: // CHECK: int test1(void) { // CHECK-NEXT: struct E e1 = {1}; // CHECK-NEXT: struct F f1 = {e1}; @@ -224,11 +224,11 @@ int main() { // CHECK-NEXT: } // CHECK-NEXT: return 0; // CHECK-NEXT: } -// CHECK-EMPTY: +// CHECK-EMPTY: // CHECK: int * deref2(struct H * h) { // CHECK-NEXT: return &(h->g.a); // CHECK-NEXT: } -// CHECK-EMPTY: +// CHECK-EMPTY: // CHECK: int test2(void) { // CHECK-NEXT: struct G g1 = {1}; // CHECK-NEXT: struct H h1 = {g1, 11}; @@ -244,11 +244,11 @@ int main() { // CHECK-NEXT: } // CHECK-NEXT: return 0; // CHECK-NEXT: } -// CHECK-EMPTY: +// CHECK-EMPTY: // CHECK: const int * deref4(const struct J * j) { // CHECK-NEXT: return &(j->i.a); // CHECK-NEXT: } -// CHECK-EMPTY: +// CHECK-EMPTY: // CHECK: int test3(void) { // CHECK-NEXT: struct I i1 = {1}; // CHECK-NEXT: struct J j1 = {i1, 11}; @@ -260,7 +260,7 @@ int main() { // CHECK-NEXT: } // CHECK-NEXT: return 0; // CHECK-NEXT: } -// CHECK-EMPTY: +// CHECK-EMPTY: // CHECK: int test4(void) { // CHECK-NEXT: struct Rc_int rc = struct_Rc_int_new(5); // CHECK-NEXT: _Bool rc_is_moved = 0; @@ -279,7 +279,7 @@ int main() { // CHECK-NEXT: struct_Rc_int_D(rc); // CHECK-NEXT: return 0; // CHECK-NEXT: } -// CHECK-EMPTY: +// CHECK-EMPTY: // CHECK: int test5(void) { // CHECK-NEXT: struct Rc_int rc1 = struct_Rc_int_new(5); // CHECK-NEXT: _Bool rc1_is_moved = 0; @@ -297,14 +297,14 @@ int main() { // CHECK-NEXT: struct_Rc_int_D(rc1); // CHECK-NEXT: return 0; // CHECK-NEXT: } -// CHECK-EMPTY: +// CHECK-EMPTY: // CHECK: int main() { // CHECK-NEXT: if (test1() || test2() || test3() || test4() || test5()) { // CHECK-NEXT: return -1; // CHECK-NEXT: } // CHECK-NEXT: return 0; // CHECK-NEXT: } -// CHECK-EMPTY: +// CHECK-EMPTY: // CHECK: static struct Rc_int struct_Rc_int_new(int data) { // CHECK-NEXT: { // CHECK-NEXT: struct RcData_int *RcDataPtr = (struct RcData_int *)malloc(sizeof(struct RcData_int)); @@ -314,21 +314,21 @@ int main() { // CHECK-NEXT: return rc; // CHECK-NEXT: } // CHECK-NEXT: } -// CHECK-EMPTY: +// CHECK-EMPTY: // CHECK: static void struct_Rc_int_D( struct Rc_int this) { // CHECK-NEXT: _Bool this_is_moved = 0; // CHECK-NEXT: } -// CHECK-EMPTY: +// CHECK-EMPTY: // CHECK: static int * deref_int( struct Rc_int * rc) { // CHECK-NEXT: return &(rc->ptr->data); // CHECK-NEXT: } -// CHECK-EMPTY: +// CHECK-EMPTY: // CHECK: static void struct_RcRecord_int_D( struct RcRecord_int this) { // CHECK-NEXT: _Bool this_is_moved = 0; // CHECK-NEXT: struct_Rc_int_D(this.rc); // CHECK-NEXT: } -// CHECK-EMPTY: +// CHECK-EMPTY: // CHECK: static struct Rc_int deref5_int( struct RcRecord_int *rcRecord) { // CHECK-NEXT: return rcRecord->rc; // CHECK-NEXT: } -// CHECK-EMPTY: +// CHECK-EMPTY: diff --git a/clang/test/BSC/Positive/OperatorOverload/member_ref/member_ref.cbs b/clang/test/BSC/Positive/OperatorOverload/member_ref/member_ref.cbs index eb67c744f55af603a86f50aa625a1c6f2eacc0c7..ddc3867d786f13a03cbd802a2561c94af487dcc7 100644 --- a/clang/test/BSC/Positive/OperatorOverload/member_ref/member_ref.cbs +++ b/clang/test/BSC/Positive/OperatorOverload/member_ref/member_ref.cbs @@ -211,8 +211,8 @@ int main(){ } // CHECK: #include -// CHECK-EMPTY: -// CHECK-EMPTY: +// CHECK-EMPTY: +// CHECK-EMPTY: // CHECK: struct A; // CHECK-NEXT: struct AP; // CHECK-NEXT: struct B; @@ -256,25 +256,25 @@ int main(){ // CHECK: struct GP { // CHECK-NEXT: struct FP fp; // CHECK-NEXT: }; -// CHECK-EMPTY: +// CHECK-EMPTY: // CHECK: struct RcRecord_int { // CHECK-NEXT: struct Rc_int rc; // CHECK-NEXT: }; -// CHECK-EMPTY: +// CHECK-EMPTY: // CHECK: static struct Rc_int struct_Rc_int_new(int data); -// CHECK-EMPTY: +// CHECK-EMPTY: // CHECK: static void struct_Rc_int_D( struct Rc_int this); -// CHECK-EMPTY: +// CHECK-EMPTY: // CHECK: static struct RcData_int *memberDerefH_int( struct Rc_int * rc); -// CHECK-EMPTY: +// CHECK-EMPTY: // CHECK: static void struct_RcRecord_int_D( struct RcRecord_int this); -// CHECK-EMPTY: +// CHECK-EMPTY: // CHECK: static struct Rc_int deref_int( struct RcRecord_int *rcRecord); -// CHECK-EMPTY: +// CHECK-EMPTY: // CHECK: struct A *memberDerefA(struct AP *s) { // CHECK-NEXT: return s->a; // CHECK-NEXT: } -// CHECK-EMPTY: +// CHECK-EMPTY: // CHECK: int test1(void) { // CHECK-NEXT: struct A sa = {1}; // CHECK-NEXT: struct AP sap = {&sa}; @@ -288,11 +288,11 @@ int main(){ // CHECK-NEXT: } // CHECK-NEXT: return 0; // CHECK-NEXT: } -// CHECK-EMPTY: +// CHECK-EMPTY: // CHECK: struct B *memberDerefB(struct BP *s) { // CHECK-NEXT: return s->b; // CHECK-NEXT: } -// CHECK-EMPTY: +// CHECK-EMPTY: // CHECK: int test2(void) { // CHECK-NEXT: struct A sa = {1}; // CHECK-NEXT: struct B sb = {2, 3}; @@ -312,11 +312,11 @@ int main(){ // CHECK-NEXT: } // CHECK-NEXT: return 0; // CHECK-NEXT: } -// CHECK-EMPTY: +// CHECK-EMPTY: // CHECK: struct A * memberDerefC(struct CP * s) { // CHECK-NEXT: return s->a; // CHECK-NEXT: } -// CHECK-EMPTY: +// CHECK-EMPTY: // CHECK: int test3(void) { // CHECK-NEXT: struct A sa = {1}; // CHECK-NEXT: struct CP scp = {&sa}; @@ -330,11 +330,11 @@ int main(){ // CHECK-NEXT: } // CHECK-NEXT: return 0; // CHECK-NEXT: } -// CHECK-EMPTY: +// CHECK-EMPTY: // CHECK: struct A * memberDerefD(const struct DP * s) { // CHECK-NEXT: return s->a; // CHECK-NEXT: } -// CHECK-EMPTY: +// CHECK-EMPTY: // CHECK: int test4(void) { // CHECK-NEXT: struct A sa = {1}; // CHECK-NEXT: struct DP sdp = {&sa}; @@ -344,11 +344,11 @@ int main(){ // CHECK-NEXT: } // CHECK-NEXT: return 0; // CHECK-NEXT: } -// CHECK-EMPTY: +// CHECK-EMPTY: // CHECK: struct FP *memberDerefG(struct GP *s) { // CHECK-NEXT: return &s->fp; // CHECK-NEXT: } -// CHECK-EMPTY: +// CHECK-EMPTY: // CHECK: int test5(void) { // CHECK-NEXT: struct A sa = {1}; // CHECK-NEXT: struct FP fp = {&sa}; @@ -359,7 +359,7 @@ int main(){ // CHECK-NEXT: } // CHECK-NEXT: return 0; // CHECK-NEXT: } -// CHECK-EMPTY: +// CHECK-EMPTY: // CHECK: int test6(void) { // CHECK-NEXT: struct Rc_int rc = struct_Rc_int_new(5); // CHECK-NEXT: _Bool rc_is_moved = 0; @@ -378,7 +378,7 @@ int main(){ // CHECK-NEXT: struct_Rc_int_D(rc); // CHECK-NEXT: return 0; // CHECK-NEXT: } -// CHECK-EMPTY: +// CHECK-EMPTY: // CHECK: int test7(void) { // CHECK-NEXT: struct Rc_int rc1 = struct_Rc_int_new(5); // CHECK-NEXT: _Bool rc1_is_moved = 0; @@ -415,11 +415,11 @@ int main(){ // CHECK-NEXT: struct_Rc_int_D(rc1); // CHECK-NEXT: return 0; // CHECK-NEXT: } -// CHECK-EMPTY: +// CHECK-EMPTY: // CHECK: int main(){ // CHECK-NEXT: return test1() || test2() || test3() || test4() || test5() || test6() || test7(); // CHECK-NEXT: } -// CHECK-EMPTY: +// CHECK-EMPTY: // CHECK: static struct Rc_int struct_Rc_int_new(int data) { // CHECK-NEXT: { // CHECK-NEXT: struct RcData_int *RcDataPtr = (struct RcData_int *)malloc(sizeof(struct RcData_int)); @@ -429,20 +429,20 @@ int main(){ // CHECK-NEXT: return rc; // CHECK-NEXT: } // CHECK-NEXT: } -// CHECK-EMPTY: +// CHECK-EMPTY: // CHECK: static void struct_Rc_int_D( struct Rc_int this) { // CHECK-NEXT: _Bool this_is_moved = 0; // CHECK-NEXT: } -// CHECK-EMPTY: +// CHECK-EMPTY: // CHECK: static struct RcData_int *memberDerefH_int( struct Rc_int * rc) { // CHECK-NEXT: return rc->ptr; // CHECK-NEXT: } -// CHECK-EMPTY: +// CHECK-EMPTY: // CHECK: static void struct_RcRecord_int_D( struct RcRecord_int this) { // CHECK-NEXT: _Bool this_is_moved = 0; // CHECK-NEXT: struct_Rc_int_D(this.rc); // CHECK-NEXT: } -// CHECK-EMPTY: +// CHECK-EMPTY: // CHECK: static struct Rc_int deref_int( struct RcRecord_int *rcRecord) { // CHECK-NEXT: return rcRecord->rc; // CHECK-NEXT: }