| {{/* |
| * Copyright (C) 2015 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. |
| */}} |
| |
| {{Global "module" ""}} |
| {{Include "go_common.tmpl"}} |
| {{$ | Macro "replay_writer.go" | GoFmt | Write "replay_writer.go"}} |
| |
| {{define "replay_writer.go"}} |
| {{template "Go.GeneratedHeader" (Global "OutputDir")}} |
| |
| import ( |
| "fmt" |
| "io" |
| "io/ioutil" |
| |
| "android.googlesource.com/platform/tools/gpu/atom" |
| "android.googlesource.com/platform/tools/gpu/binary" |
| "android.googlesource.com/platform/tools/gpu/database" |
| "android.googlesource.com/platform/tools/gpu/log" |
| "android.googlesource.com/platform/tools/gpu/memory" |
| "android.googlesource.com/platform/tools/gpu/replay/builder" |
| "android.googlesource.com/platform/tools/gpu/replay/protocol" |
| "android.googlesource.com/platform/tools/gpu/replay/value" |
| ) |
| |
| {{Global "Go.Statement.Override" "Statement"}} |
| {{Global "Go.Read.Override" "Read"}} |
| |
| type postCall []func() |
| |
| func (p *postCall) add(f func()) { |
| *p = append(*p, f) |
| } |
| |
| func (p *postCall) exec() { |
| for _, f := range *p { |
| f() |
| } |
| } |
| |
| func loadRemap(ϟb *builder.Builder, key interface{}, val value.Value) { |
| if ptr, found := ϟb.Remappings[key]; found { |
| ϟb.Load(val.Type(), ptr) |
| } else { |
| ptr = ϟb.AllocateMemory(uint64(val.Type().Size(ϟb.Architecture().PointerSize))) |
| ϟb.Push(val) // We have an input to an unknown id, use the unmapped value. |
| ϟb.Clone(0) |
| ϟb.Store(ptr) |
| ϟb.Remappings[key] = ptr |
| } |
| } |
| |
| func storeRemap(ϟb *builder.Builder, key interface{}, val value.Pointer, ty protocol.Type) { |
| if ptr, found := ϟb.Remappings[key]; !found { |
| ptr = ϟb.AllocateMemory(uint64(ty.Size(ϟb.Architecture().PointerSize))) |
| ϟb.Load(ty, val) |
| ϟb.Store(ptr) |
| ϟb.Remappings[key] = ptr |
| } |
| } |
| |
| {{Macro "DeclareBuilderFunctionInfos" $}} |
| |
| {{ForEach $.Pseudonyms "DeclarePseudonymValue" | JoinWith "\n"}} |
| |
| {{ForEach (AllCommands $) "DeclareCommandReplay" | JoinWith "\n"}} |
| |
| {{ForEach $.Pointers "PointerReplayMethods" | JoinWith "\n"}} |
| {{ForEach $.Slices "SliceReplayMethods" | JoinWith "\n"}} |
| {{end}} |
| |
| |
| {{/* |
| ------------------------------------------------------------------------------- |
| Emits the replay function for the specified command |
| ------------------------------------------------------------------------------- |
| */}} |
| {{define "DeclareCommandReplay"}} |
| {{AssertType $ "Function"}} |
| |
| {{if not (GetAnnotation $ "no_replay")}} |
| |
| {{$name := Macro "Go.CmdName" $}} |
| var _ = replay.Replayer(&{{$name}}{}) // interface compliance check |
| func (ϟa *{{$name}}) {{if GetAnnotation $ "replay_custom"}}default{{end}}Replay(§ |
| ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) { |
| ϟc := getState(ϟs) |
| ϟp := &postCall{} |
| _ = ϟc |
| |
| ϟa.observations.ApplyReads(ϟs.Memory[memory.ApplicationPool]) |
| |
| {{/* Simulate the call */}} |
| {{Macro "Go.Block" $.Block}} |
| |
| ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool]) |
| |
| {{/* Push all the parameters on the stack */}} |
| {{range $p := $.CallParameters}} |
| {{$type := TypeOf $p}} |
| {{$name := print "ϟa." (Macro "Go.Parameter" $p)}} |
| {{Macro "PushInput" "Type" $type "Name" $name}} |
| {{end}} |
| |
| {{/* Call the function */}} |
| ϟb.Call({{Macro "BuilderFunctionInfo" $}}) |
| |
| {{/* Perform post-call actions*/}} |
| ϟp.exec() |
| } |
| {{end}} |
| {{end}} |
| |
| |
| {{/* |
| ------------------------------------------------------------------------------- |
| Emits logic to push the specified input variable to the VM's stack. |
| ------------------------------------------------------------------------------- |
| */}} |
| {{define "PushInput"}} |
| {{AssertType $.Type "Type"}} |
| {{AssertType $.Name "string"}} |
| |
| {{if (GetAnnotation $.Type "replay_remap")}} |
| if key, remap := {{$.Name}}.remap(ϟa, ϟs); remap { |
| loadRemap(ϟb, key, {{Macro "Value" "Type" $.Type "Name" $.Name}}) |
| } else { |
| ϟb.Push({{Macro "Value" "Type" $.Type "Name" $.Name}}) |
| } |
| {{else}} |
| ϟb.Push({{Macro "Value" "Type" $.Type "Name" $.Name}}) |
| {{end}} |
| {{end}} |
| |
| |
| {{/* |
| ------------------------------------------------------------------------------- |
| Returns the builder.Value holding the specified variable. |
| ------------------------------------------------------------------------------- |
| */}} |
| {{define "Value"}} |
| {{AssertType $.Type "Type"}} |
| {{AssertType $.Name "string"}} |
| |
| {{if (GetAnnotation $.Type "replay_custom_value")}}{{$.Name}}.value(ϟb, ϟa, ϟs) |
| {{else if IsBool $.Type}}value.Bool({{$.Name}}) |
| {{else if IsS8 $.Type}}value.S8({{$.Name}}) |
| {{else if IsU8 $.Type}}value.U8({{$.Name}}) |
| {{else if IsS16 $.Type}}value.S16({{$.Name}}) |
| {{else if IsU16 $.Type}}value.U16({{$.Name}}) |
| {{else if IsF32 $.Type}}value.F32({{$.Name}}) |
| {{else if IsU32 $.Type}}value.U32({{$.Name}}) |
| {{else if IsS32 $.Type}}value.S32({{$.Name}}) |
| {{else if IsF64 $.Type}}value.F64({{$.Name}}) |
| {{else if IsU64 $.Type}}value.U64({{$.Name}}) |
| {{else if IsS64 $.Type}}value.S64({{$.Name}}) |
| {{else if IsInt $.Type}}value.S64({{$.Name}}) |
| {{else if IsUint $.Type}}value.U64({{$.Name}}) |
| {{else if IsString $.Type}}ϟb.String({{$.Name}}) |
| {{else if IsPointer $.Type}}{{$.Name}}.value() |
| {{else if IsEnum $.Type}}value.U32({{$.Name}}) |
| {{else if IsStaticArray $.Type}}{{$.Name}}.value(ϟb, ϟa, ϟs) |
| {{else if IsPseudonym $.Type}}{{$.Name}}.value(ϟb, ϟa, ϟs) |
| {{else if IsClass $.Type}}{{$.Name}}.value(ϟb, ϟa, ϟs) |
| {{else }}{{Error "macro Value '%v' called with unsupported type: %s" $.Name $.Type.Name}} |
| {{end}} |
| {{end}} |
| |
| |
| {{/* |
| ------------------------------------------------------------------------------- |
| Declares the value method for a given pseudonym type. |
| ------------------------------------------------------------------------------- |
| */}} |
| {{define "DeclarePseudonymValue"}} |
| {{AssertType $ "Pseudonym"}} |
| |
| {{if not (GetAnnotation $ "replay_custom_value")}} |
| {{$v := print (Macro "Go.Type" $.To) "(c)"}} |
| func (c {{$.Name}}) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Value { return {{Macro "Value" "Type" $.To "Name" $v}} } |
| {{end}} |
| {{end}} |
| |
| |
| {{/* |
| ------------------------------------------------------------------------------- |
| Declares the value method for the given static array type. |
| ------------------------------------------------------------------------------- |
| */}} |
| {{define "DeclareArrayValue"}} |
| {{AssertType $ "Array" "StaticArray"}} |
| |
| {{if not (or (Macro "IsInternal" $.ValueType) (IsAny $.ValueType))}} |
| func (arr {{Macro "Go.Type" $}}) value(ϟb *builder.Builder, ϟa atom.Atom, ϟs *gfxapi.State) value.Pointer { |
| if len(arr) > 0 { |
| for _, e := range arr { |
| {{Macro "PushInput" "Type" $.ValueType "Name" "e"}} |
| } |
| return ϟb.Buffer(len(arr)) |
| } else { |
| return value.AbsolutePointer(0) |
| } |
| } |
| {{end}} |
| {{end}} |
| |
| |
| |
| {{/* |
| ------------------------------------------------------------------------------- |
| Emits a function info definition for each of the commands. |
| ------------------------------------------------------------------------------- |
| */}} |
| {{define "DeclareBuilderFunctionInfos"}} |
| {{AssertType $ "API"}} |
| |
| {{range $i, $c := AllCommands $}} |
| var {{Macro "BuilderFunctionInfo" $c}} = builder.FunctionInfo{§ |
| ID: {{$i}},§ |
| ReturnType: {{Macro "BuilderType" $c.Return.Type}},§ |
| Parameters: {{len $c.CallParameters}},§ |
| } |
| {{end}} |
| {{end}} |
| |
| |
| {{/* |
| ------------------------------------------------------------------------------- |
| Emits the name of the variable holding the specified command's function id. |
| ------------------------------------------------------------------------------- |
| */}} |
| {{define "BuilderFunctionInfo"}}{{AssertType $ "Function"}}funcInfo{{Macro "Go.CmdName" $}}{{end}} |
| |
| |
| {{/* |
| ------------------------------------------------------------------------------- |
| Emits the replay builder type for the given command return type. |
| ------------------------------------------------------------------------------- |
| */}} |
| {{define "BuilderType"}} |
| {{AssertType $ "Type"}} |
| |
| {{ if IsPseudonym $}}{{Macro "BuilderType" $.To}} |
| {{else if IsEnum $}}protocol.TypeUint32 |
| {{else if IsBool $}}protocol.TypeBool |
| {{else if IsInt $}}protocol.TypeInt64 |
| {{else if IsUint $}}protocol.TypeUint64 |
| {{else if IsS8 $}}protocol.TypeInt8 |
| {{else if IsU8 $}}protocol.TypeUint8 |
| {{else if IsS16 $}}protocol.TypeInt16 |
| {{else if IsU16 $}}protocol.TypeUint16 |
| {{else if IsS32 $}}protocol.TypeInt32 |
| {{else if IsU32 $}}protocol.TypeUint32 |
| {{else if IsF32 $}}protocol.TypeFloat |
| {{else if IsS64 $}}protocol.TypeInt64 |
| {{else if IsU64 $}}protocol.TypeUint64 |
| {{else if IsF64 $}}protocol.TypeDouble |
| {{else if IsVoid $}}protocol.TypeVoid |
| {{else if IsString $}}protocol.TypeVolatilePointer |
| {{else if IsPointer $}}protocol.TypeVolatilePointer {{/* TODO: Might be absolute... */}} |
| {{else}}{{Error "macro BuilderType called with unsupported type: %s" $.Name}} |
| {{end}} |
| {{end}} |
| |
| |
| {{/* |
| ------------------------------------------------------------------------------- |
| An override for the "Go.Statement" macro. |
| ------------------------------------------------------------------------------- |
| */}} |
| {{define "Statement"}} |
| {{if IsRead $}} |
| {{Macro "Go.Read" $.Slice}}.onReplayRead(ϟa, ϟs, ϟd, ϟl, ϟb) |
| {{else if IsWrite $}} |
| {{Macro "Go.Read" $.Slice}}.onReplayWrite(ϟa, ϟs, ϟd, ϟl, ϟb, ϟp) |
| {{else if IsCopy $}} |
| {{Macro "Go.Read" $.Dst}}.replayCopy({{Macro "Go.Read" $.Src}}, ϟa, ϟs, ϟd, ϟl, ϟb, ϟp) |
| {{else if IsSliceAssign $}} |
| {{if ne $.Operator "="}}{{Error "Compound assignments to pointers are not supported (%s)" $.Operator}}{{end}} |
| {{Macro "Go.Read" $.To.Slice}}.Index({{Macro "Go.Read" $.To.Index}}, ϟs).replayWrite({{Macro "Go.Read" $.Value}}, ϟa, ϟs, ϟd, ϟl, ϟb, ϟp) |
| {{else}} |
| {{Macro "Go.Statement.Default" $}} |
| {{end}} |
| {{end}} |
| |
| |
| {{/* |
| ------------------------------------------------------------------------------- |
| An override for the "Go.Read" macro. |
| ------------------------------------------------------------------------------- |
| */}} |
| {{define "Read"}} |
| {{if IsSliceIndex $}} |
| {{Macro "Go.Read" $.Slice}}.Index({{Macro "Go.Read" $.Index}}, ϟs).§ |
| {{if Global "Go.InferredExpression"}} |
| replayMap(ϟa, ϟs, ϟd, ϟl, ϟb) |
| {{else}} |
| replayRead(ϟa, ϟs, ϟd, ϟl, ϟb) |
| {{end}} |
| {{else}} |
| {{Macro "Go.Read.Default" $}} |
| {{end}} |
| {{end}} |
| |
| |
| {{/* |
| ------------------------------------------------------------------------------- |
| Emits additional methods used for replay generation for the Pointer type or |
| indirect type (Pseudonym) to Pointer. |
| ------------------------------------------------------------------------------- |
| */}} |
| {{define "PointerReplayMethods"}} |
| {{AssertType $ "Pointer" "Pseudonym"}} |
| |
| {{$p := $ | Underlying | Unpack }} |
| {{$ptr_ty := Macro "Go.Type" $ }} |
| {{$el_ty := Macro "Go.Type" $p.To }} |
| {{$el_is_void := IsVoid ($p.To | Underlying | Unpack)}} |
| |
| {{if not $el_is_void}} |
| func (p {{$ptr_ty}}) replayMap(ϟa atom.Atom, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {{$el_ty}} { |
| p.Slice(0, 1, ϟs).replayMap(ϟa, ϟs, ϟd, ϟl, ϟb) |
| return p.Read(ϟs, ϟd, ϟl) |
| } |
| |
| func (p {{$ptr_ty}}) replayRead(ϟa atom.Atom, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) {{$el_ty}} { |
| p.Slice(0, 1, ϟs).onReplayRead(ϟa, ϟs, ϟd, ϟl, ϟb) |
| return p.Read(ϟs, ϟd, ϟl) |
| } |
| |
| func (p {{$ptr_ty}}) replayWrite(value {{$el_ty}}, ϟa atom.Atom, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder, ϟp *postCall) { |
| p.Write(value, ϟs) |
| p.Slice(0, 1, ϟs).onReplayWrite(ϟa, ϟs, ϟd, ϟl, ϟb, ϟp) |
| } |
| {{end}} |
| |
| func (p {{$ptr_ty}}) value() value.Pointer { |
| if p.Address != 0 { |
| return value.VolatileCapturePointer(p.Address) |
| } else { |
| return value.AbsolutePointer(0) |
| } |
| } |
| {{end}} |
| |
| |
| {{/* |
| ------------------------------------------------------------------------------- |
| Emits additional methods used for replay generation for the Slice type or |
| indirect type (Pseudonym) to Slice. |
| ------------------------------------------------------------------------------- |
| */}} |
| {{define "SliceReplayMethods"}} |
| {{AssertType $ "Slice" "Pseudonym"}} |
| |
| {{$s := $ | Underlying | Unpack }} |
| {{$slice_ty := Macro "Go.Type" $ }} |
| {{$el_ty := Macro "Go.Type" $s.To }} |
| {{$el_is_void := IsVoid ($s.To | Underlying | Unpack)}} |
| |
| func (s {{$slice_ty}}) onReplayRead(ϟa atom.Atom, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) { |
| if s.Pool == memory.ApplicationPool { |
| s.replayMap(ϟa, ϟs, ϟd, ϟl, ϟb) |
| {{if (GetAnnotation $s.To "replay_remap")}} |
| ptr, step := value.VolatileCapturePointer(s.Base), value.VolatileCapturePointer(s.ElementSize(ϟs)) |
| for _, v := range s.Read(ϟs, ϟd, ϟl) { |
| if key, remap := v.remap(ϟa, ϟs); remap { |
| loadRemap(ϟb, key, {{Macro "Value" "Type" $s.To "Name" "v"}}) |
| } else { |
| ϟb.Push({{Macro "Value" "Type" $s.To "Name" "v"}}) |
| } |
| ϟb.Store(ptr) |
| ptr += step |
| } |
| {{else}} |
| ϟb.Write(s.Range(ϟs), s.ResourceID(ϟs, ϟd, ϟl)) |
| {{end}} |
| } |
| } |
| |
| func (s {{$slice_ty}}) onReplayWrite(ϟa atom.Atom, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder, ϟp *postCall) { |
| if s.Pool == memory.ApplicationPool { |
| ϟb.MapMemory(s.Root.Range(uint64(s.Range(ϟs).End() - s.Root))) |
| {{if (GetAnnotation $s.To "replay_remap")}} |
| ϟp.add(func() { |
| ptr, step := value.VolatileCapturePointer(s.Base), value.VolatileCapturePointer(s.ElementSize(ϟs)) |
| for _, v := range s.Read(ϟs, ϟd, ϟl) { |
| if key, remap := v.remap(ϟa, ϟs); remap { |
| storeRemap(ϟb, key, ptr, {{Macro "BuilderType" $s.To}}) |
| } |
| ptr += step |
| } |
| }) |
| {{end}} |
| } |
| } |
| |
| func (s {{$slice_ty}}) replayMap(ϟa atom.Atom, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) { |
| if s.Pool == memory.ApplicationPool { |
| rng := s.Range(ϟs) |
| ϟb.MapMemory(s.Root.Range(uint64(rng.End() - s.Root))) |
| } |
| } |
| |
| {{if not $el_is_void}} |
| func (s {{$slice_ty}}) replayRead(ϟa atom.Atom, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) []{{$el_ty}} { |
| s.onReplayRead(ϟa, ϟs, ϟd, ϟl, ϟb) |
| return s.Read(ϟs, ϟd, ϟl) |
| } |
| |
| func (dst {{$slice_ty}}) replayCopy(src {{$slice_ty}}, ϟa atom.Atom, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder, ϟp *postCall) { |
| dst, src = dst.Copy(src, ϟs, ϟd, ϟl) |
| src.onReplayRead(ϟa, ϟs, ϟd, ϟl, ϟb) |
| dst.onReplayWrite(ϟa, ϟs, ϟd, ϟl, ϟb, ϟp) |
| } |
| {{end}} |
| {{end}} |
| |
