| Age | Commit message (Collapse) | Author | Files | Lines |
|---|
|
2014-11-05 Dominik Vogt <vogt@linux.vnet.ibm.com>
* libgo/runtime/runtime.c (runtime_cputicks): s390: use stckf
unconditionally
From-SVN: r217195
|
|
From Dominik Vogt.
* libgo/go/syscall/libcall_linux_s390.go: New file for s390 support.
* libgo/go/syscall/syscall_linux_s390.go: Ditto.
* libgo/go/syscall/libcall_linux_s390x.go: New file for s390x support.
* libgo/go/syscall/syscall_linux_s390x.go: Ditto.
* libgo/go/runtime/pprof/pprof.go (printStackRecord): Support s390 and
s390x.
* libgo/runtime/runtime.c (runtime_cputicks): Add support for s390 and
s390x
* libgo/mksysinfo.sh: Ditto.
(upcase_fields): New helper function
* libgo/go/debug/elf/file.go (applyRelocations): Implement relocations
on s390x.
(applyRelocationsS390x): Ditto.
(DWARF): Ditto.
* libgo/go/debug/elf/elf.go (R_390): New constants for S390 relocations.
(r390Strings): Ditto.
(String): Helper function for S390 relocations.
(GoString): Ditto.
* libgo/go/reflect/makefuncgo_s390.go: New file.
(S390MakeFuncStubGo): Implementation of s390 abi.
* libgo/go/reflect/makefuncgo_s390x.go: New file.
(S390xMakeFuncStubGo): Implementation of s390x abi.
* libgo/go/reflect/makefunc_s390.c: New file.
(makeFuncStub): s390 and s390x specific implementation of function.
* libgo/go/reflect/makefunc.go
(MakeFunc): Add support for s390 and s390x.
(makeMethodValue): Ditto.
(makeValueMethod): Ditto.
* libgo/Makefile.am (go_reflect_makefunc_s_file): Ditto.
(go_reflect_makefunc_file): Ditto.
* libgo/go/reflect/makefunc_dummy.c: Ditto.
* libgo/runtime/runtime.h (__go_makefunc_can_recover): Export prototype
for use in makefunc_s390.c.
(__go_makefunc_returning): Ditto.
* libgo/go/syscall/exec_linux.go (forkAndExecInChild): Fix order of the
arguments of the clone system call for s390[x].
* libgo/configure.ac (is_s390): New variable.
(is_s390x): Ditto
(LIBGO_IS_S390): Ditto.
(LIBGO_IS_S390X): Ditto.
(GOARCH): Support s390 and s390x.
* libgo/go/go/build/build.go (cgoEnabled): Ditto.
* libgo/go/go/build/syslist.go (goarchList): Ditto.
From-SVN: r217106
|
|
From-SVN: r216746
|
|
From-SVN: r216490
|
|
We want to create goroutines with a small stack, at least on
systems where split stacks are supported. We don't need to
create threads with a small stack.
From-SVN: r216353
|
|
PR go/60406
runtime: Check callers in can_recover if return address doesn't match.
Also use __builtin_extract_return_address and tighten up the
checks in FFI code.
Fixes PR 60406.
From-SVN: r216003
|
|
Fixes issue 38.
From-SVN: r215832
|
|
If the compiler inlines this function into kickoff, it may reuse
the TLS block address to load g. However, this is not necessarily
correct, as the call to g->entry in kickoff may cause the TLS
address to change. If the wrong value is loaded for g->status in
runtime_goexit, it may cause a runtime panic.
By marking the function as noinline we prevent the compiler from
reusing the TLS address.
From-SVN: r215484
|
|
From-SVN: r215423
|
|
From-SVN: r214965
|
|
* go-gcc.cc (Gcc_backend::implicit_variable): Remove init
parameter. Add is_hidden parameter.
(Gcc_backend::implicit_variable_set_init): New method.
(Gcc_backend::implicit_variable_reference): New method.
From-SVN: r214894
|
|
From-SVN: r214048
|
|
The Go frontend passes closures through to functions using the
functions __go_set_closure and __go_get_closure. The
expectation is that there are no function calls between
set_closure and get_closure. However, it turns out that there
can be function calls if some of the function arguments
require type conversion to an interface type. Converting to
an interface type can allocate memory, and that can in turn
trigger a garbage collection, and that can in turn call pool
cleanup functions that may call __go_set_closure. So the
called function can see the wrong closure value, which is bad.
This patch fixes the problem in two different ways. First, we
move all type conversions in function arguments into temporary
variables so that they can not appear before the call to
__go_set_closure. (This required shifting the flatten phase
after the simplify_thunk phase, since the latter expects to
work with unconverted argument types.) Second, we fix the
memory allocation function to preserve the closure value
across any possible garbage collection.
A test case is the libgo database/sql check run with the
environment variable GOGC set to 1.
From-SVN: r213932
|
|
Based on patch from Rainer Orth.
From-SVN: r213599
|
|
PR other/61895
runtime: Ignore small argv[0] file for backtrace.
Reportedly in some cases Docker starts processes with argv[0]
pointing to an empty file. That would cause libgo to pass
that empty file to libbacktrace, which would then fail to do
any backtraces. Everything should work fine if libbacktrace
falls back to /proc/self/exe.
This patch to libgo works around the problem by ignoring
argv[0] if it is a small file, or if stat fails. This is not
a perfect fix but it's an unusual problem.
From-SVN: r213513
|
|
From-SVN: r212862
|
|
Keep using the existing 386 and amd64 code on those archs,
since it is more efficient.
From-SVN: r212853
|
|
From-SVN: r212837
|
|
This revision renames several files in the runtime directory
from .c to .goc.
From-SVN: r212472
|
|
Rename in order to avoid confusion with the new
runtime/iface.goc file in the Go library master sources.
From-SVN: r212447
|
|
The flags were used by the reflect package in the past, but
not for a couple of years now.
From-SVN: r212446
|
|
PR go/61620
runtime: Don't free tiny blocks in map deletion.
The memory allocator now has a special case for tiny blocks
(smaller than 16 bytes) and they can not be explicitly freed.
From-SVN: r212233
|
|
PR go/52583
runtime: Stop backtrace at a few recognized functions.
On x86_64 Solaris the makecontext function does not properly
indicate that it is at the top of the stack. Attempting to
unwind the stack past a call to makecontext tends to crash.
This patch changes libgo to look for certain functions that
are always found at the top of the stack, and to stop
unwinding when it reaches one of those functions. There is
never anything interesting past these functions--that is,
there is never any code written by the user.
From-SVN: r211640
|
|
PR go/61498
runtime: Always set gcnext_sp to pointer-aligned address.
The gcnext_sp field is only used on systems that do not use
split stacks. It marks the bottom of the stack for the
garbage collector. This change makes sure that the stack
bottom is always aligned to a pointer value.
Previously the garbage collector would align all the addresses
that it scanned, but it now expects them to be aligned before
scanning.
From-SVN: r211639
|
|
From-SVN: r211394
|
|
The next revision, 19185, renames several runtime files, and
will be handled in a separate change.
From-SVN: r211328
|
|
This revision was committed January 7, 2014. The next
revision deleted runtime/mfinal.c. That will be done in a
subsequent merge.
This merge changes type descriptors to add a zero field,
pointing to a zero value for that type. This is implemented
as a common variable.
* go-gcc.cc (Gcc_backend::implicit_variable): Add is_common and
alignment parameters. Permit init parameter to be NULL.
From-SVN: r211249
|
|
Based on a patch from Peter Collingbourne.
From-SVN: r211081
|
|
LLVM's code generator does not currently support split stacks for vararg
functions, so we disable split stacks for the only function that uses this
feature under Clang. This appears to be OK as long as:
- this function only calls non-inlined, internal-linkage (hence no dynamic
loader) functions compiled with split stacks (i.e. go_vprintf), which can
allocate more stack space as required;
- this function itself does not occupy more than BACKOFF bytes of stack space
(see libgcc/config/i386/morestack.S).
These conditions are currently known to be satisfied by Clang on x86-32 and
x86-64. Note that signal handlers receive slightly less stack space than they
would normally do if they happen to be called while this function is being
run. If this turns out to be a problem we could consider increasing BACKOFF.
From-SVN: r211037
|
|
This includes the use of __complex and __builtin_ functions where
unprefixed entities would suffice, and the use of a union for
bit-casting between types.
From-SVN: r211036
|
|
Result of runtime_write is ignored, causing
an unused-result result warning (error in my
case, with -Werror=unused-result).
From-SVN: r210987
|
|
PR go/60931
runtime: Fix garbage collector issue with non 4kB system page size
The go garbage collector tracks memory in terms of 4kB pages.
Most of the code checks getpagesize() at runtime and does the
right thing.
On a 64kB ppc64 box I see SEGVs in long running processes
which has been diagnosed as a bug in scavengelist.
scavengelist does a madvise(MADV_DONTNEED) without rounding
the arguments to the system page size. A strace of one of the
failures shows the problem:
madvise(0xc211030000, 4096, MADV_DONTNEED) = 0
The kernel rounds the length up to 64kB and we mark 60kB of
valid data as no longer needed.
Round start up to a system page and end down before calling
madvise.
From-SVN: r209777
|
|
From Rainer Orth.
From-SVN: r209448
|
|
user: Ian Lance Taylor <iant@golang.org>
date: Thu Apr 10 09:25:24 2014 -0700
files: go/expressions.cc
description:
compiler: add checks for constant overflow
Prevent extremely large constants from eating all of memory.
user: Chris Manghane <cmang@golang.org>
date: Mon Apr 07 16:57:09 2014 -0700
files: go/gogo-tree.cc go/gogo.cc go/gogo.h go/statements.cc
description:
compiler: Use backend interface for variable initialization.
user: Chris Manghane <cmang@golang.org>
date: Thu Apr 03 19:56:05 2014 -0700
files: go/backend.h go/gogo-tree.cc go/gogo.cc go/gogo.h
description:
compiler: Use backend interface to build function code.
changeset: 1269:6e30875d539e
user: Chris Manghane <cmang@golang.org>
date: Wed Apr 02 13:16:00 2014 -0700
files: go/backend.h go/gogo-tree.cc go/gogo.cc go/gogo.h
description:
compiler: Use backend interface for building function defer wrappers.
user: Chris Manghane <cmang@golang.org>
date: Mon Mar 31 12:42:49 2014 -0700
files: go/expressions.cc go/gogo-tree.cc go/gogo.cc go/gogo.h
description:
compiler: Use backend interface for memory allocation.
user: Chris Manghane <cmang@golang.org>
date: Thu Mar 27 14:22:49 2014 -0700
files: go/backend.h go/expressions.cc go/expressions.h
description:
compiler: Use backend interface for fixed array construction.
user: Chris Manghane <cmang@golang.org>
date: Mon Mar 17 21:25:04 2014 -0700
files: go/expressions.cc
description:
compiler: Check for loops in self-referential array types. Fixes issue 7525.
user: Chris Manghane <cmang@golang.org>
date: Mon Mar 17 14:31:59 2014 -0700
files: go/gogo.cc go/parse.cc
description:
compiler: Don't declare blank labels. Fixes issue 7539.
user: Chris Manghane <cmang@golang.org>
date: Mon Mar 17 13:12:32 2014 -0700
files: go/backend.h go/expressions.cc go/expressions.h go/runtime.def
description:
compiler: Use backend interface for call expressions.
user: Chris Manghane <cmang@golang.org>
date: Wed Mar 12 13:34:27 2014 -0700
files: go/expressions.cc go/expressions.h go/gogo-tree.cc go/statements.cc
description:
compiler: Use backend interface map construction.
user: Chris Manghane <cmang@golang.org>
date: Tue Mar 11 12:53:06 2014 -0700
files: go/backend.h go/expressions.cc go/gogo-tree.cc go/gogo.h
description:
compiler: Use backend interface for string expressions.
user: Chris Manghane <cmang@golang.org>
date: Sat Mar 08 15:56:59 2014 -0800
files: go/backend.h go/expressions.cc go/expressions.h
description:
compiler: Use backend interface for array and string indexing.
user: Chris Manghane <cmang@golang.org>
date: Fri Mar 07 16:02:18 2014 -0800
files: go/expressions.cc
description:
compiler: Use backend interface for constant expressions.
user: Chris Manghane <cmang@golang.org>
date: Thu Mar 06 16:00:18 2014 -0800
files: go/expressions.cc
description:
compiler: Use backend interface for struct construction.
user: Chris Manghane <cmang@golang.org>
date: Wed Mar 05 13:09:37 2014 -0800
files: go/expressions.cc
description:
compiler: Use backend interface for type conversions.
user: Chris Manghane <cmang@golang.org>
date: Tue Mar 04 07:03:47 2014 -0800
files: go/expressions.cc go/expressions.h go/gogo-tree.cc go/gogo.h go/runtime.def libgo/runtime/chan.c
description:
compiler: Use backend interface for channel receive.
user: Chris Manghane <cmang@golang.org>
date: Mon Mar 03 15:18:57 2014 -0800
files: go/backend.h go/expressions.cc go/runtime.def
description:
compiler: Use backend interface for builtin calls.
user: Chris Manghane <cmang@golang.org>
date: Mon Mar 03 07:44:35 2014 -0800
files: go/expressions.cc go/expressions.h go/types.cc go/types.h
description:
compiler: Use backend interface for string info.
user: Chris Manghane <cmang@golang.org>
date: Fri Feb 28 10:45:55 2014 -0800
files: go/expressions.cc go/expressions.h go/gogo-tree.cc go/statements.cc
description:
compiler: Use backend interface for map indexing.
user: Chris Manghane <cmang@golang.org>
date: Wed Feb 26 14:13:10 2014 -0800
files: go/expressions.cc go/expressions.h
description:
compiler: Use backend interface for slice value expressions.
user: Chris Manghane <cmang@golang.org>
date: Wed Feb 26 13:12:19 2014 -0800
files: go/backend.h go/expressions.cc go/expressions.h go/gogo-tree.cc go/runtime.def go/statements.cc
description:
compiler: Use backend interface for interface values.
user: Chris Manghane <cmang@golang.org>
date: Mon Feb 24 12:30:13 2014 -0800
files: go/expressions.cc go/expressions.h go/parse.cc go/statements.cc
description:
compiler: Change Heap_composite_expression to Heap_expression.
user: Chris Manghane <cmang@golang.org>
date: Thu Feb 20 19:47:06 2014 -0800
files: go/expressions.cc go/expressions.h go/gogo-tree.cc go/gogo.cc go/gogo.h go/types.cc go/types.h
description:
compiler: Use backend interface for interface method table expressions.
user: Chris Manghane <cmang@golang.org>
date: Mon Feb 03 14:36:20 2014 -0800
files: go/expressions.cc go/expressions.h
description:
compiler: Add compound expressions to the frontend.
* go-gcc.cc: Include "convert.h".
(Gcc_backend::string_constant_expression): New function.
(Gcc_backend::real_part_expression): Likewise.
(Gcc_backend::imag_part_expression): Likewise.
(Gcc_backend::complex_expression): Likewise.
(Gcc_backend::constructor_expression): Likewise.
(Gcc_backend::array_constructor_expression): Likewise.
(Gcc_backend::pointer_offset_expression): Likewise.
(Gcc_backend::array_index_expression): Likewise.
(Gcc_backend::call_expression): Likewise.
(Gcc_backend::exception_handler_statement): Likewise.
(Gcc_backend::function_defer_statement): Likewise.
(Gcc_backend::function_set_parameters): Likewise.
(Gcc_backend::function_set_body): Likewise.
(Gcc_backend::convert_expression): Handle various type
conversions.
From-SVN: r209393
|
|
This patch fixes a rare but serious bug. The Go garbage
collector only examines Go stacks. When Go code calls a
function that is not written in Go, it first calls
syscall.Entersyscall. Entersyscall records the position of
the Go stack pointer and saves a copy of all the registers.
If the garbage collector runs while the thread is executing
the non-Go code, the garbage collector fetches the stack
pointer and registers from the saved location.
Entersyscall saves the registers using the getcontext
function. Unfortunately I didn't consider the possibility
that Entersyscall might itself change a register before
calling getcontext. This only matters for callee-saved
registers, as caller-saved registers would be visible on the
saved stack. And it only matters if Entersyscall is compiled
to save and modify a callee-saved register before it calls
getcontext. And it only matters if a garbage collection
occurs while the non-Go code is executing. And it only
matters if the only copy of a valid Go pointer happens to be
in the callee-saved register when Entersyscall is called.
When all those conditions are true, the Go pointer might get
collected incorrectly, leading to memory corruption.
This patch tries to avoid the problem by splitting
Entersyscall into two functions. The first is a simple
function that just calls getcontext and then calls the rest of
Entersyscall. This should fix the problem, provided the
simple Entersyscall function does not itself modify any
callee-saved registers before calling getcontext. That seems
to be true on the systems I checked. But since the argument
to getcontext is an offset from a TLS variable, it won't be
true on a system which needs to save callee-saved registers in
order to get the address of a TLS variable. I don't know why
any system would work that way, but I don't know how to rule
it out. I think that on any such system this will have to be
implemented in assembler. I can't put the ucontext_t
structure on the stack, because this function can not split
stacks, and the ucontext_t structure is large enough that it
could cause a stack overflow.
From-SVN: r208390
|
|
From-SVN: r208286
|
|
Before this, the heap location used on a 64-bit system was not
available to user-space on arm64, so the "32-bit" strategy ended up
being used. So use somewhere that is available, and for bonus points
is far away from where the kernel allocates address space by default.
From-SVN: r207977
|
|
PR go/59866
runtime: Force work variable in mgc0 to be aligned on 8-byte boundary.
From-SVN: r206738
|
|
The spans array is allocated in runtime_mallocinit. On a
32-bit system the number of entries in the spans array is
MaxArena32 / PageSize, which (2U << 30) / (1 << 12) == (1 << 19).
So we are allocating an array that can hold 19 bits for an
index that can hold 20 bits. According to the comment in the
function, this is intentional: we only allocate enough spans
(and bitmaps) for a 2G arena, because allocating more would
probably be wasteful.
But since the span index is simply the upper 20 bits of the
memory address, this scheme only works if memory addresses are
limited to the low 2G of memory. That would be OK if we were
careful to enforce it, but we're not. What we are careful to
enforce, in functions like runtime_MHeap_SysAlloc, is that we
always return addresses between the heap's arena_start and
arena_start + MaxArena32.
We generally get away with it because we start allocating just
after the program end, so we only run into trouble with
programs that allocate a lot of memory, enough to get past
address 0x80000000.
This changes the code that computes a span index to subtract
arena_start on 32-bit systems just as we currently do on
64-bit systems.
From-SVN: r206501
|
|
PR go/59433
net: Don't use stack space for fd_sets when using select.
From-SVN: r206411
|
|
From-SVN: r206353
|
|
Don't free stack allocated defer block. Also ensure we have a
Go context in a few more places before freeing the block.
From-SVN: r205940
|
|
From-SVN: r205913
|
|
From-SVN: r205908
|
|
PR go/59408
runtime: Don't require g != m->g0 in sema notesleep.
From-SVN: r205756
|
|
From-SVN: r205652
|
|
From Richard Biener.
From-SVN: r205634
|
|
Avoids hanging inside older versions of glibc that do not
support recurive calls to dl_iterate_phdr.
From-SVN: r205561
|
|
From-SVN: r205422
|
|
From-SVN: r205321
|
