// genInvoke generates constraints for a dynamic method invocation. func (a *analysis) genInvoke(caller *cgnode, site *callsite, call *ssa.CallCommon, result nodeid) { if call.Value.Type() == a.reflectType { a.genInvokeReflectType(caller, site, call, result) return } sig := call.Signature() // Allocate a contiguous targets/params/results block for this call. block := a.nextNode() // pts(targets) will be the set of possible call targets site.targets = a.addOneNode(sig, "invoke.targets", nil) p := a.addNodes(sig.Params(), "invoke.params") r := a.addNodes(sig.Results(), "invoke.results") // Copy the actual parameters into the call's params block. for i, n := 0, sig.Params().Len(); i < n; i++ { sz := a.sizeof(sig.Params().At(i).Type()) a.copy(p, a.valueNode(call.Args[i]), sz) p += nodeid(sz) } // Copy the call's results block to the actual results. if result != 0 { a.copy(result, r, a.sizeof(sig.Results())) } // We add a dynamic invoke constraint that will connect the // caller's and the callee's P/R blocks for each discovered // call target. a.addConstraint(&invokeConstraint{call.Method, a.valueNode(call.Value), block}) }
// genStaticCall generates constraints for a statically dispatched function call. func (a *analysis) genStaticCall(caller *cgnode, site *callsite, call *ssa.CallCommon, result nodeid) { fn := call.StaticCallee() // Special cases for inlined intrinsics. switch fn { case a.runtimeSetFinalizer: // Inline SetFinalizer so the call appears direct. site.targets = a.addOneNode(tInvalid, "SetFinalizer.targets", nil) a.addConstraint(&runtimeSetFinalizerConstraint{ targets: site.targets, x: a.valueNode(call.Args[0]), f: a.valueNode(call.Args[1]), }) return case a.reflectValueCall: // Inline (reflect.Value).Call so the call appears direct. dotdotdot := false ret := reflectCallImpl(a, caller, site, a.valueNode(call.Args[0]), a.valueNode(call.Args[1]), dotdotdot) if result != 0 { a.addressOf(fn.Signature.Results().At(0).Type(), result, ret) } return } // Ascertain the context (contour/cgnode) for a particular call. var obj nodeid if a.shouldUseContext(fn) { obj = a.makeFunctionObject(fn, site) // new contour } else { obj = a.objectNode(nil, fn) // shared contour } a.callEdge(caller, site, obj) sig := call.Signature() // Copy receiver, if any. params := a.funcParams(obj) args := call.Args if sig.Recv() != nil { sz := a.sizeof(sig.Recv().Type()) a.copy(params, a.valueNode(args[0]), sz) params += nodeid(sz) args = args[1:] } // Copy actual parameters into formal params block. // Must loop, since the actuals aren't contiguous. for i, arg := range args { sz := a.sizeof(sig.Params().At(i).Type()) a.copy(params, a.valueNode(arg), sz) params += nodeid(sz) } // Copy formal results block to actual result. if result != 0 { a.copy(result, a.funcResults(obj), a.sizeof(sig.Results())) } }
// genDynamicCall generates constraints for a dynamic function call. func (a *analysis) genDynamicCall(caller *cgnode, site *callsite, call *ssa.CallCommon, result nodeid) { // pts(targets) will be the set of possible call targets. site.targets = a.valueNode(call.Value) // We add dynamic closure rules that store the arguments into // the P-block and load the results from the R-block of each // function discovered in pts(targets). sig := call.Signature() var offset uint32 = 1 // P/R block starts at offset 1 for i, arg := range call.Args { sz := a.sizeof(sig.Params().At(i).Type()) a.genStore(caller, call.Value, a.valueNode(arg), offset, sz) offset += sz } if result != 0 { a.genLoad(caller, result, call.Value, offset, a.sizeof(sig.Results())) } }
// Emit the code for a call to a function or builtin, which could be deferred. func emitCall(isBuiltin, isGo, isDefer bool, register string, callInfo ssa.CallCommon, errorInfo, comment string) { l := TargetLang fnToCall := "" if isBuiltin { fnToCall = callInfo.Value.(*ssa.Builtin).Name() } else if callInfo.StaticCallee() != nil { pName := "unknown" if callInfo.Signature().Recv() != nil { pName = callInfo.Signature().Recv().Type().String() // no use of Underlying() here } else { pkg := callInfo.StaticCallee().Pkg if pkg != nil { pName = pkg.Object.Name() } } fnToCall = LanguageList[l].LangName(pName, callInfo.StaticCallee().Name()) } else { // Dynamic call fnToCall = LanguageList[l].Value(callInfo.Value, errorInfo) } if isBuiltin { switch fnToCall { case "len", "cap", "append", "real", "imag", "complex": // "copy" may have the results unused if register == "" { LogError(errorInfo, "pogo", fmt.Errorf("the result from a built-in function is not used")) } else { } default: } } else { if callInfo.Signature().Results().Len() > 0 { if register == "" { LogWarning(errorInfo, "pogo", fmt.Errorf("the result from a function call is not used")) //TODO is this needed? } else { } } } // target language code must do builtin emulation text := LanguageList[l].Call(register, callInfo, callInfo.Args, isBuiltin, isGo, isDefer, fnToCall, errorInfo) fmt.Fprintln(&LanguageList[l].buffer, text+LanguageList[l].Comment(comment)) }