| Age | Commit message (Collapse) | Author | Files | Lines |
|---|
|
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/194698
From-SVN: r275691
|
|
Change Named_object::get_backend to ignore aliases when creating type
descriptors for types, to be consistent with
Type::needs_specific_type_functions and the Specific_type_functions
traversal class. For example, when compiling a package that creates an
alias to an an externally defined type, e.g.
import "foo"
type MyFoo = foo.Foo
it makes sense to skip the alias (not try to generate type specific
functions for it) and let the normal mechanisms take care of the alias
target, depending on whether the target is defined locally or defined
elsewhere.
Testcase for this problen can be found in CL 193261.
Fixes golang/go#33866.
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/191961
From-SVN: r275651
|
|
Should fix the build on riscv64 and other systems.
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/194641
From-SVN: r275650
|
|
When compiling the x_test package, force the test package to be
imported first. That ensures that we will see the types defined in
the test package before the types defined in the non-test version of
the package. This matters if the types differ in some way, such as by
adding a new method.
This avoids a failure in internal/poll on Solaris, in which the test
package adds a method to a type (FD.EOFError). I think it was Solaris-
specific because files are sorted in a different order by default.
The go tool handles this kind of thing correctly, by rebuilding
dependent packages. This is just a hack sufficient to run the libgo
testsuite without using the go tool.
Fixes https://gcc.gnu.org/PR91712
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/194637
From-SVN: r275648
|
|
Restore Solaris compatibility fixes lost when internal/x/net/lif moved
to golang.org/x/net/lif. Also fix the Makefile for x/net/lif and
x/net/route.
Change x/sys/cpu to get the cache line size from goarch.sh as the
gofrontend version of internal/cpu does.
Partially based on work by Rainer Orth.
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/194438
From-SVN: r275611
|
|
PR go/91621
mksysinfo: change test == to test =
Fixes https://gcc.gnu.org/PR91621
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/194569
From-SVN: r275608
|
|
Backport of https://golang.org/cl/194440. Original description:
If an embedded field refers to a type via a pointer, the parser needs
to know the name of the embedded field. It is possible that the
pointer type is not yet resolved. This CL fixes the parser to handle
that case by setting the pointer element type to the unresolved named
type while the pointer is being resolved.
Updates golang/go#34182
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/194562
From-SVN: r275606
|
|
Also fix the key used to store the ID.
This is a significant speedup in cmd/go run time.
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/194257
From-SVN: r275559
|
|
This relatively minor change increases the number of inlinable
functions/methods in the standard library from 983 to 2179.
In particular it permits inlining math/bits/RotateLeftNN. This
restores the speed of crypto/sha256 back to what it was before the
update to 1.13beta1.
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/194340
From-SVN: r275558
|
|
They were lost when the files were moved in the update to Go1.13beta1.
These changes should be made in the master repo for the 1.14 release,
as riscv64 support is added there.
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/194343
From-SVN: r275551
|
|
The C file has a build tag, but the procedure we use for building C
files ignores build tags.
This should fix the libgo build on non-x86 systems.
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/194378
From-SVN: r275544
|
|
For the main package we add an implicit import of the runtime package,
to ensure that it is initialized. That import used the predeclared
location, which caused various tests, notably Named_type::is_builtin,
to treat these imported names as builtin. Start using a real location,
so that those tests do the right thing.
By the way, this implicit import is a partial cause of golang/go#19773.
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/194337
From-SVN: r275540
|
|
We forgot to ever traverse types of constant expressions. This rarely
makes a difference--evidently, since nobody noticed--but it does
matter when we inline constant expressions: we need to ensure that the
type is visible to the importing code.
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/194317
From-SVN: r275539
|
|
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/193497
From-SVN: r275473
|
|
If we dot-import a package, we should only add an imported variable to
the package bindings if the variable is in the package being imported.
A test case for this is the 1.13 os package, in which ErrClosed and
friends are defined both locally and in the imported internal/oserror package.
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/192718
From-SVN: r275358
|
|
When generating write barriers, we were only checking for a notinheap
struct at the outermost struct. That mishandled the case of setting a
pointer to a notinheap struct as a field of another struct that is not
notinheap. This caused an invalid write barrier error when building
the 1.13 version of the runtime.
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/192279
From-SVN: r275240
|
|
The gc compiler has started permitting go:linkname comments with a
single argument to mean that a function should be externally visible
outside the package. Implement this in the Go frontend.
Change the libgo runtime package to use it, rather than repeating the
name just to export a function.
Remove a couple of unnecessary go:linkname comments on declarations.
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/192197
From-SVN: r275239
|
|
If we get errors during compilation, we skip the escape analysis pass.
If we are compiling the runtime package, we report an error if a bound
method expression escapes. The effect is that if we get an error
while compiling the runtime package, we would report confusing and
meaningless errors about bound method expressions escaping.
This CL stops doing that.
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/192720
From-SVN: r275238
|
|
Avoids problems with arm64 ILP32 mode. We might want to handle that
mode better in general, but always building panic32.go is simple and
fixes the build.
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/192723
From-SVN: r275237
|
|
Permit putting structs with anonymous and empty fields in the C header
file runtime.inc that is used to build the C runtime code. This is
required for upcoming 1.13 support, as the m struct has picked up an
anonymous field.
Doing this lets the C header contain all the type descriptor structs,
so start using those in the C code. This cuts the number of copies of
type descriptor definitions from 3 to 2.
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/192343
From-SVN: r275227
|
|
This is a step toward updating libgo to 1.13. This adds the 1.13
version of the osinit function to Go code, and removes the
corresponding code from the C runtime. This should simplify future updates.
Some additional 1.13 code was brought in to simplify this change.
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/191717
From-SVN: r275010
|
|
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/192037
From-SVN: r275000
|
|
This implements https://golang.org/cl/161477 in the gofrontend.
Updates golang/go#30116
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/191881
From-SVN: r274998
|
|
The Makefile was missing a dependency.
Also remove runtime.inc.raw in mostlyclean.
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/191958
From-SVN: r274956
|
|
This change extends the work in https://golang.org/cl/51131 to include
placeholder pointer types created for Go function types, which can
also be left dangling/unresolved in some instances. This fixes an
assert in Llvm_backend::materializeComposite.
Test case can be found in https://golang.org/cl/191743.
Updates golang/go#33020.
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/191744
From-SVN: r274935
|
|
Record when a local pointer variable is set to a value such that
indirecting through the pointer does not require a write barrier. Use
that to eliminate write barriers when indirecting through that local
pointer variable. Only keep this information per-block, so it's not
all that applicable.
This reduces the number of write barriers generated when compiling the
runtime package from 553 to 524.
The point of this is to eliminate a bad write barrier in the bytes
function in runtime/print.go. Mark that function nowritebarrier so
that the problem does not recur.
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/191581
From-SVN: r274890
|
|
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/191040
From-SVN: r274803
|
|
Fixes golang/go#33739
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/191037
From-SVN: r274800
|
|
Shifting by signed types is a new language feature in Go 1.13.
This requires a patch to the testsuite.
Updates golang/go#19113
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/190977
* go.test/test/fixedbugs/bug073.go: Update for language changes.
From-SVN: r274755
|
|
Add new hooks for dumping named objects, package bindings,
and top level Gogo package list.
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/190877
From-SVN: r274682
|
|
With CL 190599, along with what we do in greyobject, we ensure
that we only mark allocated heap objects. As a result we can be
more strict in GC:
- Enable "sweep increased allocation count" check, which checks
that the number of mark bits set are no more than the number of
allocation bits.
- Enable invalid pointer check on heap scan. We only trace
allocated heap objects, which should not contain invalid
pointer.
This also makes the libgo runtime more convergent with the gc
runtime.
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/190797
From-SVN: r274678
|
|
Support 0b, 0o, and hex floats.
Tested against test/literal2.go in the gc repo.
Updates golang/go#12711
Updates golang/go#19308
Updates golang/go#28493
Updates golang/go#29008
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/189718
From-SVN: r274614
|
|
When a defer is executed at most once in a function body,
we can allocate the defer record for it on the stack instead
of on the heap.
This should make defers like this (which are very common) faster.
This is a port of CL 171758 from the gc repo.
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/190410
From-SVN: r274613
|
|
In gccgo, we insert the write barriers in the frontend, and so we
cannot completely prevent write barriers on stack writes. So it
is possible for a bad pointer appearing in the write barrier
buffer. When flushing the write barrier, treat it the same as
sacnning the stack. In particular, don't mark a pointer if it
does not point to an allocated object. We already have similar
logic in greyobject. With this, hopefully, we can prevent an
unallocated object from being marked completely.
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/190599
From-SVN: r274598
|
|
The gc compiler recognizes the type runtime.hex and prints values
in this type as hex. Do the same here. This makes debugging
runtime crashes slightly better.
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/190597
From-SVN: r274591
|
|
In the channel-send case, the value to be sent may needs an
(implicit) type conversion to the channel element type. This CL
ensures that we use the correct value type for the send.
Fixes golang/go#33235.
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/187177
From-SVN: r273743
|
|
This patch is a revision to CL 185518, which added code to perform
finalization of methods on types created by the importer and not
directly reachable until inlining is done.
The original fix invoked the finalization code at the end of
Import::read_types(), but it turns out this doesn't handle the case
where a type with methods is read in due to a reference from something
later in the export data (a function or variable). The fix is to move
the import finalization call to the end of Import::import().
Testcase for this bug is in CL 187057.
Fixes golang/go#33219.
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/187058
From-SVN: r273713
|
|
The current Mark_inline_candidates helper looks only at budget when
deciding to mark a function or method as inline (with the proviso that
IR constructs not yet supported by the inliner are given artificially
high cost). This patch changes the helper to also look at whether a
function has the "go:noinline" pragma; if it does have the pragma
there is no point putting it into the export data (it will just make
the export data bigger).
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/186923
From-SVN: r273611
|
|
This patch fixes a buglet in the function body importer. Add hooks for
keeping a stack of blocks corresponding to the block nesting in the
imported function. This ensures that local variables and temps wind up
correctly scoped and don't introduce collisions.
New test case for this problem in CL 186717.
Fixes golang/go#33158.
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/186757
From-SVN: r273577
|
|
In CL 183850 a change was made to combine tracking/discovery of
exported types and imported packages during export data generation. As
a result of this refactoring a bug was introduced: the new code can
potentially insert items into the exports set (an unordered_set) while
iterating through the same set, which is illegal according to the spec
for std::unordered_set.
This patch fixes the problem by changing the type discovery phase to
iterate through a separate list of sorted exports, as opposed to
iterating through the main unordered set. Also included is a change
to fix the code that looks for variables that are referenced from
inlined routine bodies (this code wasn't scanning all of the function
that it needed to scan).
New test case for this problem in CL 186697.
Updates golang/go#33020.
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/185977
From-SVN: r273564
|
|
Currently, getg is implemented in C, which loads the thread-local
g variable. The g variable is declared static in C.
This CL exposes the g variable, so it can be accessed from the Go
side. This allows the Go compiler to inline getg calls to direct
access of g.
Currently, the actual inlining is only implemented in the gollvm
compiler. The g variable is thread-local and the compiler backend
may choose to cache the TLS address in a register or on stack. If
a thread switch happens the cache may become invalid. I don't
know how to disable the TLS address cache in gccgo, therefore
the inlining of getg is not implemented. In the future gccgo may
gain this if we know how to do it safely.
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/186238
From-SVN: r273499
|
|
The type hash and equality functions are generated after the
order_evaluations pass. They may contain shortcut operators and
Set_and_use_temporary_expressions (e.g. from lowering a
Binary_exprssion) that need to be ordered. Run order_evaluations
and remove_shortcuts on these functions. (The hash functions
may be fine, but to be on the safe side we run on them anyway.
We do need to run on the equality functions.)
A Set_and_use_temporary_expression is effectively an assignment,
so it needs to be ordered. Otherwise if we insert a temporary
statement before it, we may get wrong evaluation order.
A test case is CL 185818.
Fixes golang/go#33062.
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/185817
From-SVN: r273425
|
|
This patch changes the compiler to be more aggressive about finalizing
methods on imported types, to avoid problems with interface types that
are imported but remain unreachable until a later stage in the compilation.
The normal pattern prior to this change was that the import process would
leave imported interface types alone, and rely on Gogo::finalize_methods
to locate and finalize all interface types at a later point. This way
of doing things was not working in all cases due to the fact that we can
import an interface type that is only reachable from the body of an
inlinable function, meaning that we can't "find" the type during
the methods finalize phase.
The importer's Import::read_types() now makes a pass over all imported
types to finalize methods on any newly imported type, which takes care
of the issue.
New test case for this problem in CL 185517.
Fixes golang/go#33013
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/185518
From-SVN: r273364
|
|
CL 184998 added optimizations for one- and two-case select
statements. But it didn't handle break statement in the select
case correctly. Specifically, it didn't add the label definition,
so it could result in a dangling goto. This CL fixes this, by
adding the label definition.
A test case is CL 185520.
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/185519
From-SVN: r273359
|
|
For a select statement with zero-, one-, or two-case with a
default case, we can generate simpler code instead of calling the
generic selectgo. A zero-case select is just blocking the
execution. A one-case select is mostly just executing the case. A
two-case select with a default case is a non-blocking send or
receive. We add these special cases for lowering a select
statement.
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/184998
From-SVN: r273034
|
|
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/184997
From-SVN: r273032
|
|
Fix compiler buglet: varargs lowering happens before inlinable
function bodies are written out to export data, so set the "varargs
lowered" flag on call expressions that we import.
Fixes golang/go#32922
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/184919
From-SVN: r273026
|
|
In CL 179598, we were using Gogo::packages_, when compiling the
main package, as the list of packages of which we need to
register the type descriptors. This is not complete. It only
includes main's direct import and one-level indirect imports. It
does not include all the packages transitively imported.
To fix that, we need to track all the transitive imports. We
have almost already done that, for init functions. However, there
may be packages that don't need init functions but do need to
register type descriptors. For them, we add a dummy init function
to its export data. So when we compile the main package we will
see all the transitive imports. The dummy init functions are not
real functions and are not called.
Fixes golang/go#32901.
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/184717
From-SVN: r273009
|
|
Revamps the way the exporter tracks exported types and imported
packages that need to be mentioned in the export data.
The previous implementation wasn't properly handling the case where an
exported non-inlinable function refers to an imported type whose
method set includes an inlinable function whose body makes a call to a
function in another package that's not directly used in the original
package.
This patch integrates together two existing traversal helper classes,
"Collect_references_from_inline" and "Find_types_to_prepare" into a
single helper "Collect_export_references", so as to have common/shared
code that looks for indirectly imported packages.
Fixes golang/go#32778
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/183850
From-SVN: r272955
|
|
For zeroing a range of memory that doesn't contain pointer, we
can use builtin memset directly.
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/184438
* go-gcc.cc (Gcc_backend::Gcc_backend): Define __builtin_memset.
From-SVN: r272944
|
