A step toward eliminating goc2c.
    
    Drop the exported parfor code; it was needed for tests in the past, but
    no longer is. The Go 1.7 runtime no longer uses parfor.
    
    Reviewed-on: https://go-review.googlesource.com/33324

From-SVN: r242509

<toplevel>

2016-11-15  Matthias Klose  <doko@ubuntu.com>

	* config-ml.in: Remove references to GCJ.
	* configure.ac: Likewise.
	* configure: Regenerate.

config/

2016-11-15  Matthias Klose  <doko@ubuntu.com>

	multi.m4: Don't set GCJ.

gcc/

2016-11-15  Matthias Klose  <doko@ubuntu.com>

	* doc/install.texi: Remove references to gcj/libjava.
	* doc/invoke.texi: Likewise.

*/ (where necessary)

2016-11-15  Matthias Klose  <doko@ubuntu.com>

	* configure: Regenerate.

From-SVN: r242433

    
    Apparently on Solaris 10 a SA_SIGINFO signal handler can be invoked with
    a nil info argument.  I would not have believed it but I've now seen it
    happen, and the sigaction man page actually says "If the second argument
    is not equal to NULL, it points to a siginfo_t structure...."  So, if
    that happens, don't crash.
    
    Also fix another case where we want to make sure that &T{} does not
    allocate.
    
    Reviewed-on: https://go-review.googlesource.com/33150

From-SVN: r242403

    
    From Andreas Schwab.
    
    Reviewed-on: https://go-review.googlesource.com/33130

From-SVN: r242072

    
    Add a little shell script to auto-generate runtime.sigtable from the
    known signal names.
    
    Force the main package to always import the runtime package.  Otherwise
    some runtime package global variables may never be initialized.
    
    Set the syscallsp and syscallpc fields of g when entering a syscall, so
    that the runtime package knows when a g is executing a syscall.
    
    Fix runtime.funcPC to avoid dead store elimination of the interface
    value when the function is inlined.
    
    Reviewed-on: https://go-review.googlesource.com/33025

From-SVN: r242060

	PR go/78172.
    libgo: avoid confusion in upcase_fields in mksysinfo.sh
    
    The mksysinfo.sh script could get confused when there were multiple
    types starting with the same name.  I believe this is the underlying
    cause of GCC PR 78172.
    
    Also redirect a grep to /dev/null to avoid extraneous messages during
    the build.
    
    Reviewed-on: https://go-review.googlesource.com/32821

From-SVN: r241868

    
    From Andreas Schwab.
    
    Reviewed-on: https://go-review.googlesource.com/32537

From-SVN: r241757

    
    When using cgo -gccgo calls to C.GoString, C.GoStringN, and C.GoBytes
    are turned into calls to __go_byte_array_to_string and
    __go_string_to_byte_array.  Those functions were removed when the string
    code was copied from Go 1.7, but we still need them for cgo.  While cgo
    should be updated, old versions will exist for some time.
    
    Reviewed-on: https://go-review.googlesource.com/32474

From-SVN: r241743

    
    Use mvifdiff and stamp files to track whether a .gox file has changed.
    When package A depends on package B, and we rebuild package B, only
    rebuild package A if package B's .gox file changes.  This is safe
    because when package A imports package B it only reads package B's .gox
    file.  This means that changes that do not affect export information
    will not cause dependent packages to be recompiled.
    
    Reviewed-on: https://go-review.googlesource.com/32476

From-SVN: r241742

    
    Suggested by Ralph Corderoy.
    
    Reviewed-on: https://go-review.googlesource.com/32414

From-SVN: r241741

    
    I read through the GNU make manual.  I knew there had to be a way to do it.
    
    Remove the special netgo library.  The essential feature--using the Go
    DNS resolver--is now available by setting GODEBUG=netdns=go.
    
    Reviewed-on: https://go-review.googlesource.com/32333

From-SVN: r241687

    
    Change the compiler handle append as the gc compiler does: call a
    function to grow the slice, but otherwise assign the new elements
    directly to the final slice.
    
    For the current gccgo memory allocator the slice code has to call
    runtime_newarray, not mallocgc directly, so that the allocator sets the
    TypeInfo_Array bit in the type pointer.
    
    Rename the static function cnew to runtime_docnew, so that the stack
    trace ignores it when ignoring runtime functions.  This was needed to
    fix the runtime/pprof tests on 386.
    
    Reviewed-on: https://go-review.googlesource.com/32218

From-SVN: r241667

	PR go/78144
    libgo: incorporate fix for timezone test
    
    This brings over the test-only fix for issue 17276 into gccgo/libgo
    (with tzdata-2016g there is a new zone abbreviation).  This is a
    copy of https://golang.org/cl/29995.
    
    Reviewed-on: https://go-review.googlesource.com/32182

From-SVN: r241661

	PR go/78143
    runtime: build lfstack_32bit.go on ppc
    
    Missed a build tag.  This is GCC PR 78143.
    
    Reviewed-on: https://go-review.googlesource.com/32295

From-SVN: r241659

    
    I noticed a stray useless output line when building libgo.
    
    Reviewed-on: https://go-review.googlesource.com/32294

From-SVN: r241655

    
    The constants named c0 and c1 turn up as macros in runtime.inc.  This
    reportedly breaks building on Solaris 11, where there is a system struct
    that has a field named c1.  The constants aren't needed by the runtime C
    code, so avoid the problem by grepping them out.
    
    Reviewed-on: https://go-review.googlesource.com/31730

From-SVN: r241432

    
    Verified by testing on SPARC Solaris.
    
    Reviewed-on: https://go-review.googlesource.com/31675

From-SVN: r241430

    
    Note that lfstack_64bit.go was modified for Solaris support in a
    different, and better, way than the superseded lfstack.goc code.
    
    Reviewed-on: https://go-review.googlesource.com/31673

From-SVN: r241427

    
    I started to copy the Go 1.7 interface code, but the gc and gccgo
    representations of interfaces are too different.  So instead I rewrote
    the gccgo interface code from C to Go.  The code is largely the same as
    it was, but the names are more like those used in the gc runtime.
    
    I also copied over the string comparison functions, and tweaked the
    compiler to use eqstring when comparing strings for equality.
    
    Reviewed-on: https://go-review.googlesource.com/31591

From-SVN: r241384

    
    The C definition is 1U << 31.  Reportedly on some systems GCC's
    -fgo-dump-spec can print this as -2147483648.
    
    Reviewed-on: https://go-review.googlesource.com/31448

From-SVN: r241347

    
    Reviewed-on: https://go-review.googlesource.com/31325

From-SVN: r241307

    
    While testing a patch on Solaris, which does not support split-stack, I
    ran across a bug in the handling of caller-saved registers for the
    garbage collector.  For non-split-stack systems, runtime_mcall is
    responsible for saving all caller-saved registers on the stack so that
    the GC stack scan will see them.  It does this by calling
    __builtin_unwind_init and setting the g's gcnextsp field to point to the
    current stack.  The garbage collector then scans the stack from gcnextsp
    to the top of stack.
    
    Unfortunately, the code was setting gcnextsp to point to runtime_mcall's
    argument, which meant that even though runtime_mcall was careful to
    store all caller-saved registers on the stack, the GC never saw them.
    This is, of course, only a problem if a value lives only in a
    caller-saved register, and not anywhere else on the stack or heap.  And
    it is only a problem if that caller-saved register manages to make it
    all the way down to runtime_mcall without being saved by any function on
    the way.  This is moderately unlikely but it turns out that the recent
    changes to keep values on the stack when compiling the runtime package
    caused it to happen for the local variable `s` in `notifyListWait` in
    runtime/sema.go.  That function calls goparkunlock which is simple
    enough to not require all registers, and itself calls runtime_mcall.  So
    it was possible for `s` to be released by the GC before the goroutine
    returned from goparkunlock, which eventually caused a dangling pointer
    to be passed to releaseSudog.
    
    This is not a problem on split-stack systems, which use
    __splitstack_get_context, which saves a stack pointer low enough on the
    stack to scan the registers saved by runtime_mcall.
    
    Reviewed-on: https://go-review.googlesource.com/31323

From-SVN: r241304

    
    While we're at it, update the runtime/debug package, and start running
    its testsuite by default.  I'm not sure why runtime/debug was not
    previously updated to 1.7.  Doing that led me to fix some minor aspects
    of runtime.Stack and the C function runtime/debug.readGCStats.
    
    Reviewed-on: https://go-review.googlesource.com/31251

From-SVN: r241261

    
    Fix handling of function values for -fgo-c-header to generate FuncVal*,
    not simply FuncVal.
    
    While we're here change runtime.nanotime to use clock_gettime with
    CLOCK_MONOTONIC, rather than gettimeofday.  This is what the gc library
    does.  It provides nanosecond precision and a monotonic clock.
    
    Reviewed-on: https://go-review.googlesource.com/31232

From-SVN: r241197

    
    Also create a gccgo version of some of the traceback code in
    traceback_gccgo.go, replacing some code currently in C.
    
    This required modifying the compiler so that when compiling the runtime
    package a slice expression does not cause a local array variable to
    escape to the heap.
    
    Reviewed-on: https://go-review.googlesource.com/31230

From-SVN: r241189

    
    In order to port stack backtraces to Go, we need the ability to look up
    file/line information for PC values without allocating memory.  This
    patch moves the handling of Func from C code to Go code, and simplifies
    the C code to just look up function/file/line/entry information for a PC.
    
    Reviewed-on: https://go-review.googlesource.com/31150

From-SVN: r241172

    
    This is a backport of https://go-review.googlesource.com/30870.
    
    Reviewed-on: https://go-review.googlesource.com/30916

From-SVN: r241171

    
    This replaces runtime/cpuprof.goc with go/runtime/cpuprof.go and adjusts
    the supporting code in runtime/proc.c.
    
    This adds another case where the compiler needs to avoid heap allocation
    in the runtime package: when evaluating a method expression into a
    closure.  Implementing this required moving the relevant code from
    do_get_backend to do_flatten, so that I could easily add a temporary
    variable.  Doing that let me get rid of Bound_method_expression::do_lower.
    
    Reviewed-on: https://go-review.googlesource.com/31050

From-SVN: r241163

    
    This replaces mem.go and the C runtime_ReadMemStats function with the Go
    1.7 mstats.go.
    
    The GCStats code is commented out for now.  The corresponding gccgo code
    is in runtime/mgc0.c.
    
    The variables memstats and worldsema are shared between the Go code and
    the C code, but are not exported.  To make this work, add temporary
    accessor functions acquireWorldsema, releaseWorldsema, getMstats (the
    latter known as mstats in the C code).
    
    Check the preemptoff field of m when allocating and when considering
    whether to start a GC.  This works with the new stopTheWorld and
    startTheWorld functions in Go, which are essentially the Go 1.7
    versions.
    
    Change the compiler to stack allocate closures when compiling the
    runtime package.  Within the runtime packages closures do not escape.
    This is similar to what the gc compiler does, except that the gc
    compiler, when compiling the runtime package, gives an error if escape
    analysis shows that a closure does escape.  I added this here because
    the Go version of ReadMemStats calls systemstack with a closure, and
    having that allocate memory was causing some tests that measure memory
    allocations to fail.
    
    Reviewed-on: https://go-review.googlesource.com/30972

From-SVN: r241124

    
    It's unnecessary and it reportedly breaks the build on arm64 GNU/Linux.
    
    Reviewed-on: https://go-review.googlesource.com/30978

From-SVN: r241084

    
    Add compiler support for turning concatenating strings into a call to
    a runtime function that takes the appropriate number of arguments.
    
    Rename some local variables in mgc0.c to avoid macros that the new
    rune.go causes to appear in runtime.inc.
    
    Reviewed-on: https://go-review.googlesource.com/30827

From-SVN: r241074

    
    Reviewed-on: https://go-review.googlesource.com/30955

From-SVN: r241072

    
    This triggered a check in releaseSudog that g.param not nil, because
    libgo uses the param field when starting a goroutine.  Fixed by clearing
    g->param in kickoff in proc.c.
    
    Reviewed-on: https://go-review.googlesource.com/30951

From-SVN: r241067

    
    Since sparc is a valid architecture, the name of
    getrandom_linux_sparc.go means that it will be ignored on sparc64,
    even though it's whitelisted with a +build line.
    
    On SPARC, clone has a unique return value convention which requires
    some inline assembly to convert it to the normal convention.
    
    Reviewed-on: https://go-review.googlesource.com/30873

From-SVN: r241051

    
    Avoid an error message in the middle of the configure output.
    
    Patch by Eric Botcazou.
    
    Reviewed-on: https://go-review.googlesource.com/30813

From-SVN: r240993

    Update the compiler to use the new names.  Add calls to printlock and
    printunlock around print statements.  Move expression evaluation before
    the call to printlock.  Update g's writebuf field to a slice, and adjust
    C code accordingly.

    Reviewed-on: https://go-review.googlesource.com/30717

From-SVN: r240958

    
    Update the compiler to use the new names.  Add calls to printlock and
    printunlock around print statements.  Move expression evaluation before
    the call to printlock.  Update g's writebuf field to a slice, and adjust
    C code accordingly.
    
    Reviewed-on: https://go-review.googlesource.com/30717

From-SVN: r240956

    
    Change the compiler to use the new routines. Drop the separation of
    small and large values when sending on a channel. Allocate the select
    struct on the stack. Remove the old C implementation of channels. Adjust
    the garbage collector for the new data structure.
    
    Bring in part of the tracing code, enough for the channel code to call.
    
    Bump the permitted number of allocations in one of the tests in
    context_test.go. The difference is that now receiving from a channel
    allocates a sudog, which the C code used to simply put on the
    stack. This will be somewhat better when we port proc.go.
    
    Reviewed-on: https://go-review.googlesource.com/30714

From-SVN: r240941

	PR go/77809

    libgo: strip most C macros from runtime.inc
    
    The Go runtime package is picking up C macros from runtime_sysinfo.go
    and then re-exporting them to runtime.inc.  This can cause name
    conflicts.  Change the Makefile so that we only put the macros we need
    into runtime.inc.  These are the constants that are actually defined by
    Go code, not runtime_sysinfo.go.  There are only a few, so we can
    pattern match.
    
    This is an additional hack on runtime.inc.  The long term goal is to
    convert the runtime package to Go and eliminate runtime.inc entirely, so
    a few hacks seem acceptable.
    
    Fixes GCC PR 77809.

    Reviewed-on: https://go-review.googlesource.com/30167

From-SVN: r240724

    
    Remove the old locking code written in C.
    
    Add a shell script mkrsysinfo.sh to generate the runtime_sysinfo.go
    file, so that we can get Go copies of the system time structures and
    other types.
    
    Tweak the compiler so that when compiling the runtime package the
    address operator does not cause local variables to escape.  When the gc
    compiler compiles the runtime, an escaping local variable is treated as
    an error.  We should implement that, instead of this change, when escape
    analysis is turned on.
    
    Tweak the compiler so that the generated C header does not include names
    that start with an underscore followed by a non-upper-case letter,
    except for the special cases of _defer and _panic.  Otherwise we
    translate C types to Go in runtime_sysinfo.go and then generate those Go
    types back as C types in runtime.inc, which is useless and painful for
    the C code.
    
    Change entersyscall and friends to take a dummy argument, as the gc
    versions do, to simplify calls from the shared code.
    
    Reviewed-on: https://go-review.googlesource.com/30079

From-SVN: r240657