diff --git a/api/apic/template/types.go b/api/apic/template/types.go
index 0b2b775..48bd08e 100644
--- a/api/apic/template/types.go
+++ b/api/apic/template/types.go
@@ -60,6 +60,7 @@
 		semantic.DeclareLocal{},
 		semantic.EnumEntry{},
 		semantic.Enum{},
+		semantic.Fence{},
 		semantic.Field{},
 		semantic.Function{},
 		semantic.Global{},
diff --git a/api/resolver/flow.go b/api/resolver/flow.go
new file mode 100644
index 0000000..a3f597d
--- /dev/null
+++ b/api/resolver/flow.go
@@ -0,0 +1,101 @@
+// Copyright (C) 2014 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package resolver
+
+import "android.googlesource.com/platform/tools/gpu/api/semantic"
+
+type fenceTracker struct {
+	ctx  *context
+	post bool
+}
+
+func addFence(ctx *context, block *semantic.Block) {
+	t := fenceTracker{ctx: ctx}
+	if !t.boundary(block) {
+		block.Statements = append(block.Statements, &semantic.Fence{})
+	}
+}
+
+func (t *fenceTracker) scan(n semantic.Node) {
+	switch n := n.(type) {
+	case *semantic.Block:
+		for i := 0; i < len(n.Statements); i++ {
+			s := n.Statements[i]
+			if t.boundary(s) {
+				// first post operation detected, insert fence marker here
+				n.Statements = append(n.Statements, nil)
+				copy(n.Statements[i+1:], n.Statements[i:])
+				n.Statements[i] = &semantic.Fence{}
+				// step past the newly inserted fence
+				i++
+				// Continue calling boundary() on later statements to detect post-after-pre errors.
+			}
+		}
+	case *semantic.Branch:
+		t.scan(n.Condition)
+		if t.boundary(n.True) {
+			t.ctx.errorf(n.True, "pre-post boundary in true condition")
+		}
+		if n.False != nil {
+			if t.boundary(n.False) {
+				t.ctx.errorf(n.False, "pre-post boundary in condition")
+			}
+		}
+	case *semantic.Select, *semantic.Switch, *semantic.Iteration:
+		ct := *t
+		semantic.Visit(n, t.scan)
+		if ct.post && !t.post {
+			t.post = true
+			t.ctx.errorf(n, "pre-post boundary in %T", n)
+		}
+	case *semantic.Copy:
+		semantic.Visit(n, t.scan)
+		if t.post {
+			t.ctx.errorf(n, "copy after fence")
+		}
+		t.post = true
+	case *semantic.Read:
+		semantic.Visit(n, t.scan)
+		if t.post {
+			t.ctx.errorf(n, "read after fence")
+		}
+	case *semantic.Unknown:
+		t.post = true
+	case *semantic.Write:
+		semantic.Visit(n, t.scan)
+		t.post = true
+	case *semantic.SliceIndex:
+		semantic.Visit(n, t.scan)
+		if t.post {
+			t.ctx.errorf(n, "slice index after fence")
+		}
+	case *semantic.SliceAssign:
+		semantic.Visit(n.To, t.scan)
+		t.scan(n.Value)
+		t.post = true
+	default:
+		semantic.Visit(n, t.scan)
+	}
+}
+
+func (t *fenceTracker) boundary(n semantic.Node) bool {
+	ct := *t
+	ct.scan(n)
+	if ct.post && !t.post {
+		t.post = true
+		return true
+	}
+	return false
+}
diff --git a/api/resolver/function.go b/api/resolver/function.go
index 6749c5b..bf7c082 100644
--- a/api/resolver/function.go
+++ b/api/resolver/function.go
@@ -96,6 +96,7 @@
 			}
 			out.Annotations = annotations(ctx, in.Annotations)
 			out.Block = block(ctx, in.Block, out)
+			addFence(ctx, out.Block)
 		})
 	}
 	if len(out.Docs) == 0 {
diff --git a/api/semantic/statement.go b/api/semantic/statement.go
index a127aec..5aedac8 100644
--- a/api/semantic/statement.go
+++ b/api/semantic/statement.go
@@ -94,3 +94,7 @@
 	Function *Function   // the function this statement returns from
 	Value    Expression  // the value to be returned
 }
+
+// Fence is a marker to indicate a safe point between the last read and the first write.
+// It can be used to generate safe forwarding calls.
+type Fence struct{}
diff --git a/api/semantic/visit.go b/api/semantic/visit.go
index 78e2ce4..8836b51 100644
--- a/api/semantic/visit.go
+++ b/api/semantic/visit.go
@@ -28,6 +28,9 @@
 	case *SliceIndex:
 		visitor(n.Slice)
 		visitor(n.Index)
+	case *SliceAssign:
+		visitor(n.To)
+		visitor(n.Value)
 	case *Assert:
 		visitor(n.Condition)
 	case *Assign:
@@ -111,6 +114,7 @@
 		for _, m := range n.Methods {
 			visitor(m)
 		}
+	case *Fence:
 	case *Field:
 		visitor(n.Type)
 		if n.Default != nil {
@@ -177,6 +181,7 @@
 		for _, c := range n.Choices {
 			visitor(c)
 		}
+	case StringValue:
 	case *Switch:
 		visitor(n.Value)
 		for _, c := range n.Cases {
diff --git a/gfxapi/templates/cpp_common.tmpl b/gfxapi/templates/cpp_common.tmpl
index 1c83c2f..f630e98 100644
--- a/gfxapi/templates/cpp_common.tmpl
+++ b/gfxapi/templates/cpp_common.tmpl
@@ -302,6 +302,7 @@
   {{else if IsRead      $}}read({{Macro "C++.Read" $.Slice}});
   {{else if IsWrite     $}}write({{Macro "C++.Read" $.Slice}});
   {{else if IsCopy      $}}copy({{Macro "C++.Read" $.Dst}}, {{Macro "C++.Read" $.Src}});
+  {{else if IsFence     $}}
   {{else                 }}{{Error "unsupported statement %T: %+v" $ $}}
   {{end}}
 {{end}}
diff --git a/gfxapi/templates/go_common.tmpl b/gfxapi/templates/go_common.tmpl
index f2fae84..cd2928c 100644
--- a/gfxapi/templates/go_common.tmpl
+++ b/gfxapi/templates/go_common.tmpl
@@ -300,6 +300,7 @@
   {{else if IsCall         $}}{{Macro "Go.Call" $}}
   {{else if IsRead         $}}
   {{else if IsWrite        $}}
+  {{else if IsFence        $}}
   {{else if IsBranch       $}}if {{Macro "Go.Read" $.Condition}} {
     {{Macro "Go.Block" $.True}}
     {{if len $.False.Statements}}