I want to know methods internal working

10IN_ALL · January 12, 2024, 2:06am

I know semantics about methods
But want to know mechanics

How func structured
How method structured
Difference between both of them
How method and function calling works

mje · January 17, 2024, 4:32pm

Here are pointers to function representations at different levels of compilation, and part of the translation of a function call into machine code. You can see in the code the differences for methods.

github.com

golang/go/blob/master/src/cmd/compile/internal/syntax/nodes.go#L105


      
          		NameList []*Name
          		Type     Expr // nil means no type
          		Values   Expr // nil means no values
          		decl
          	}
          
          	// func          Name Type { Body }
          	// func          Name Type
          	// func Receiver Name Type { Body }
          	// func Receiver Name Type
          	FuncDecl struct {
          		Pragma     Pragma
          		Recv       *Field // nil means regular function
          		Name       *Name
          		TParamList []*Field // nil means no type parameters
          		Type       *FuncType
          		Body       *BlockStmt // nil means no body (forward declaration)
          		decl
          	}
          )

github.com

golang/go/blob/master/src/cmd/compile/internal/ir/func.go

// Copyright 2020 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package ir

import (
	"cmd/compile/internal/base"
	"cmd/compile/internal/types"
	"cmd/internal/obj"
	"cmd/internal/objabi"
	"cmd/internal/src"
	"fmt"
	"strings"
	"unicode/utf8"
)

// A Func corresponds to a single function in a Go program
// (and vice versa: each function is denoted by exactly one *Func).
//

This file has been truncated. show original

github.com

golang/go/blob/master/src/cmd/compile/internal/ssa/func.go

// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package ssa

import (
	"cmd/compile/internal/abi"
	"cmd/compile/internal/base"
	"cmd/compile/internal/ir"
	"cmd/compile/internal/typecheck"
	"cmd/compile/internal/types"
	"cmd/internal/obj"
	"cmd/internal/src"
	"fmt"
	"math"
	"strings"
)

// A Func represents a Go func declaration (or function literal) and its body.

This file has been truncated. show original

github.com

golang/go/blob/master/src/cmd/compile/internal/ssa/expand_calls.go#L21


      
          	"cmd/compile/internal/types"
          	"cmd/internal/src"
          	"fmt"
          )
          
          func postExpandCallsDecompose(f *Func) {
          	decomposeUser(f)    // redo user decompose to cleanup after expand calls
          	decomposeBuiltIn(f) // handles both regular decomposition and cleanup.
          }
          
          func expandCalls(f *Func) {
          	// Convert each aggregate arg to a call into "dismantle aggregate, store/pass parts"
          	// Convert each aggregate result from a call into "assemble aggregate from parts"
          	// Convert each multivalue exit into "dismantle aggregate, store/return parts"
          	// Convert incoming aggregate arg into assembly of parts.
          	// Feed modified AST to decompose.
          
          	sp, _ := f.spSb()
          
          	x := &expandState{
          		f:               f,

system · April 16, 2024, 4:32pm

This topic was automatically closed 90 days after the last reply. New replies are no longer allowed.