From 4e974292d4d5e91c7be554482d8ec8a2fdbbe228 Mon Sep 17 00:00:00 2001 From: Cherry Zhang Date: Fri, 15 May 2020 19:12:21 -0400 Subject: [PATCH] [dev.link] cmd/link: delete sym.Attribute Change-Id: I1a3ad5e02e9586168a0c5cd37bee37ab5b65e501 Reviewed-on: https://go-review.googlesource.com/c/go/+/234039 Run-TryBot: Cherry Zhang TryBot-Result: Gobot Gobot Reviewed-by: Than McIntosh Reviewed-by: Jeremy Faller --- src/cmd/link/internal/sym/attribute.go | 129 ------------------------- 1 file changed, 129 deletions(-) delete mode 100644 src/cmd/link/internal/sym/attribute.go diff --git a/src/cmd/link/internal/sym/attribute.go b/src/cmd/link/internal/sym/attribute.go deleted file mode 100644 index eda3fe60e4..0000000000 --- a/src/cmd/link/internal/sym/attribute.go +++ /dev/null @@ -1,129 +0,0 @@ -// Copyright 2017 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 sym - -import "sync/atomic" - -// Attribute is a set of common symbol attributes. -type Attribute int32 - -const ( - // AttrDuplicateOK marks a symbol that can be present in multiple object - // files. - AttrDuplicateOK Attribute = 1 << iota - // AttrExternal marks function symbols loaded from host object files. - AttrExternal - // AttrNoSplit marks functions that cannot split the stack; the linker - // cares because it checks that there are no call chains of nosplit - // functions that require more than StackLimit bytes (see - // lib.go:dostkcheck) - AttrNoSplit - // AttrReachable marks symbols that are transitively referenced from the - // entry points. Unreachable symbols are not written to the output. - AttrReachable - // AttrCgoExportDynamic and AttrCgoExportStatic mark symbols referenced - // by directives written by cgo (in response to //export directives in - // the source). - AttrCgoExportDynamic - AttrCgoExportStatic - // AttrSpecial marks symbols that do not have their address (i.e. Value) - // computed by the usual mechanism of data.go:dodata() & - // data.go:address(). - AttrSpecial - // AttrStackCheck is used by dostkcheck to only check each NoSplit - // function's stack usage once. - AttrStackCheck - // AttrNotInSymbolTable marks symbols that are not written to the symbol table. - AttrNotInSymbolTable - // AttrOnList marks symbols that are on some list (such as the list of - // all text symbols, or one of the lists of data symbols) and is - // consulted to avoid bugs where a symbol is put on a list twice. - AttrOnList - // AttrLocal marks symbols that are only visible within the module - // (executable or shared library) being linked. Only relevant when - // dynamically linking Go code. - AttrLocal - // AttrReflectMethod marks certain methods from the reflect package that - // can be used to call arbitrary methods. If no symbol with this bit set - // is marked as reachable, more dead code elimination can be done. - AttrReflectMethod - // AttrMakeTypelink Amarks types that should be added to the typelink - // table. See typelinks.go:typelinks(). - AttrMakeTypelink - // AttrShared marks symbols compiled with the -shared option. - AttrShared - // AttrVisibilityHidden symbols are ELF symbols with - // visibility set to STV_HIDDEN. They become local symbols in - // the final executable. Only relevant when internally linking - // on an ELF platform. - AttrVisibilityHidden - // AttrSubSymbol mostly means that the symbol appears on the Sub list of some - // other symbol. Unfortunately, it's not 100% reliable; at least, it's not set - // correctly for the .TOC. symbol in Link.dodata. Usually the Outer field of the - // symbol points to the symbol whose list it is on, but that it is not set for the - // symbols added to .windynamic in initdynimport in pe.go. - // - // TODO(mwhudson): fix the inconsistencies noticed above. - // - // Sub lists are used when loading host objects (sections from the host object - // become regular linker symbols and symbols go on the Sub list of their section) - // and for constructing the global offset table when internally linking a dynamic - // executable. - // - // TODO(mwhudson): perhaps a better name for this is AttrNonGoSymbol. - AttrSubSymbol - // AttrContainer is set on text symbols that are present as the .Outer for some - // other symbol. - AttrContainer - // AttrTopFrame means that the function is an entry point and unwinders - // should stop when they hit this function. - AttrTopFrame - // AttrReadOnly indicates whether the symbol's content (Symbol.P) is backed by - // read-only memory. - AttrReadOnly - // 19 attributes defined so far. -) - -func (a *Attribute) load() Attribute { return Attribute(atomic.LoadInt32((*int32)(a))) } - -func (a *Attribute) DuplicateOK() bool { return a.load()&AttrDuplicateOK != 0 } -func (a *Attribute) External() bool { return a.load()&AttrExternal != 0 } -func (a *Attribute) NoSplit() bool { return a.load()&AttrNoSplit != 0 } -func (a *Attribute) Reachable() bool { return a.load()&AttrReachable != 0 } -func (a *Attribute) CgoExportDynamic() bool { return a.load()&AttrCgoExportDynamic != 0 } -func (a *Attribute) CgoExportStatic() bool { return a.load()&AttrCgoExportStatic != 0 } -func (a *Attribute) Special() bool { return a.load()&AttrSpecial != 0 } -func (a *Attribute) StackCheck() bool { return a.load()&AttrStackCheck != 0 } -func (a *Attribute) NotInSymbolTable() bool { return a.load()&AttrNotInSymbolTable != 0 } -func (a *Attribute) OnList() bool { return a.load()&AttrOnList != 0 } -func (a *Attribute) Local() bool { return a.load()&AttrLocal != 0 } -func (a *Attribute) ReflectMethod() bool { return a.load()&AttrReflectMethod != 0 } -func (a *Attribute) MakeTypelink() bool { return a.load()&AttrMakeTypelink != 0 } -func (a *Attribute) Shared() bool { return a.load()&AttrShared != 0 } -func (a *Attribute) VisibilityHidden() bool { return a.load()&AttrVisibilityHidden != 0 } -func (a *Attribute) SubSymbol() bool { return a.load()&AttrSubSymbol != 0 } -func (a *Attribute) Container() bool { return a.load()&AttrContainer != 0 } -func (a *Attribute) TopFrame() bool { return a.load()&AttrTopFrame != 0 } -func (a *Attribute) ReadOnly() bool { return a.load()&AttrReadOnly != 0 } - -func (a *Attribute) CgoExport() bool { - return a.CgoExportDynamic() || a.CgoExportStatic() -} - -func (a *Attribute) Set(flag Attribute, value bool) { - // XXX it would be nice if we have atomic And, Or. - for { - a0 := a.load() - var anew Attribute - if value { - anew = a0 | flag - } else { - anew = a0 &^ flag - } - if atomic.CompareAndSwapInt32((*int32)(a), int32(a0), int32(anew)) { - return - } - } -}