src/sksl/SkSLCFGGenerator.cpp - third_party/skia - Git at Google

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */

 #include "SkSLCFGGenerator.h"

 #include "ir/SkSLConstructor.h"
 #include "ir/SkSLBinaryExpression.h"
 #include "ir/SkSLDoStatement.h"
 #include "ir/SkSLExpressionStatement.h"
 #include "ir/SkSLFieldAccess.h"
 #include "ir/SkSLForStatement.h"
 #include "ir/SkSLFunctionCall.h"
 #include "ir/SkSLIfStatement.h"
 #include "ir/SkSLIndexExpression.h"
 #include "ir/SkSLPostfixExpression.h"
 #include "ir/SkSLPrefixExpression.h"
 #include "ir/SkSLReturnStatement.h"
 #include "ir/SkSLSwizzle.h"
 #include "ir/SkSLTernaryExpression.h"
 #include "ir/SkSLVarDeclarationsStatement.h"
 #include "ir/SkSLWhileStatement.h"

 namespace SkSL {

 BlockId CFG::newBlock() {
     BlockId result = fBlocks.size();
     fBlocks.emplace_back();
     if (fBlocks.size() > 1) {
         this->addExit(fCurrent, result);
     }
     fCurrent = result;
     return result;
 }

 BlockId CFG::newIsolatedBlock() {
     BlockId result = fBlocks.size();
     fBlocks.emplace_back();
     return result;
 }

 void CFG::addExit(BlockId from, BlockId to) {
     if (from == 0 || fBlocks[from].fEntrances.size()) {
         fBlocks[from].fExits.insert(to);
         fBlocks[to].fEntrances.insert(from);
     }
 }

 void CFG::dump() {
     for (size_t i = 0; i < fBlocks.size(); i++) {
         printf("Block %d\n-------\nBefore: ", (int) i);
         const char* separator = "";
         for (auto iter = fBlocks[i].fBefore.begin(); iter != fBlocks[i].fBefore.end(); iter++) {
             printf("%s%s = %s", separator, iter->first->description().c_str(),
                    iter->second ? iter->second->description().c_str() : "<undefined>");
             separator = ", ";
         }
         printf("\nEntrances: ");
         separator = "";
         for (BlockId b : fBlocks[i].fEntrances) {
             printf("%s%d", separator, (int) b);
             separator = ", ";
         }
         printf("\n");
         for (size_t j = 0; j < fBlocks[i].fNodes.size(); j++) {
             printf("Node %d: %s\n", (int) j, fBlocks[i].fNodes[j].fNode->description().c_str());
         }
         printf("Exits: ");
         separator = "";
         for (BlockId b : fBlocks[i].fExits) {
             printf("%s%d", separator, (int) b);
             separator = ", ";
         }
         printf("\n\n");
     }
 }

 void CFGGenerator::addExpression(CFG& cfg, const Expression* e) {
     switch (e->fKind) {
         case Expression::kBinary_Kind: {
             const BinaryExpression* b = (const BinaryExpression*) e;
             switch (b->fOperator) {
                 case Token::LOGICALAND: // fall through
                 case Token::LOGICALOR: {
                     // this isn't as precise as it could be -- we don't bother to track that if we
                     // early exit from a logical and/or, we know which branch of an 'if' we're going
                     // to hit -- but it won't make much difference in practice.
                     this->addExpression(cfg, b->fLeft.get());
                     BlockId start = cfg.fCurrent;
                     cfg.newBlock();
                     this->addExpression(cfg, b->fRight.get());
                     cfg.newBlock();
                     cfg.addExit(start, cfg.fCurrent);
                     break;
                 }
                 case Token::EQ: {
                     this->addExpression(cfg, b->fRight.get());
                     this->addLValue(cfg, b->fLeft.get());
                     cfg.fBlocks[cfg.fCurrent].fNodes.push_back({
                         BasicBlock::Node::kExpression_Kind,
                         b
                     });
                     break;
                 }
                 default:
                     this->addExpression(cfg, b->fLeft.get());
                     this->addExpression(cfg, b->fRight.get());
                     cfg.fBlocks[cfg.fCurrent].fNodes.push_back({
                         BasicBlock::Node::kExpression_Kind,
                         b
                     });
             }
             break;
         }
         case Expression::kConstructor_Kind: {
             const Constructor* c = (const Constructor*) e;
             for (const auto& arg : c->fArguments) {
                 this->addExpression(cfg, arg.get());
             }
             cfg.fBlocks[cfg.fCurrent].fNodes.push_back({ BasicBlock::Node::kExpression_Kind, c });
             break;
         }
         case Expression::kFunctionCall_Kind: {
             const FunctionCall* c = (const FunctionCall*) e;
             for (const auto& arg : c->fArguments) {
                 this->addExpression(cfg, arg.get());
             }
             cfg.fBlocks[cfg.fCurrent].fNodes.push_back({ BasicBlock::Node::kExpression_Kind, c });
             break;
         }
         case Expression::kFieldAccess_Kind:
             this->addExpression(cfg, ((const FieldAccess*) e)->fBase.get());
             cfg.fBlocks[cfg.fCurrent].fNodes.push_back({ BasicBlock::Node::kExpression_Kind, e });
             break;
         case Expression::kIndex_Kind:
             this->addExpression(cfg, ((const IndexExpression*) e)->fBase.get());
             this->addExpression(cfg, ((const IndexExpression*) e)->fIndex.get());
             cfg.fBlocks[cfg.fCurrent].fNodes.push_back({ BasicBlock::Node::kExpression_Kind, e });
             break;
         case Expression::kPrefix_Kind:
             this->addExpression(cfg, ((const PrefixExpression*) e)->fOperand.get());
             cfg.fBlocks[cfg.fCurrent].fNodes.push_back({ BasicBlock::Node::kExpression_Kind, e });
             break;
         case Expression::kPostfix_Kind:
             this->addExpression(cfg, ((const PostfixExpression*) e)->fOperand.get());
             cfg.fBlocks[cfg.fCurrent].fNodes.push_back({ BasicBlock::Node::kExpression_Kind, e });
             break;
         case Expression::kSwizzle_Kind:
             this->addExpression(cfg, ((const Swizzle*) e)->fBase.get());
             cfg.fBlocks[cfg.fCurrent].fNodes.push_back({ BasicBlock::Node::kExpression_Kind, e });
             break;
         case Expression::kBoolLiteral_Kind:  // fall through
         case Expression::kFloatLiteral_Kind: // fall through
         case Expression::kIntLiteral_Kind:   // fall through
         case Expression::kVariableReference_Kind:
             cfg.fBlocks[cfg.fCurrent].fNodes.push_back({ BasicBlock::Node::kExpression_Kind, e });
             break;
         case Expression::kTernary_Kind: {
             const TernaryExpression* t = (const TernaryExpression*) e;
             this->addExpression(cfg, t->fTest.get());
             BlockId start = cfg.fCurrent;
             cfg.newBlock();
             this->addExpression(cfg, t->fIfTrue.get());
             BlockId next = cfg.newBlock();
             cfg.fCurrent = start;
             cfg.newBlock();
             this->addExpression(cfg, t->fIfFalse.get());
             cfg.addExit(cfg.fCurrent, next);
             cfg.fCurrent = next;
             break;
         }
         case Expression::kFunctionReference_Kind: // fall through
         case Expression::kTypeReference_Kind:     // fall through
         case Expression::kDefined_Kind:
             ASSERT(false);
             break;
     }
 }

 // adds expressions that are evaluated as part of resolving an lvalue
 void CFGGenerator::addLValue(CFG& cfg, const Expression* e) {
     switch (e->fKind) {
         case Expression::kFieldAccess_Kind:
             this->addLValue(cfg, ((const FieldAccess*) e)->fBase.get());
             break;
         case Expression::kIndex_Kind:
             this->addLValue(cfg, ((const IndexExpression*) e)->fBase.get());
             this->addExpression(cfg, ((const IndexExpression*) e)->fIndex.get());
             break;
         case Expression::kSwizzle_Kind:
             this->addLValue(cfg, ((const Swizzle*) e)->fBase.get());
             break;
         case Expression::kVariableReference_Kind:
             break;
         default:
             // not an lvalue, can't happen
             ASSERT(false);
             break;
     }
 }

 void CFGGenerator::addStatement(CFG& cfg, const Statement* s) {
     switch (s->fKind) {
         case Statement::kBlock_Kind:
             for (const auto& child : ((const Block*) s)->fStatements) {
                 addStatement(cfg, child.get());
             }
             break;
         case Statement::kIf_Kind: {
             const IfStatement* ifs = (const IfStatement*) s;
             this->addExpression(cfg, ifs->fTest.get());
             BlockId start = cfg.fCurrent;
             cfg.newBlock();
             this->addStatement(cfg, ifs->fIfTrue.get());
             BlockId next = cfg.newBlock();
             if (ifs->fIfFalse) {
                 cfg.fCurrent = start;
                 cfg.newBlock();
                 this->addStatement(cfg, ifs->fIfFalse.get());
                 cfg.addExit(cfg.fCurrent, next);
                 cfg.fCurrent = next;
             } else {
                 cfg.addExit(start, next);
             }
             break;
         }
         case Statement::kExpression_Kind: {
             this->addExpression(cfg, ((ExpressionStatement&) *s).fExpression.get());
             break;
         }
         case Statement::kVarDeclarations_Kind: {
             const VarDeclarationsStatement& decls = ((VarDeclarationsStatement&) *s);
             for (const auto& vd : decls.fDeclaration->fVars) {
                 if (vd.fValue) {
                     this->addExpression(cfg, vd.fValue.get());
                 }
             }
             cfg.fBlocks[cfg.fCurrent].fNodes.push_back({ BasicBlock::Node::kStatement_Kind, s });
             break;
         }
         case Statement::kDiscard_Kind:
             cfg.fBlocks[cfg.fCurrent].fNodes.push_back({ BasicBlock::Node::kStatement_Kind, s });
             cfg.fCurrent = cfg.newIsolatedBlock();
             break;
         case Statement::kReturn_Kind: {
             const ReturnStatement& r = ((ReturnStatement&) *s);
             if (r.fExpression) {
                 this->addExpression(cfg, r.fExpression.get());
             }
             cfg.fBlocks[cfg.fCurrent].fNodes.push_back({ BasicBlock::Node::kStatement_Kind, s });
             cfg.fCurrent = cfg.newIsolatedBlock();
             break;
         }
         case Statement::kBreak_Kind:
             cfg.fBlocks[cfg.fCurrent].fNodes.push_back({ BasicBlock::Node::kStatement_Kind, s });
             cfg.addExit(cfg.fCurrent, fLoopExits.top());
             cfg.fCurrent = cfg.newIsolatedBlock();
             break;
         case Statement::kContinue_Kind:
             cfg.fBlocks[cfg.fCurrent].fNodes.push_back({ BasicBlock::Node::kStatement_Kind, s });
             cfg.addExit(cfg.fCurrent, fLoopContinues.top());
             cfg.fCurrent = cfg.newIsolatedBlock();
             break;
         case Statement::kWhile_Kind: {
             const WhileStatement* w = (const WhileStatement*) s;
             BlockId loopStart = cfg.newBlock();
             fLoopContinues.push(loopStart);
             BlockId loopExit = cfg.newIsolatedBlock();
             fLoopExits.push(loopExit);
             this->addExpression(cfg, w->fTest.get());
             BlockId test = cfg.fCurrent;
             cfg.addExit(test, loopExit);
             cfg.newBlock();
             this->addStatement(cfg, w->fStatement.get());
             cfg.addExit(cfg.fCurrent, loopStart);
             fLoopContinues.pop();
             fLoopExits.pop();
             cfg.fCurrent = loopExit;
             break;
         }
         case Statement::kDo_Kind: {
             const DoStatement* d = (const DoStatement*) s;
             BlockId loopStart = cfg.newBlock();
             fLoopContinues.push(loopStart);
             BlockId loopExit = cfg.newIsolatedBlock();
             fLoopExits.push(loopExit);
             this->addStatement(cfg, d->fStatement.get());
             this->addExpression(cfg, d->fTest.get());
             cfg.addExit(cfg.fCurrent, loopExit);
             cfg.addExit(cfg.fCurrent, loopStart);
             fLoopContinues.pop();
             fLoopExits.pop();
             cfg.fCurrent = loopExit;
             break;
         }
         case Statement::kFor_Kind: {
             const ForStatement* f = (const ForStatement*) s;
             if (f->fInitializer) {
                 this->addStatement(cfg, f->fInitializer.get());
             }
             BlockId loopStart = cfg.newBlock();
             BlockId next = cfg.newIsolatedBlock();
             fLoopContinues.push(next);
             BlockId loopExit = cfg.newIsolatedBlock();
             fLoopExits.push(loopExit);
             if (f->fTest) {
                 this->addExpression(cfg, f->fTest.get());
                 BlockId test = cfg.fCurrent;
                 cfg.addExit(test, loopExit);
             }
             cfg.newBlock();
             this->addStatement(cfg, f->fStatement.get());
             cfg.addExit(cfg.fCurrent, next);
             cfg.fCurrent = next;
             if (f->fNext) {
                 this->addExpression(cfg, f->fNext.get());
             }
             cfg.addExit(next, loopStart);
             fLoopContinues.pop();
             fLoopExits.pop();
             cfg.fCurrent = loopExit;
             break;
         }
         default:
             printf("statement: %s\n", s->description().c_str());
             ABORT("unsupported statement kind");
     }
 }

 CFG CFGGenerator::getCFG(const FunctionDefinition& f) {
     CFG result;
     result.fStart = result.newBlock();
     result.fCurrent = result.fStart;
     this->addStatement(result, f.fBody.get());
     result.newBlock();
     result.fExit = result.fCurrent;
     return result;
 }

 } // namespace
	/*
	* Copyright 2016 Google Inc.
	*
	* Use of this source code is governed by a BSD-style license that can be
	* found in the LICENSE file.
	*/

	#include "SkSLCFGGenerator.h"

	#include "ir/SkSLConstructor.h"
	#include "ir/SkSLBinaryExpression.h"
	#include "ir/SkSLDoStatement.h"
	#include "ir/SkSLExpressionStatement.h"
	#include "ir/SkSLFieldAccess.h"
	#include "ir/SkSLForStatement.h"
	#include "ir/SkSLFunctionCall.h"
	#include "ir/SkSLIfStatement.h"
	#include "ir/SkSLIndexExpression.h"
	#include "ir/SkSLPostfixExpression.h"
	#include "ir/SkSLPrefixExpression.h"
	#include "ir/SkSLReturnStatement.h"
	#include "ir/SkSLSwizzle.h"
	#include "ir/SkSLTernaryExpression.h"
	#include "ir/SkSLVarDeclarationsStatement.h"
	#include "ir/SkSLWhileStatement.h"

	namespace SkSL {

	BlockId CFG::newBlock() {
	BlockId result = fBlocks.size();
	fBlocks.emplace_back();
	if (fBlocks.size() > 1) {
	this->addExit(fCurrent, result);
	}
	fCurrent = result;
	return result;
	}

	BlockId CFG::newIsolatedBlock() {
	BlockId result = fBlocks.size();
	fBlocks.emplace_back();
	return result;
	}

	void CFG::addExit(BlockId from, BlockId to) {
	if (from == 0 \|\| fBlocks[from].fEntrances.size()) {
	fBlocks[from].fExits.insert(to);
	fBlocks[to].fEntrances.insert(from);
	}
	}

	void CFG::dump() {
	for (size_t i = 0; i < fBlocks.size(); i++) {
	printf("Block %d\n-------\nBefore: ", (int) i);
	const char* separator = "";
	for (auto iter = fBlocks[i].fBefore.begin(); iter != fBlocks[i].fBefore.end(); iter++) {
	printf("%s%s = %s", separator, iter->first->description().c_str(),
	iter->second ? iter->second->description().c_str() : "<undefined>");
	separator = ", ";
	}
	printf("\nEntrances: ");
	separator = "";
	for (BlockId b : fBlocks[i].fEntrances) {
	printf("%s%d", separator, (int) b);
	separator = ", ";
	}
	printf("\n");
	for (size_t j = 0; j < fBlocks[i].fNodes.size(); j++) {
	printf("Node %d: %s\n", (int) j, fBlocks[i].fNodes[j].fNode->description().c_str());
	}
	printf("Exits: ");
	separator = "";
	for (BlockId b : fBlocks[i].fExits) {
	printf("%s%d", separator, (int) b);
	separator = ", ";
	}
	printf("\n\n");
	}
	}

	void CFGGenerator::addExpression(CFG& cfg, const Expression* e) {
	switch (e->fKind) {
	case Expression::kBinary_Kind: {
	const BinaryExpression* b = (const BinaryExpression*) e;
	switch (b->fOperator) {
	case Token::LOGICALAND: // fall through
	case Token::LOGICALOR: {
	// this isn't as precise as it could be -- we don't bother to track that if we
	// early exit from a logical and/or, we know which branch of an 'if' we're going
	// to hit -- but it won't make much difference in practice.
	this->addExpression(cfg, b->fLeft.get());
	BlockId start = cfg.fCurrent;
	cfg.newBlock();
	this->addExpression(cfg, b->fRight.get());
	cfg.newBlock();
	cfg.addExit(start, cfg.fCurrent);
	break;
	}
	case Token::EQ: {
	this->addExpression(cfg, b->fRight.get());
	this->addLValue(cfg, b->fLeft.get());
	cfg.fBlocks[cfg.fCurrent].fNodes.push_back({
	BasicBlock::Node::kExpression_Kind,
	b
	});
	break;
	}
	default:
	this->addExpression(cfg, b->fLeft.get());
	this->addExpression(cfg, b->fRight.get());
	cfg.fBlocks[cfg.fCurrent].fNodes.push_back({
	BasicBlock::Node::kExpression_Kind,
	b
	});
	}
	break;
	}
	case Expression::kConstructor_Kind: {
	const Constructor* c = (const Constructor*) e;
	for (const auto& arg : c->fArguments) {
	this->addExpression(cfg, arg.get());
	}
	cfg.fBlocks[cfg.fCurrent].fNodes.push_back({ BasicBlock::Node::kExpression_Kind, c });
	break;
	}
	case Expression::kFunctionCall_Kind: {
	const FunctionCall* c = (const FunctionCall*) e;
	for (const auto& arg : c->fArguments) {
	this->addExpression(cfg, arg.get());
	}
	cfg.fBlocks[cfg.fCurrent].fNodes.push_back({ BasicBlock::Node::kExpression_Kind, c });
	break;
	}
	case Expression::kFieldAccess_Kind:
	this->addExpression(cfg, ((const FieldAccess*) e)->fBase.get());
	cfg.fBlocks[cfg.fCurrent].fNodes.push_back({ BasicBlock::Node::kExpression_Kind, e });
	break;
	case Expression::kIndex_Kind:
	this->addExpression(cfg, ((const IndexExpression*) e)->fBase.get());
	this->addExpression(cfg, ((const IndexExpression*) e)->fIndex.get());
	cfg.fBlocks[cfg.fCurrent].fNodes.push_back({ BasicBlock::Node::kExpression_Kind, e });
	break;
	case Expression::kPrefix_Kind:
	this->addExpression(cfg, ((const PrefixExpression*) e)->fOperand.get());
	cfg.fBlocks[cfg.fCurrent].fNodes.push_back({ BasicBlock::Node::kExpression_Kind, e });
	break;
	case Expression::kPostfix_Kind:
	this->addExpression(cfg, ((const PostfixExpression*) e)->fOperand.get());
	cfg.fBlocks[cfg.fCurrent].fNodes.push_back({ BasicBlock::Node::kExpression_Kind, e });
	break;
	case Expression::kSwizzle_Kind:
	this->addExpression(cfg, ((const Swizzle*) e)->fBase.get());
	cfg.fBlocks[cfg.fCurrent].fNodes.push_back({ BasicBlock::Node::kExpression_Kind, e });
	break;
	case Expression::kBoolLiteral_Kind: // fall through
	case Expression::kFloatLiteral_Kind: // fall through
	case Expression::kIntLiteral_Kind: // fall through
	case Expression::kVariableReference_Kind:
	cfg.fBlocks[cfg.fCurrent].fNodes.push_back({ BasicBlock::Node::kExpression_Kind, e });
	break;
	case Expression::kTernary_Kind: {
	const TernaryExpression* t = (const TernaryExpression*) e;
	this->addExpression(cfg, t->fTest.get());
	BlockId start = cfg.fCurrent;
	cfg.newBlock();
	this->addExpression(cfg, t->fIfTrue.get());
	BlockId next = cfg.newBlock();
	cfg.fCurrent = start;
	cfg.newBlock();
	this->addExpression(cfg, t->fIfFalse.get());
	cfg.addExit(cfg.fCurrent, next);
	cfg.fCurrent = next;
	break;
	}
	case Expression::kFunctionReference_Kind: // fall through
	case Expression::kTypeReference_Kind: // fall through
	case Expression::kDefined_Kind:
	ASSERT(false);
	break;
	}
	}

	// adds expressions that are evaluated as part of resolving an lvalue
	void CFGGenerator::addLValue(CFG& cfg, const Expression* e) {
	switch (e->fKind) {
	case Expression::kFieldAccess_Kind:
	this->addLValue(cfg, ((const FieldAccess*) e)->fBase.get());
	break;
	case Expression::kIndex_Kind:
	this->addLValue(cfg, ((const IndexExpression*) e)->fBase.get());
	this->addExpression(cfg, ((const IndexExpression*) e)->fIndex.get());
	break;
	case Expression::kSwizzle_Kind:
	this->addLValue(cfg, ((const Swizzle*) e)->fBase.get());
	break;
	case Expression::kVariableReference_Kind:
	break;
	default:
	// not an lvalue, can't happen
	ASSERT(false);
	break;
	}
	}

	void CFGGenerator::addStatement(CFG& cfg, const Statement* s) {
	switch (s->fKind) {
	case Statement::kBlock_Kind:
	for (const auto& child : ((const Block*) s)->fStatements) {
	addStatement(cfg, child.get());
	}
	break;
	case Statement::kIf_Kind: {
	const IfStatement* ifs = (const IfStatement*) s;
	this->addExpression(cfg, ifs->fTest.get());
	BlockId start = cfg.fCurrent;
	cfg.newBlock();
	this->addStatement(cfg, ifs->fIfTrue.get());
	BlockId next = cfg.newBlock();
	if (ifs->fIfFalse) {
	cfg.fCurrent = start;
	cfg.newBlock();
	this->addStatement(cfg, ifs->fIfFalse.get());
	cfg.addExit(cfg.fCurrent, next);
	cfg.fCurrent = next;
	} else {
	cfg.addExit(start, next);
	}
	break;
	}
	case Statement::kExpression_Kind: {
	this->addExpression(cfg, ((ExpressionStatement&) *s).fExpression.get());
	break;
	}
	case Statement::kVarDeclarations_Kind: {
	const VarDeclarationsStatement& decls = ((VarDeclarationsStatement&) *s);
	for (const auto& vd : decls.fDeclaration->fVars) {
	if (vd.fValue) {
	this->addExpression(cfg, vd.fValue.get());
	}
	}
	cfg.fBlocks[cfg.fCurrent].fNodes.push_back({ BasicBlock::Node::kStatement_Kind, s });
	break;
	}
	case Statement::kDiscard_Kind:
	cfg.fBlocks[cfg.fCurrent].fNodes.push_back({ BasicBlock::Node::kStatement_Kind, s });
	cfg.fCurrent = cfg.newIsolatedBlock();
	break;
	case Statement::kReturn_Kind: {
	const ReturnStatement& r = ((ReturnStatement&) *s);
	if (r.fExpression) {
	this->addExpression(cfg, r.fExpression.get());
	}
	cfg.fBlocks[cfg.fCurrent].fNodes.push_back({ BasicBlock::Node::kStatement_Kind, s });
	cfg.fCurrent = cfg.newIsolatedBlock();
	break;
	}
	case Statement::kBreak_Kind:
	cfg.fBlocks[cfg.fCurrent].fNodes.push_back({ BasicBlock::Node::kStatement_Kind, s });
	cfg.addExit(cfg.fCurrent, fLoopExits.top());
	cfg.fCurrent = cfg.newIsolatedBlock();
	break;
	case Statement::kContinue_Kind:
	cfg.fBlocks[cfg.fCurrent].fNodes.push_back({ BasicBlock::Node::kStatement_Kind, s });
	cfg.addExit(cfg.fCurrent, fLoopContinues.top());
	cfg.fCurrent = cfg.newIsolatedBlock();
	break;
	case Statement::kWhile_Kind: {
	const WhileStatement* w = (const WhileStatement*) s;
	BlockId loopStart = cfg.newBlock();
	fLoopContinues.push(loopStart);
	BlockId loopExit = cfg.newIsolatedBlock();
	fLoopExits.push(loopExit);
	this->addExpression(cfg, w->fTest.get());
	BlockId test = cfg.fCurrent;
	cfg.addExit(test, loopExit);
	cfg.newBlock();
	this->addStatement(cfg, w->fStatement.get());
	cfg.addExit(cfg.fCurrent, loopStart);
	fLoopContinues.pop();
	fLoopExits.pop();
	cfg.fCurrent = loopExit;
	break;
	}
	case Statement::kDo_Kind: {
	const DoStatement* d = (const DoStatement*) s;
	BlockId loopStart = cfg.newBlock();
	fLoopContinues.push(loopStart);
	BlockId loopExit = cfg.newIsolatedBlock();
	fLoopExits.push(loopExit);
	this->addStatement(cfg, d->fStatement.get());
	this->addExpression(cfg, d->fTest.get());
	cfg.addExit(cfg.fCurrent, loopExit);
	cfg.addExit(cfg.fCurrent, loopStart);
	fLoopContinues.pop();
	fLoopExits.pop();
	cfg.fCurrent = loopExit;
	break;
	}
	case Statement::kFor_Kind: {
	const ForStatement* f = (const ForStatement*) s;
	if (f->fInitializer) {
	this->addStatement(cfg, f->fInitializer.get());
	}
	BlockId loopStart = cfg.newBlock();
	BlockId next = cfg.newIsolatedBlock();
	fLoopContinues.push(next);
	BlockId loopExit = cfg.newIsolatedBlock();
	fLoopExits.push(loopExit);
	if (f->fTest) {
	this->addExpression(cfg, f->fTest.get());
	BlockId test = cfg.fCurrent;
	cfg.addExit(test, loopExit);
	}
	cfg.newBlock();
	this->addStatement(cfg, f->fStatement.get());
	cfg.addExit(cfg.fCurrent, next);
	cfg.fCurrent = next;
	if (f->fNext) {
	this->addExpression(cfg, f->fNext.get());
	}
	cfg.addExit(next, loopStart);
	fLoopContinues.pop();
	fLoopExits.pop();
	cfg.fCurrent = loopExit;
	break;
	}
	default:
	printf("statement: %s\n", s->description().c_str());
	ABORT("unsupported statement kind");
	}
	}

	CFG CFGGenerator::getCFG(const FunctionDefinition& f) {
	CFG result;
	result.fStart = result.newBlock();
	result.fCurrent = result.fStart;
	this->addStatement(result, f.fBody.get());
	result.newBlock();
	result.fExit = result.fCurrent;
	return result;
	}

	} // namespace