| Age | Commit message (Collapse) | Author | Files | Lines |
|---|
|
When finalizing the methods of a named struct type, we used to
finalize all the field types first. That can fail if the field types
refer indirectly to the named type. Change it to just finalize the
embedded field types first, and the rest of the fields later.
Fixes golang/go#21253
Reviewed-on: https://go-review.googlesource.com/52570
From-SVN: r250832
|
|
Tweak Interface_field_reference_expression::do_get_backend to apply an
additional backend type conversion to the returned result. This is
needed due to the fact that the top level type of the expression is a
function descriptor, however the value being manufactured is a pointer
to <thunk-descriptor, value> struct.
Reviewed-on: https://go-review.googlesource.com/51712
From-SVN: r250686
|
|
We recently started walking through the hash table of pointer types to
finalize them. Unfortunately it is possible to create a new pointer
type while finalizing an existing one (test case: test/fixedbugs/issue5291)
and that breaks the iteration. So, instead, keep a list of
placeholder pointer types, and iterate through them while permitting
the list to be extended as we go.
Reviewed-on: https://go-review.googlesource.com/51771
From-SVN: r250683
|
|
For calls that return multiple results we used to create a temporary
of struct type to hold the results, and also create a separate
temporary for each result. Then the call expression would copy each
result out of the struct to the temporary, and Call_result_expression
would refer to the desired temporary.
Simplify this to just use a single temporary of struct type, and
change Call_result_expression to fetch a field of the struct.
This may reduce some incorrect tree sharing in the backend code.
Reviewed-on: https://go-review.googlesource.com/51770
From-SVN: r250682
|
|
* go-backend.c (go_write_export_data): Use EXCLUDE section for
AIX.
From-SVN: r250648
|
|
Patch by Uros Bizjak.
Reviewed-on: https://go-review.googlesource.com/51370
From-SVN: r250588
|
|
Add a new helper routine Type::finish_pointer_types that walks through
the pointer type cache and looks for placeholder types that may have
been created at some point before conversion of named types, and
invokes Type::finish_backend() on said placeholders. This is needed
to handle cases where the compiler manufactures a pointer type as part
of lowering, then a placeholder is created for it due to a call to
Type::backend_type_size(), but there is no explicit reference to the
type in user code.
Reviewed-on: https://go-review.googlesource.com/51131
From-SVN: r250548
|
|
We unconditionally set _FILE_OFFSET_BITS to 64 in configure.ac, so we
should unconditionally call the statfs64 and fstatfs64 functions.
These functions should be available on all versions of GNU/Linux since 2.6.
On 64-bit systems they are aliased to statfs/fstatfs, and on 32-bit
systems they use the 64-bit data structures.
Fixes golang/go#20922
Reviewed-on: https://go-review.googlesource.com/50635
From-SVN: r250443
|
|
If getSiginfo does not know how to determine the PC, it will call
runtime_callers. That can happen in a thread that was started by
non-Go code, in which case the TLS variable g will not be set, in
which case runtime_lock will crash.
Avoid the problem by using atomic operations for the lock. This is OK
since creating a backtrace state is fast and never blocks.
The test case is TestCgoExternalThreadSIGPROF in the runtime package
on a system that getSiginfo doesn't handle specially.
Updates golang/go#20931
Reviewed-on: https://go-review.googlesource.com/50650
From-SVN: r250439
|
|
Updates golang/go#20931
Reviewed-on: https://go-review.googlesource.com/50631
From-SVN: r250436
|
|
Allocate enough stack space so that the test will work on a system
that does not support split stacks.
This test is actually not very meaningful for gccgo at present, but it
doesn't hurt to keep running it.
Updates golang/go#20931
Reviewed-on: https://go-review.googlesource.com/50630
From-SVN: r250433
|
|
The current recipe in Type_guard_expression for creating a Bexpression
performs a type conversion at the Type level, but doesn't invoke
Backend::convert_expression to capture the conversion for the back
end. Add code to create a BE type conversion operation.
Reviewed-on: https://go-review.googlesource.com/50373
From-SVN: r250400
|
|
In Func_expression::do_get_backend when creating the backend
representation for a closure, create a backend type conversion to
account for potential differences between the closure struct type
(where the number of fields is dependent on the number of values
referenced in the closure) and the generic function descriptor type
(struct with single function pointer field).
Reviewed-on: https://go-review.googlesource.com/49255
From-SVN: r250327
|
|
futex.h:13:12: error: expected ‘=’, ‘,’, ‘;’, ‘asm’ or ‘__attribute__’ before ‘long’)
PR go/81451
runtime: inline runtime_osinit
We had two identical copies of runtime_osinit. They set runtime_ncpu,
a variable that is no longer used. Removing that leaves us with two lines.
Inline those two lines in the two places the function was called.
This fixes GCC PR 81451.
Reviewed-on: https://go-review.googlesource.com/48862
From-SVN: r250326
|
|
The code in Named_type::do_get_backend was not passing the correct
flag value for circular function types to Backend::circular_pointer_type
(it was always setting this flag to false). Pass a true value if the
type being converted is a function type.
Reviewed-on: https://go-review.googlesource.com/49330
From-SVN: r250325
|
|
PR go/81324
sysinfo.c: ignore ptrace_peeksiginfo_args from <linux/ptrace.h>
With some versions of glibc and GNU/Linux ptrace_pseeksiginfo_args is
defined in both <sys/ptrace.h> and <linux/ptrace.h>. We don't actually
care about the struct, so use a #define to avoid a redefinition error.
This fixes https://gcc.gnu.org/PR81324.
Reviewed-on: https://go-review.googlesource.com/49290
From-SVN: r250324
|
|
https://gcc.gnu.org/PR81449 reports a problem with the definition semt
in runtime.inc on some systems. Since the C code in libgo/runtime
doesn't need semt, just don't copy it into runtime.inc.
Reviewed-on: https://go-review.googlesource.com/48593
From-SVN: r250217
|
|
Don't assume that all (or only) 386/amd64 compilers support
-fsplit-stack.
Reviewed-on: https://go-review.googlesource.com/48592
From-SVN: r250216
|
|
against recent glibc)
PR go/81393
syscall: don't use GETREGS/SETREGS on s390
They were removed in recent glibc.
Patch by Andreas Krebbel for GCC PR 81393.
Reviewed-on: https://go-review.googlesource.com/48231
From-SVN: r250174
|
|
This test is not yet run, but it will be soon.
Reviewed-on: https://go-review.googlesource.com/47038
From-SVN: r249795
|
|
The tests are misc/cgo tests that are not currently run but will be
run soon.
Reviewed-on: https://go-review.googlesource.com/47037
From-SVN: r249794
|
|
On AIX:
* mmap does not allow to map an already mapped range,
* mmap range start at 0x30000000 for 32 bits processes,
* mmap range start at 0x70000000_00000000 for 64 bits processes
This is adapted from change 37845.
Issue golang/go#19200
Reviewed-on: https://go-review.googlesource.com/46772
From-SVN: r249713
|
|
Fixes required now that we #include <linux/ptrace.h> in sysinfo.c.
Patch by Andreas Krebbel.
Reviewed-on: https://go-review.googlesource.com/46839
From-SVN: r249712
|
|
Copy all the misc/cgo files from the gc toolchain into libgo/misc.
These will be used for testing purposes by later changes to the
gotools directory.
Reviewed-on: https://go-review.googlesource.com/46721
From-SVN: r249674
|
|
It's now defined by mksysinfo.sh.
Patch by Uros Bizjak.
Reviewed-on: https://go-review.googlesource.com/46712
From-SVN: r249663
|
|
Avoid https://sourceware.org/bugzilla/show_bug.cgi?id=762.
Patch by Andreas Schwab.
Reviewed-on: https://go-review.googlesource.com/46711
From-SVN: r249662
|
|
When C code calls a Go function, it actually calls a function
generated by cgo. That function is written in Go, and, among other
things, it calls the real Go function like this:
CgocallBack()
defer CgocallBackDone()
RealGoFunction()
The deferred CgocallBackDone function enters syscall mode as we return
to C. Typically the C function will then eventually return to Go.
However, in the case where the C function is running on a thread
created in C, it will not return to Go. For that case we will have
allocated an m struct, with an associated g struct, for the duration
of the Go code, and when the Go is complete we will return the m and g
to a free list.
That all works, but we are running in a deferred function, which means
that we have been invoked by deferreturn, and deferreturn expects to
do a bit of cleanup to record that the defer has been completed. Doing
that cleanup while using an m and g that have already been returned to
the free list is clearly a bad idea. It was kind of working because
deferreturn was holding the g pointer in a local variable, but there
were races with some other thread picking up and using the newly freed g.
It was also kind of working because of a special check in freedefer;
that check is no longer necessary.
This patch changes the special case of releasing the m and g to do the
defer cleanup in CgocallBackDone itself.
This patch also checks for the special case of a panic through
CgocallBackDone. In that special case, we don't want to release the m
and g. Since we are returning to C code that was not called by Go
code, we know that the panic is not going to be caught and we are
going to exit the program. So for that special case we keep the m and
g structs so that the rest of the panic code can use them.
Reviewed-on: https://go-review.googlesource.com/46530
From-SVN: r249611
|
|
Reviewed-on: https://go-review.googlesource.com/46590
From-SVN: r249609
|
|
Backport https://golang.org/cl/46511 from gc trunk, as it may fix a
bug reported for gccgo running on MIPS
(https://groups.google.com/d/msg/golang-dev/sDg-t1_DPw0/-AJmLxgPBQAJ).
Reviewed-on: https://go-review.googlesource.com/46571
From-SVN: r249599
|
|
The kickoff function for g0 can be invoked without a p, for example
from mcall(exitsyscall0) in exitsyscall after exitsyscall has cleared
the p field. The assignment gp.param = nil will invoke a write barrier.
If gp.param is not already nil, this will require a p. Avoid the problem
for a specific case that is known to be OK: when the value in gp.param
is a *g.
Reviewed-on: https://go-review.googlesource.com/46512
From-SVN: r249595
|
|
Implement go:notinheap as the gc compiler does. A type marked as
go:notinheap may not live in the heap, and does not require a write
barrier. Struct and array types that incorporate notinheap types are
themselves notinheap. Allocating a value of a notinheap type on the
heap is an error.
This is not just an optimization. There is code where a write barrier
may not occur that was getting a write barrier with gccgo but not gc,
because the types in question were notinheap. The case I found was
setting the mcache field in exitsyscallfast.
Reviewed-on: https://go-review.googlesource.com/46490
From-SVN: r249594
|
|
When a panic occurs while processing a deferred function that
recovered an earlier panic, we shouldn't report the recovered panic
in the panic stack trace. Stop doing so by keeping track of the panic
that triggered a defer, marking it as aborted if we see the defer again,
and discarding aborted panics when a panic is recovered. This is what
the gc runtime does.
The test for this is TestRecursivePanic in runtime/crash_test.go.
We don't run that test yet, but we will soon.
Reviewed-on: https://go-review.googlesource.com/46461
From-SVN: r249590
|
|
Now that systemstack changes to the g0 stack, this check passes.
Reviewed-on: https://go-review.googlesource.com/46460
From-SVN: r249578
|
|
The CgocallbackDone function calls dropm after it calls entersyscall,
which means that dropm must not have any write barriers. Mark it
accordingly.
Reviewed-on: https://go-review.googlesource.com/46464
From-SVN: r249577
|
|
Use go:linkname to export the getm function. This makes it visible to
runtime/testdata/testprogcgo/dropm_stub.go, which uses it as part of
the TestEnsureDropM test in runtime/crash_cgo_test.go. That test is
not run today, but it will be soon.
Reviewed-on: https://go-review.googlesource.com/46462
From-SVN: r249576
|
|
Patch from Rainer Orth.
Reviewed-on: https://go-review.googlesource.com/46459
From-SVN: r249575
|
|
In libgo system goroutines register themselves after they start.
That means that there is a small race between the goroutine being
seen by the scheduler and the scheduler knowing that the goroutine
is a system goroutine. That in turn means that runtime.NumGoroutines
can overestimate the number of goroutines at times.
This patch fixes the overestimate by counting the number of system
goroutines waiting to start, and pausing NumGoroutines until those
goroutines have all registered.
This is kind of a lot of mechanism for this not very important
problem, but I couldn't think of a better approach.
The test for this is TestNumGoroutine in runtime/proc_test.go.
The test is not currently run, but it will be soon.
Reviewed-on: https://go-review.googlesource.com/46457
From-SVN: r249565
|
|
Remove stale comment in code that accepts "go:nowritebarrier"
pragma. Update comment for "go:nowritebarrierrec".
Reviewed-on: https://go-review.googlesource.com/46416
From-SVN: r249564
|
|
With the gc toolchain apparently
var s *string
_ = *s
is enough to panic with a nil pointer dereference. The gccgo compiler
will simply discard the dereference, which I think is a reasonable and
acceptable optimization. Change the tests to use an exported variable
instead. The tests are not currently run, but they will be with a
later patch to gotools.
Reviewed-on: https://go-review.googlesource.com/46450
From-SVN: r249562
|
|
Because of how gccgo implements cgo calls, the code in dropm may not
have any write barriers. As a step toward implementing that, change
the gcstack, gcnextsegment, and gcnextsp fields of the g struct to
uintptr, so that assignments to them do not require write barriers.
The gcinitialsp field remains unsafe.Pointer, as on 32-bit systems
that do not support split stack it points to a heap allocated space
used for the goroutine stack.
The test for this is runtime tests like TestCgoCallbackGC, which are
not run today but will be run with a future gotools patch.
Reviewed-on: https://go-review.googlesource.com/46396
From-SVN: r249561
|
|
Calling a deferred function currently requires changing from a uintptr
to the function code to a Go function value. That is done by setting
the value of a func local variable using unsafe.Pointer. The local
variable will always be on the stack. Adjust the code that sets the
local variable to avoid generating a write barrier.
A write barrier is never needed here. Also, for deferreturn, we must
avoid write barriers entirely when called from a cgo function; that
requires more than just this, but this is a start.
The test for this is runtime tests that use the go tool; these are not
currently run, but they will be in the future.
Reviewed-on: https://go-review.googlesource.com/46455
From-SVN: r249559
|
|
The gc version of the _defer struct has a _panic field that has a
completely different meaning. We are going to want that bring that new
meaning into the gofrontend to improve panic reports with nested
panic calls. Simplify that by first renaming the existing _panic field.
Reviewed-on: https://go-review.googlesource.com/46454
From-SVN: r249558
|
|
- don't run tests that depend on SetCgoTraceback
- don't expect a '(' after the function name in a traceback
- change the expected name of nested functions in a traceback
These tests are not currently run, but they will be soon.
Reviewed-on: https://go-review.googlesource.com/46453
From-SVN: r249557
|
|
The gofrontend doesn't support the runtime.SetCgoTraceback function,
which is specifically for handling mixed Go and C tracebacks.
Use a build tag to avoid compiling the runtime/testdata/testprogcgo
files that refer to SetCgoTraceback. These files are not currently
compiled anyhow, but they will be with a future gotools patch.
Reviewed-on: https://go-review.googlesource.com/46452
From-SVN: r249556
|
|
Building this test with gccgo requires an explicit -pthread option to
be passed to the C compiler, so that it links against -lpthread.
This test is not built today, but it will be soon with a future patch.
Reviewed-on: https://go-review.googlesource.com/46451
From-SVN: r249555
|
|
The gc toolchain does the same thing, in gentraceback in
runtime/traceback.go.
The test for this is TestPanicTraceback in runtime/crash_test.go. We
don't yet run that test, but we will in a future change.
Reviewed-on: https://go-review.googlesource.com/46397
From-SVN: r249495
|
|
The test for this is TestGoNil in the runtime package, which we don't
run yet but will run with a subsequent gotools patch.
Updates golang/go#8045
Reviewed-on: https://go-review.googlesource.com/46392
From-SVN: r249494
|
|
Patch by Uros Bizjak.
Reviewed-on: https://go-review.googlesource.com/46391
From-SVN: r249487
|
|
Update the code in Array_type::get_value_pointer that handles
"lvalue" context to look for both regular var expressions
and temp var expressions, since both can appear in array/slice
index expressions on the left hand side of assignments.
Reviewed-on: https://go-review.googlesource.com/46170
From-SVN: r249486
|
|
This removes the old names for the 3 main MIPS ABIs: mipso32, mipsn32
and mipsn64. It also removes the mipso64 ABI which has no equivalent
architecture name in go. This ABI has been dead for sometime and I doubt
anyone will miss it.
Reviewed-on: https://go-review.googlesource.com/46154
From-SVN: r249477
|
