[llgo] Roll gofrontend forward

[axw]

Summary

Switch gofrontend to using go.googlesource.com, and
update to 81eb6a3f425b2158c67ee32c0cc973a72ce9d6be.

There are various changes required to update to the
go 1.5 runtime:

• typemap.go is changed to accommodate the change in representation for equal/hash algorithms, and the removal of the zero value/type.
• CMakeLists.txt is updated to add the build tree to the package search path, so internal packages, which are not installed, are found.
• various files changes due to removal of __go_new_nopointers; the same change as in D11863, but with NoUnwindAttribute added to the added runtime functions which are called with "callOnly".
• minor cleanups in ssa.go while investigating issues with unwinding/panic handling.

[axw]

I've just come back to this and found that it's broken. Unsure of what's changed in the interim, but I get "panic: panic during panic" caused by type descriptor comparisons. Will come back to this when I have time.

[axw]

Revert removal of __go_runtime_error

No longer causing errors. Have not bisected
to find out what the issue is yet.

[axw]

In D15188#331740, @axw wrote:

Revert removal of __go_runtime_error

No longer causing errors. Have not bisected
to find out what the issue is yet.

The failures stopped in r256202.

[axw]

@pcc Ping. This is ready for review now.

[pcc]

irgen/typemap.go

1484–1498

I don't think you need to be able to call arbitrary closures in the algorithm implementations. Since the identity of the element type is statically known, you can just call the function directly. The only place where you should need to deal with closure descriptors is when building the type descriptor struct.

update_third_party.sh

74–76

Will this work now that autoconf support is removed from LLVM? We might need to make our own copies of the files in the llgo repo.

[axw]

• Fix autoconf file copying
• Call hash/equal functions directly, not through descriptors.

[axw]

@pcc Thanks, PTAL.

irgen/typemap.go

1484–1498

Yep, thanks, I'm storing functions and descriptors, so reverted the hash/equal calls.

update_third_party.sh

74–76

config.guess was relocated to cmake/config.guess, so I'll change it to copy from there.
config.sub was removed, so adding it as llgo/autoconf/config.sub.

[axw]

Ping. Once this is in, I'll look at updating to 1.6.

[cierniak]

In D15188#355493, @axw wrote:

Ping. Once this is in, I'll look at updating to 1.6.

I'm also keen to see this submitted and then seeing the update to 1.6.

[pcc]

Sorry for the delay. LGTM, thanks!

[axw]

TargetMachine.TargetData -> TargetMachine.CreateTargetData

[pcc]

cmd/gllgo/gllgo.go

489–490

Was this change intended?

[pcc]

Ah, I see that LLVMAddTargetData is no more. LGTM then.

[axw]

cmd/gllgo/gllgo.go

489–490

Yes, sorry, should have commented. LLVMAddTargetData has been removed. AFAICT, PM now uses the data layout from the module.

[axw]

Closed by rL263536

CMakeLists.txt

set(LLGO_GO_SOURCES
   ${CMAKE_CURRENT_SOURCE_DIR}/third_party/gofrontend/libgo/go/cmd/go/fmt.go
   ${CMAKE_CURRENT_SOURCE_DIR}/third_party/gofrontend/libgo/go/cmd/go/generate.go
   ${CMAKE_CURRENT_SOURCE_DIR}/third_party/gofrontend/libgo/go/cmd/go/get.go
   ${CMAKE_CURRENT_SOURCE_DIR}/third_party/gofrontend/libgo/go/cmd/go/go11.go
   ${CMAKE_CURRENT_SOURCE_DIR}/third_party/gofrontend/libgo/go/cmd/go/help.go
   ${CMAKE_CURRENT_SOURCE_DIR}/third_party/gofrontend/libgo/go/cmd/go/http.go
   ${CMAKE_CURRENT_SOURCE_DIR}/third_party/gofrontend/libgo/go/cmd/go/list.go
   ${CMAKE_CURRENT_SOURCE_DIR}/third_party/gofrontend/libgo/go/cmd/go/main.go
+  ${CMAKE_CURRENT_SOURCE_DIR}/third_party/gofrontend/libgo/go/cmd/go/note.go
   ${CMAKE_CURRENT_SOURCE_DIR}/third_party/gofrontend/libgo/go/cmd/go/pkg.go
   ${CMAKE_CURRENT_SOURCE_DIR}/third_party/gofrontend/libgo/go/cmd/go/run.go
   ${CMAKE_CURRENT_SOURCE_DIR}/third_party/gofrontend/libgo/go/cmd/go/signal.go
   ${CMAKE_CURRENT_SOURCE_DIR}/third_party/gofrontend/libgo/go/cmd/go/signal_unix.go
   ${CMAKE_CURRENT_SOURCE_DIR}/third_party/gofrontend/libgo/go/cmd/go/testflag.go
   ${CMAKE_CURRENT_SOURCE_DIR}/third_party/gofrontend/libgo/go/cmd/go/test.go
   ${CMAKE_CURRENT_SOURCE_DIR}/third_party/gofrontend/libgo/go/cmd/go/tool.go
   ${CMAKE_CURRENT_SOURCE_DIR}/third_party/gofrontend/libgo/go/cmd/go/vcs.go
   ${CMAKE_CURRENT_SOURCE_DIR}/third_party/gofrontend/libgo/go/cmd/go/version.go
   ${CMAKE_CURRENT_SOURCE_DIR}/third_party/gofrontend/libgo/go/cmd/go/vet.go
   ${CMAKE_CURRENT_BINARY_DIR}/cmd/go/zdefaultcc.go
 )
 
 add_custom_command(OUTPUT ${CMAKE_BINARY_DIR}/bin/llgo-go${CMAKE_EXECUTABLE_SUFFIX}
   COMMAND ${CMAKE_BINARY_DIR}/bin/llgo -static-libgo
+          -I ${CMAKE_CURRENT_BINARY_DIR}/libgo
           -o ${CMAKE_BINARY_DIR}/bin/llgo-go${CMAKE_EXECUTABLE_SUFFIX}
           ${LLGO_GO_SOURCES}
           ${CMAKE_CURRENT_BINARY_DIR}/libgo/zstdpkglist.go
   DEPENDS llgo libgo ${LLGO_GO_SOURCES}
   COMMENT "Building Go executable llgo-go"
   VERBATIM)
 add_custom_target(llgo-go ALL DEPENDS ${CMAKE_BINARY_DIR}/bin/llgo-go${CMAKE_EXECUTABLE_SUFFIX})
 

autoconf/config.sub

+#! /bin/sh
+# Configuration validation subroutine script.
+#   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
+#   2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
+#   2011 Free Software Foundation, Inc.
+
+timestamp='2011-11-02'
+
+# This file is (in principle) common to ALL GNU software.
+# The presence of a machine in this file suggests that SOME GNU software
+# can handle that machine.  It does not imply ALL GNU software can.
+#
+# This file is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
+# 02110-1301, USA.
+#
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+
+# Please send patches to <[e-mail]>.  Submit a context
+# diff and a properly formatted GNU ChangeLog entry.
+#
+# Configuration subroutine to validate and canonicalize a configuration type.
+# Supply the specified configuration type as an argument.
+# If it is invalid, we print an error message on stderr and exit with code 1.
+# Otherwise, we print the canonical config type on stdout and succeed.
+
+# You can get the latest version of this script from:
+# http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub;hb=HEAD
+
+# This file is supposed to be the same for all GNU packages
+# and recognize all the CPU types, system types and aliases
+# that are meaningful with *any* GNU software.
+# Each package is responsible for reporting which valid configurations
+# it does not support.  The user should be able to distinguish
+# a failure to support a valid configuration from a meaningless
+# configuration.
+
+# The goal of this file is to map all the various variations of a given
+# machine specification into a single specification in the form:
+# CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM
+# or in some cases, the newer four-part form:
+# CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM
+# It is wrong to echo any other type of specification.
+
+me=`echo "$0" | sed -e 's,.*/,,'`
+
+usage="\
+Usage: $0 [OPTION] CPU-MFR-OPSYS
+       $0 [OPTION] ALIAS
+
+Canonicalize a configuration name.
+
+Operation modes:
+  -h, --help         print this help, then exit
+  -t, --time-stamp   print date of last modification, then exit
+  -v, --version      print version number, then exit
+
+Report bugs and patches to <[e-mail]>."
+
+version="\
+GNU config.sub ($timestamp)
+
+Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
+2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free
+Software Foundation, Inc.
+
+This is free software; see the source for copying conditions.  There is NO
+warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
+
+help="
+Try \`$me --help' for more information."
+
+# Parse command line
+while test $# -gt 0 ; do
+  case $1 in
+    --time-stamp | --time* | -t )
+       echo "$timestamp" ; exit ;;
+    --version | -v )
+       echo "$version" ; exit ;;
+    --help | --h* | -h )
+       echo "$usage"; exit ;;
+    -- )     # Stop option processing
+       shift; break ;;
+    - ) # Use stdin as input.
+       break ;;
+    -* )
+       echo "$me: invalid option $1$help"
+       exit 1 ;;
+
+    *local*)
+       # First pass through any local machine types.
+       echo $1
+       exit ;;
+
+    * )
+       break ;;
+  esac
+done
+
+case $# in
+ 0) echo "$me: missing argument$help" >&2
+    exit 1;;
+ 1) ;;
+ *) echo "$me: too many arguments$help" >&2
+    exit 1;;
+esac
+
+# Separate what the user gave into CPU-COMPANY and OS or KERNEL-OS (if any).
+# Here we must recognize all the valid KERNEL-OS combinations.
+maybe_os=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'`
+case $maybe_os in
+  nto-qnx* | linux-gnu* | linux-android* | linux-dietlibc | linux-newlib* | \
+  linux-uclibc* | uclinux-uclibc* | uclinux-gnu* | kfreebsd*-gnu* | \
+  knetbsd*-gnu* | netbsd*-gnu* | \
+  kopensolaris*-gnu* | \
+  storm-chaos* | os2-emx* | rtmk-nova*)
+    os=-$maybe_os
+    basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`
+    ;;
+  *)
+    basic_machine=`echo $1 | sed 's/-[^-]*$//'`
+    if [ $basic_machine != $1 ]
+    then os=`echo $1 | sed 's/.*-/-/'`
+    else os=; fi
+    ;;
+esac
+
+### Let's recognize common machines as not being operating systems so
+### that things like config.sub decstation-3100 work.  We also
+### recognize some manufacturers as not being operating systems, so we
+### can provide default operating systems below.
+case $os in
+  -sun*os*)
+    # Prevent following clause from handling this invalid input.
+    ;;
+  -dec* | -mips* | -sequent* | -encore* | -pc532* | -sgi* | -sony* | \
+  -att* | -7300* | -3300* | -delta* | -motorola* | -sun[234]* | \
+  -unicom* | -ibm* | -next | -hp | -isi* | -apollo | -altos* | \
+  -convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\
+  -c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \
+  -harris | -dolphin | -highlevel | -gould | -cbm | -ns | -masscomp | \
+  -apple | -axis | -knuth | -cray | -microblaze)
+    os=
+    basic_machine=$1
+    ;;
+  -bluegene*)
+    os=-cnk
+    ;;
+  -sim | -cisco | -oki | -wec | -winbond)
+    os=
+    basic_machine=$1
+    ;;
+  -scout)
+    ;;
+  -wrs)
+    os=-vxworks
+    basic_machine=$1
+    ;;
+  -chorusos*)
+    os=-chorusos
+    basic_machine=$1
+    ;;
+  -chorusrdb)
+    os=-chorusrdb
+    basic_machine=$1
+    ;;
+  -hiux*)
+    os=-hiuxwe2
+    ;;
+  -sco6)
+    os=-sco5v6
+    basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+    ;;
+  -sco5)
+    os=-sco3.2v5
+    basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+    ;;
+  -sco4)
+    os=-sco3.2v4
+    basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+    ;;
+  -sco3.2.[4-9]*)
+    os=`echo $os | sed -e 's/sco3.2./sco3.2v/'`
+    basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+    ;;
+  -sco3.2v[4-9]*)
+    # Don't forget version if it is 3.2v4 or newer.
+    basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+    ;;
+  -sco5v6*)
+    # Don't forget version if it is 3.2v4 or newer.
+    basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+    ;;
+  -sco*)
+    os=-sco3.2v2
+    basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+    ;;
+  -udk*)
+    basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+    ;;
+  -isc)
+    os=-isc2.2
+    basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+    ;;
+  -clix*)
+    basic_machine=clipper-intergraph
+    ;;
+  -isc*)
+    basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+    ;;
+  -lynx*)
+    os=-lynxos
+    ;;
+  -ptx*)
+    basic_machine=`echo $1 | sed -e 's/86-.*/86-sequent/'`
+    ;;
+  -windowsnt*)
+    os=`echo $os | sed -e 's/windowsnt/winnt/'`
+    ;;
+  -psos*)
+    os=-psos
+    ;;
+  -mint | -mint[0-9]*)
+    basic_machine=m68k-atari
+    os=-mint
+    ;;
+esac
+
+# Decode aliases for certain CPU-COMPANY combinations.
+case $basic_machine in
+  # Recognize the basic CPU types without company name.
+  # Some are omitted here because they have special meanings below.
+  1750a | 580 \
+  | a29k \
+  | alpha | alphaev[4-8] | alphaev56 | alphaev6[78] | alphapca5[67] \
+  | alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] | alpha64pca5[67] \
+  | am33_2.0 \
+  | arc | arm | arm[bl]e | arme[lb] | armv[2345] | armv[345][lb] | avr | avr32 \
+   | aarch64 | aarch64_be \
+   | be32 | be64 \
+  | bfin \
+  | c4x | clipper \
+  | d10v | d30v | dlx | dsp16xx \
+  | fido | fr30 | frv \
+  | hexagon \
+  | h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \
+  | i370 | i860 | i960 | ia64 \
+  | ip2k | iq2000 \
+  | le32 | le64 \
+  | lm32 \
+  | m32c | m32r | m32rle | m68000 | m68k | m88k \
+  | maxq | mb | microblaze | mcore | mep | metag \
+  | mips | mipsbe | mipseb | mipsel | mipsle \
+  | mips16 \
+  | mips64 | mips64el \
+  | mips64octeon | mips64octeonel \
+  | mips64orion | mips64orionel \
+  | mips64r5900 | mips64r5900el \
+  | mips64vr | mips64vrel \
+  | mips64vr4100 | mips64vr4100el \
+  | mips64vr4300 | mips64vr4300el \
+  | mips64vr5000 | mips64vr5000el \
+  | mips64vr5900 | mips64vr5900el \
+  | mipsisa32 | mipsisa32el \
+  | mipsisa32r2 | mipsisa32r2el \
+  | mipsisa64 | mipsisa64el \
+  | mipsisa64r2 | mipsisa64r2el \
+  | mipsisa64sb1 | mipsisa64sb1el \
+  | mipsisa64sr71k | mipsisa64sr71kel \
+  | mipstx39 | mipstx39el \
+  | mn10200 | mn10300 \
+  | moxie \
+  | mt \
+  | msp430 \
+  | nds32 | nds32le | nds32be \
+  | nios | nios2 \
+  | ns16k | ns32k \
+  | open8 \
+  | or32 \
+  | pdp10 | pdp11 | pj | pjl \
+  | powerpc | powerpc64 | powerpc64le | powerpcle \
+  | pyramid \
+  | rx \
+  | score \
+  | sh | sh[1234] | sh[24]a | sh[24]aeb | sh[23]e | sh[34]eb | sheb | shbe | shle | sh[1234]le | sh3ele \
+  | sh64 | sh64le \
+  | sparc | sparc64 | sparc64b | sparc64v | sparc86x | sparclet | sparclite \
+  | sparcv8 | sparcv9 | sparcv9b | sparcv9v \
+  | spu \
+  | tahoe | tic4x | tic54x | tic55x | tic6x | tic80 | tron \
+  | ubicom32 \
+  | v850 | v850e | v850e1 | v850e2 | v850es | v850e2v3 \
+  | we32k \
+  | x86 | xc16x | xstormy16 | xtensa \
+  | z8k | z80)
+    basic_machine=$basic_machine-unknown
+    ;;
+  c54x)
+    basic_machine=tic54x-unknown
+    ;;
+  c55x)
+    basic_machine=tic55x-unknown
+    ;;
+  c6x)
+    basic_machine=tic6x-unknown
+    ;;
+  m6811 | m68hc11 | m6812 | m68hc12 | picochip)
+    # Motorola 68HC11/12.
+    basic_machine=$basic_machine-unknown
+    os=-none
+    ;;
+  m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | v70 | w65 | z8k)
+    ;;
+  ms1)
+    basic_machine=mt-unknown
+    ;;
+
+  strongarm | thumb | xscale)
+    basic_machine=arm-unknown
+    ;;
+
+  xscaleeb)
+    basic_machine=armeb-unknown
+    ;;
+
+  xscaleel)
+    basic_machine=armel-unknown
+    ;;
+
+  # We use `pc' rather than `unknown'
+  # because (1) that's what they normally are, and
+  # (2) the word "unknown" tends to confuse beginning users.
+  i*86 | x86_64)
+    basic_machine=$basic_machine-pc
+    ;;
+  # Object if more than one company name word.
+  *-*-*)
+    echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2
+    exit 1
+    ;;
+  # Recognize the basic CPU types with company name.
+  580-* \
+  | a29k-* \
+  | alpha-* | alphaev[4-8]-* | alphaev56-* | alphaev6[78]-* \
+  | alpha64-* | alpha64ev[4-8]-* | alpha64ev56-* | alpha64ev6[78]-* \
+  | alphapca5[67]-* | alpha64pca5[67]-* | arc-* \
+  | arm-*  | armbe-* | armle-* | armeb-* | armv*-* \
+   | aarch64-* | aarch64_be-* \
+  | avr-* | avr32-* \
+  | be32-* | be64-* \
+  | bfin-* | bs2000-* \
+  | c[123]* | c30-* | [cjt]90-* | c4x-* \
+  | clipper-* | craynv-* | cydra-* \
+  | d10v-* | d30v-* | dlx-* \
+  | elxsi-* \
+  | f30[01]-* | f700-* | fido-* | fr30-* | frv-* | fx80-* \
+  | h8300-* | h8500-* \
+  | hexagon-* \
+  | hppa-* | hppa1.[01]-* | hppa2.0-* | hppa2.0[nw]-* | hppa64-* \
+  | i*86-* | i860-* | i960-* | ia64-* \
+  | ip2k-* | iq2000-* \
+  | le32-* | le64-* \
+  | lm32-* \
+  | m32c-* | m32r-* | m32rle-* \
+  | m68000-* | m680[012346]0-* | m68360-* | m683?2-* | m68k-* \
+  | m88110-* | m88k-* | maxq-* | mcore-* | metag-* | microblaze-* \
+  | mips-* | mipsbe-* | mipseb-* | mipsel-* | mipsle-* \
+  | mips16-* \
+  | mips64-* | mips64el-* \
+  | mips64octeon-* | mips64octeonel-* \
+  | mips64orion-* | mips64orionel-* \
+  | mips64r5900-* | mips64r5900el-* \
+  | mips64vr-* | mips64vrel-* \
+  | mips64vr4100-* | mips64vr4100el-* \
+  | mips64vr4300-* | mips64vr4300el-* \
+  | mips64vr5000-* | mips64vr5000el-* \
+  | mips64vr5900-* | mips64vr5900el-* \
+  | mipsisa32-* | mipsisa32el-* \
+  | mipsisa32r2-* | mipsisa32r2el-* \
+  | mipsisa64-* | mipsisa64el-* \
+  | mipsisa64r2-* | mipsisa64r2el-* \
+  | mipsisa64sb1-* | mipsisa64sb1el-* \
+  | mipsisa64sr71k-* | mipsisa64sr71kel-* \
+  | mipstx39-* | mipstx39el-* \
+  | mmix-* \
+  | mt-* \
+  | msp430-* \
+  | nds32-* | nds32le-* | nds32be-* \
+  | nios-* | nios2-* \
+  | none-* | np1-* | ns16k-* | ns32k-* \
+  | open8-* \
+  | orion-* \
+  | pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \
+  | powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* \
+  | pyramid-* \
+  | romp-* | rs6000-* | rx-* \
+  | sh-* | sh[1234]-* | sh[24]a-* | sh[24]aeb-* | sh[23]e-* | sh[34]eb-* | sheb-* | shbe-* \
+  | shle-* | sh[1234]le-* | sh3ele-* | sh64-* | sh64le-* \
+  | sparc-* | sparc64-* | sparc64b-* | sparc64v-* | sparc86x-* | sparclet-* \
+  | sparclite-* \
+  | sparcv8-* | sparcv9-* | sparcv9b-* | sparcv9v-* | sv1-* | sx?-* \
+  | tahoe-* \
+  | tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* \
+  | tile*-* \
+  | tron-* \
+  | ubicom32-* \
+  | v850-* | v850e-* | v850e1-* | v850es-* | v850e2-* | v850e2v3-* \
+  | vax-* \
+  | we32k-* \
+  | x86-* | x86_64-* | xc16x-* | xps100-* \
+  | xstormy16-* | xtensa*-* \
+  | ymp-* \
+  | z8k-* | z80-*)
+    ;;
+  # Recognize the basic CPU types without company name, with glob match.
+  xtensa*)
+    basic_machine=$basic_machine-unknown
+    ;;
+  # Recognize the various machine names and aliases which stand
+  # for a CPU type and a company and sometimes even an OS.
+  386bsd)
+    basic_machine=i386-unknown
+    os=-bsd
+    ;;
+  3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc)
+    basic_machine=m68000-att
+    ;;
+  3b*)
+    basic_machine=we32k-att
+    ;;
+  a29khif)
+    basic_machine=a29k-amd
+    os=-udi
+    ;;
+  abacus)
+    basic_machine=abacus-unknown
+    ;;
+  adobe68k)
+    basic_machine=m68010-adobe
+    os=-scout
+    ;;
+  alliant | fx80)
+    basic_machine=fx80-alliant
+    ;;
+  altos | altos3068)
+    basic_machine=m68k-altos
+    ;;
+  am29k)
+    basic_machine=a29k-none
+    os=-bsd
+    ;;
+  amd64)
+    basic_machine=x86_64-pc
+    ;;
+  amd64-*)
+    basic_machine=x86_64-`echo $basic_machine | sed 's/^[^-]*-//'`
+    ;;
+  amdahl)
+    basic_machine=580-amdahl
+    os=-sysv
+    ;;
+  amiga | amiga-*)
+    basic_machine=m68k-unknown
+    ;;
+  amigaos | amigados)
+    basic_machine=m68k-unknown
+    os=-amigaos
+    ;;
+  amigaunix | amix)
+    basic_machine=m68k-unknown
+    os=-sysv4
+    ;;
+  apollo68)
+    basic_machine=m68k-apollo
+    os=-sysv
+    ;;
+  apollo68bsd)
+    basic_machine=m68k-apollo
+    os=-bsd
+    ;;
+  aros)
+    basic_machine=i386-pc
+    os=-aros
+    ;;
+  aux)
+    basic_machine=m68k-apple
+    os=-aux
+    ;;
+  balance)
+    basic_machine=ns32k-sequent
+    os=-dynix
+    ;;
+  blackfin)
+    basic_machine=bfin-unknown
+    os=-linux
+    ;;
+  blackfin-*)
+    basic_machine=bfin-`echo $basic_machine | sed 's/^[^-]*-//'`
+    os=-linux
+    ;;
+  bluegene*)
+    basic_machine=powerpc-ibm
+    os=-cnk
+    ;;
+  c54x-*)
+    basic_machine=tic54x-`echo $basic_machine | sed 's/^[^-]*-//'`
+    ;;
+  c55x-*)
+    basic_machine=tic55x-`echo $basic_machine | sed 's/^[^-]*-//'`
+    ;;
+  c6x-*)
+    basic_machine=tic6x-`echo $basic_machine | sed 's/^[^-]*-//'`
+    ;;
+  c90)
+    basic_machine=c90-cray
+    os=-unicos
+    ;;
+  cegcc)
+    basic_machine=arm-unknown
+    os=-cegcc
+    ;;
+  convex-c1)
+    basic_machine=c1-convex
+    os=-bsd
+    ;;
+  convex-c2)
+    basic_machine=c2-convex
+    os=-bsd
+    ;;
+  convex-c32)
+    basic_machine=c32-convex
+    os=-bsd
+    ;;
+  convex-c34)
+    basic_machine=c34-convex
+    os=-bsd
+    ;;
+  convex-c38)
+    basic_machine=c38-convex
+    os=-bsd
+    ;;
+  cray | j90)
+    basic_machine=j90-cray
+    os=-unicos
+    ;;
+  craynv)
+    basic_machine=craynv-cray
+    os=-unicosmp
+    ;;
+  cr16 | cr16-*)
+    basic_machine=cr16-unknown
+    os=-elf
+    ;;
+  crds | unos)
+    basic_machine=m68k-crds
+    ;;
+  crisv32 | crisv32-* | etraxfs*)
+    basic_machine=crisv32-axis
+    ;;
+  cris | cris-* | etrax*)
+    basic_machine=cris-axis
+    ;;
+  crx)
+    basic_machine=crx-unknown
+    os=-elf
+    ;;
+  da30 | da30-*)
+    basic_machine=m68k-da30
+    ;;
+  decstation | decstation-3100 | pmax | pmax-* | pmin | dec3100 | decstatn)
+    basic_machine=mips-dec
+    ;;
+  decsystem10* | dec10*)
+    basic_machine=pdp10-dec
+    os=-tops10
+    ;;
+  decsystem20* | dec20*)
+    basic_machine=pdp10-dec
+    os=-tops20
+    ;;
+  delta | 3300 | motorola-3300 | motorola-delta \
+        | 3300-motorola | delta-motorola)
+    basic_machine=m68k-motorola
+    ;;
+  delta88)
+    basic_machine=m88k-motorola
+    os=-sysv3
+    ;;
+  dicos)
+    basic_machine=i686-pc
+    os=-dicos
+    ;;
+  djgpp)
+    basic_machine=i586-pc
+    os=-msdosdjgpp
+    ;;
+  dpx20 | dpx20-*)
+    basic_machine=rs6000-bull
+    os=-bosx
+    ;;
+  dpx2* | dpx2*-bull)
+    basic_machine=m68k-bull
+    os=-sysv3
+    ;;
+  ebmon29k)
+    basic_machine=a29k-amd
+    os=-ebmon
+    ;;
+  elxsi)
+    basic_machine=elxsi-elxsi
+    os=-bsd
+    ;;
+  encore | umax | mmax)
+    basic_machine=ns32k-encore
+    ;;
+  es1800 | OSE68k | ose68k | ose | OSE)
+    basic_machine=m68k-ericsson
+    os=-ose
+    ;;
+  fx2800)
+    basic_machine=i860-alliant
+    ;;
+  genix)
+    basic_machine=ns32k-ns
+    ;;
+  gmicro)
+    basic_machine=tron-gmicro
+    os=-sysv
+    ;;
+  go32)
+    basic_machine=i386-pc
+    os=-go32
+    ;;
+  h3050r* | hiux*)
+    basic_machine=hppa1.1-hitachi
+    os=-hiuxwe2
+    ;;
+  h8300hms)
+    basic_machine=h8300-hitachi
+    os=-hms
+    ;;
+  h8300xray)
+    basic_machine=h8300-hitachi
+    os=-xray
+    ;;
+  h8500hms)
+    basic_machine=h8500-hitachi
+    os=-hms
+    ;;
+  harris)
+    basic_machine=m88k-harris
+    os=-sysv3
+    ;;
+  hp300-*)
+    basic_machine=m68k-hp
+    ;;
+  hp300bsd)
+    basic_machine=m68k-hp
+    os=-bsd
+    ;;
+  hp300hpux)
+    basic_machine=m68k-hp
+    os=-hpux
+    ;;
+  hp3k9[0-9][0-9] | hp9[0-9][0-9])
+    basic_machine=hppa1.0-hp
+    ;;
+  hp9k2[0-9][0-9] | hp9k31[0-9])
+    basic_machine=m68000-hp
+    ;;
+  hp9k3[2-9][0-9])
+    basic_machine=m68k-hp
+    ;;
+  hp9k6[0-9][0-9] | hp6[0-9][0-9])
+    basic_machine=hppa1.0-hp
+    ;;
+  hp9k7[0-79][0-9] | hp7[0-79][0-9])
+    basic_machine=hppa1.1-hp
+    ;;
+  hp9k78[0-9] | hp78[0-9])
+    # FIXME: really hppa2.0-hp
+    basic_machine=hppa1.1-hp
+    ;;
+  hp9k8[67]1 | hp8[67]1 | hp9k80[24] | hp80[24] | hp9k8[78]9 | hp8[78]9 | hp9k893 | hp893)
+    # FIXME: really hppa2.0-hp
+    basic_machine=hppa1.1-hp
+    ;;
+  hp9k8[0-9][13679] | hp8[0-9][13679])
+    basic_machine=hppa1.1-hp
+    ;;
+  hp9k8[0-9][0-9] | hp8[0-9][0-9])
+    basic_machine=hppa1.0-hp
+    ;;
+  hppa-next)
+    os=-nextstep3
+    ;;
+  hppaosf)
+    basic_machine=hppa1.1-hp
+    os=-osf
+    ;;
+  hppro)
+    basic_machine=hppa1.1-hp
+    os=-proelf
+    ;;
+  i370-ibm* | ibm*)
+    basic_machine=i370-ibm
+    ;;
+# I'm not sure what "Sysv32" means.  Should this be sysv3.2?
+  i*86v32)
+    basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
+    os=-sysv32
+    ;;
+  i*86v4*)
+    basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
+    os=-sysv4
+    ;;
+  i*86v)
+    basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
+    os=-sysv
+    ;;
+  i*86sol2)
+    basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
+    os=-solaris2
+    ;;
+  i386mach)
+    basic_machine=i386-mach
+    os=-mach
+    ;;
+  i386-vsta | vsta)
+    basic_machine=i386-unknown
+    os=-vsta
+    ;;
+  iris | iris4d)
+    basic_machine=mips-sgi
+    case $os in
+        -irix*)
+      ;;
+        *)
+      os=-irix4
+      ;;
+    esac
+    ;;
+  isi68 | isi)
+    basic_machine=m68k-isi
+    os=-sysv
+    ;;
+  m68knommu)
+    basic_machine=m68k-unknown
+    os=-linux
+    ;;
+  m68knommu-*)
+    basic_machine=m68k-`echo $basic_machine | sed 's/^[^-]*-//'`
+    os=-linux
+    ;;
+  m88k-omron*)
+    basic_machine=m88k-omron
+    ;;
+  magnum | m3230)
+    basic_machine=mips-mips
+    os=-sysv
+    ;;
+  merlin)
+    basic_machine=ns32k-utek
+    os=-sysv
+    ;;
+  microblaze)
+    basic_machine=microblaze-xilinx
+    ;;
+  mingw32)
+    basic_machine=i386-pc
+    os=-mingw32
+    ;;
+  mingw32ce)
+    basic_machine=arm-unknown
+    os=-mingw32ce
+    ;;
+  miniframe)
+    basic_machine=m68000-convergent
+    ;;
+  *mint | -mint[0-9]* | *MiNT | *MiNT[0-9]*)
+    basic_machine=m68k-atari
+    os=-mint
+    ;;
+  mips3*-*)
+    basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`
+    ;;
+  mips3*)
+    basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`-unknown
+    ;;
+  monitor)
+    basic_machine=m68k-rom68k
+    os=-coff
+    ;;
+  morphos)
+    basic_machine=powerpc-unknown
+    os=-morphos
+    ;;
+  msdos)
+    basic_machine=i386-pc
+    os=-msdos
+    ;;
+  ms1-*)
+    basic_machine=`echo $basic_machine | sed -e 's/ms1-/mt-/'`
+    ;;
+  mvs)
+    basic_machine=i370-ibm
+    os=-mvs
+    ;;
+  nacl)
+    basic_machine=le32-unknown
+    os=-nacl
+    ;;
+  ncr3000)
+    basic_machine=i486-ncr
+    os=-sysv4
+    ;;
+  netbsd386)
+    basic_machine=i386-unknown
+    os=-netbsd
+    ;;
+  netwinder)
+    basic_machine=armv4l-rebel
+    os=-linux
+    ;;
+  news | news700 | news800 | news900)
+    basic_machine=m68k-sony
+    os=-newsos
+    ;;
+  news1000)
+    basic_machine=m68030-sony
+    os=-newsos
+    ;;
+  news-3600 | risc-news)
+    basic_machine=mips-sony
+    os=-newsos
+    ;;
+  necv70)
+    basic_machine=v70-nec
+    os=-sysv
+    ;;
+  next | m*-next )
+    basic_machine=m68k-next
+    case $os in
+        -nextstep* )
+      ;;
+        -ns2*)
+          os=-nextstep2
+      ;;
+        *)
+          os=-nextstep3
+      ;;
+    esac
+    ;;
+  nh3000)
+    basic_machine=m68k-harris
+    os=-cxux
+    ;;
+  nh[45]000)
+    basic_machine=m88k-harris
+    os=-cxux
+    ;;
+  nindy960)
+    basic_machine=i960-intel
+    os=-nindy
+    ;;
+  mon960)
+    basic_machine=i960-intel
+    os=-mon960
+    ;;
+  nonstopux)
+    basic_machine=mips-compaq
+    os=-nonstopux
+    ;;
+  np1)
+    basic_machine=np1-gould
+    ;;
+  neo-tandem)
+    basic_machine=neo-tandem
+    ;;
+  nse-tandem)
+    basic_machine=nse-tandem
+    ;;
+  nsr-tandem)
+    basic_machine=nsr-tandem
+    ;;
+  op50n-* | op60c-*)
+    basic_machine=hppa1.1-oki
+    os=-proelf
+    ;;
+  openrisc | openrisc-*)
+    basic_machine=or32-unknown
+    ;;
+  os400)
+    basic_machine=powerpc-ibm
+    os=-os400
+    ;;
+  OSE68000 | ose68000)
+    basic_machine=m68000-ericsson
+    os=-ose
+    ;;
+  os68k)
+    basic_machine=m68k-none
+    os=-os68k
+    ;;
+  pa-hitachi)
+    basic_machine=hppa1.1-hitachi
+    os=-hiuxwe2
+    ;;
+  paragon)
+    basic_machine=i860-intel
+    os=-osf
+    ;;
+  parisc)
+    basic_machine=hppa-unknown
+    os=-linux
+    ;;
+  parisc-*)
+    basic_machine=hppa-`echo $basic_machine | sed 's/^[^-]*-//'`
+    os=-linux
+    ;;
+  pbd)
+    basic_machine=sparc-tti
+    ;;
+  pbb)
+    basic_machine=m68k-tti
+    ;;
+  pc532 | pc532-*)
+    basic_machine=ns32k-pc532
+    ;;
+  pc98)
+    basic_machine=i386-pc
+    ;;
+  pc98-*)
+    basic_machine=i386-`echo $basic_machine | sed 's/^[^-]*-//'`
+    ;;
+  pentium | p5 | k5 | k6 | nexgen | viac3)
+    basic_machine=i586-pc
+    ;;
+  pentiumpro | p6 | 6x86 | athlon | athlon_*)
+    basic_machine=i686-pc
+    ;;
+  pentiumii | pentium2 | pentiumiii | pentium3)
+    basic_machine=i686-pc
+    ;;
+  pentium4)
+    basic_machine=i786-pc
+    ;;
+  pentium-* | p5-* | k5-* | k6-* | nexgen-* | viac3-*)
+    basic_machine=i586-`echo $basic_machine | sed 's/^[^-]*-//'`
+    ;;
+  pentiumpro-* | p6-* | 6x86-* | athlon-*)
+    basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'`
+    ;;
+  pentiumii-* | pentium2-* | pentiumiii-* | pentium3-*)
+    basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'`
+    ;;
+  pentium4-*)
+    basic_machine=i786-`echo $basic_machine | sed 's/^[^-]*-//'`
+    ;;
+  pn)
+    basic_machine=pn-gould
+    ;;
+  power)  basic_machine=power-ibm
+    ;;
+  ppc | ppcbe)  basic_machine=powerpc-unknown
+    ;;
+  ppc-* | ppcbe-*)
+    basic_machine=powerpc-`echo $basic_machine | sed 's/^[^-]*-//'`
+    ;;
+  ppcle | powerpclittle | ppc-le | powerpc-little)
+    basic_machine=powerpcle-unknown
+    ;;
+  ppcle-* | powerpclittle-*)
+    basic_machine=powerpcle-`echo $basic_machine | sed 's/^[^-]*-//'`
+    ;;
+  ppc64)  basic_machine=powerpc64-unknown
+    ;;
+  ppc64-*) basic_machine=powerpc64-`echo $basic_machine | sed 's/^[^-]*-//'`
+    ;;
+  ppc64le | powerpc64little | ppc64-le | powerpc64-little)
+    basic_machine=powerpc64le-unknown
+    ;;
+  ppc64le-* | powerpc64little-*)
+    basic_machine=powerpc64le-`echo $basic_machine | sed 's/^[^-]*-//'`
+    ;;
+  ps2)
+    basic_machine=i386-ibm
+    ;;
+  pw32)
+    basic_machine=i586-unknown
+    os=-pw32
+    ;;
+  rdos)
+    basic_machine=i386-pc
+    os=-rdos
+    ;;
+  rom68k)
+    basic_machine=m68k-rom68k
+    os=-coff
+    ;;
+  rm[46]00)
+    basic_machine=mips-siemens
+    ;;
+  rtpc | rtpc-*)
+    basic_machine=romp-ibm
+    ;;
+  s390 | s390-*)
+    basic_machine=s390-ibm
+    ;;
+  s390x | s390x-*)
+    basic_machine=s390x-ibm
+    ;;
+  sa29200)
+    basic_machine=a29k-amd
+    os=-udi
+    ;;
+  sb1)
+    basic_machine=mipsisa64sb1-unknown
+    ;;
+  sb1el)
+    basic_machine=mipsisa64sb1el-unknown
+    ;;
+  sde)
+    basic_machine=mipsisa32-sde
+    os=-elf
+    ;;
+  sei)
+    basic_machine=mips-sei
+    os=-seiux
+    ;;
+  sequent)
+    basic_machine=i386-sequent
+    ;;
+  sh)
+    basic_machine=sh-hitachi
+    os=-hms
+    ;;
+  sh5el)
+    basic_machine=sh5le-unknown
+    ;;
+  sh64)
+    basic_machine=sh64-unknown
+    ;;
+  sparclite-wrs | simso-wrs)
+    basic_machine=sparclite-wrs
+    os=-vxworks
+    ;;
+  sps7)
+    basic_machine=m68k-bull
+    os=-sysv2
+    ;;
+  spur)
+    basic_machine=spur-unknown
+    ;;
+  st2000)
+    basic_machine=m68k-tandem
+    ;;
+  stratus)
+    basic_machine=i860-stratus
+    os=-sysv4
+    ;;
+  strongarm-* | thumb-*)
+    basic_machine=arm-`echo $basic_machine | sed 's/^[^-]*-//'`
+    ;;
+  sun2)
+    basic_machine=m68000-sun
+    ;;
+  sun2os3)
+    basic_machine=m68000-sun
+    os=-sunos3
+    ;;
+  sun2os4)
+    basic_machine=m68000-sun
+    os=-sunos4
+    ;;
+  sun3os3)
+    basic_machine=m68k-sun
+    os=-sunos3
+    ;;
+  sun3os4)
+    basic_machine=m68k-sun
+    os=-sunos4
+    ;;
+  sun4os3)
+    basic_machine=sparc-sun
+    os=-sunos3
+    ;;
+  sun4os4)
+    basic_machine=sparc-sun
+    os=-sunos4
+    ;;
+  sun4sol2)
+    basic_machine=sparc-sun
+    os=-solaris2
+    ;;
+  sun3 | sun3-*)
+    basic_machine=m68k-sun
+    ;;
+  sun4)
+    basic_machine=sparc-sun
+    ;;
+  sun386 | sun386i | roadrunner)
+    basic_machine=i386-sun
+    ;;
+  sv1)
+    basic_machine=sv1-cray
+    os=-unicos
+    ;;
+  symmetry)
+    basic_machine=i386-sequent
+    os=-dynix
+    ;;
+  t3e)
+    basic_machine=alphaev5-cray
+    os=-unicos
+    ;;
+  t90)
+    basic_machine=t90-cray
+    os=-unicos
+    ;;
+  tile*)
+    basic_machine=$basic_machine-unknown
+    os=-linux-gnu
+    ;;
+  tx39)
+    basic_machine=mipstx39-unknown
+    ;;
+  tx39el)
+    basic_machine=mipstx39el-unknown
+    ;;
+  toad1)
+    basic_machine=pdp10-xkl
+    os=-tops20
+    ;;
+  tower | tower-32)
+    basic_machine=m68k-ncr
+    ;;
+  tpf)
+    basic_machine=s390x-ibm
+    os=-tpf
+    ;;
+  udi29k)
+    basic_machine=a29k-amd
+    os=-udi
+    ;;
+  ultra3)
+    basic_machine=a29k-nyu
+    os=-sym1
+    ;;
+  v810 | necv810)
+    basic_machine=v810-nec
+    os=-none
+    ;;
+  vaxv)
+    basic_machine=vax-dec
+    os=-sysv
+    ;;
+  vms)
+    basic_machine=vax-dec
+    os=-vms
+    ;;
+  vpp*|vx|vx-*)
+    basic_machine=f301-fujitsu
+    ;;
+  vxworks960)
+    basic_machine=i960-wrs
+    os=-vxworks
+    ;;
+  vxworks68)
+    basic_machine=m68k-wrs
+    os=-vxworks
+    ;;
+  vxworks29k)
+    basic_machine=a29k-wrs
+    os=-vxworks
+    ;;
+  w65*)
+    basic_machine=w65-wdc
+    os=-none
+    ;;
+  w89k-*)
+    basic_machine=hppa1.1-winbond
+    os=-proelf
+    ;;
+  xbox)
+    basic_machine=i686-pc
+    os=-mingw32
+    ;;
+  xps | xps100)
+    basic_machine=xps100-honeywell
+    ;;
+  xscale-* | xscalee[bl]-*)
+    basic_machine=`echo $basic_machine | sed 's/^xscale/arm/'`
+    ;;
+  ymp)
+    basic_machine=ymp-cray
+    os=-unicos
+    ;;
+  z8k-*-coff)
+    basic_machine=z8k-unknown
+    os=-sim
+    ;;
+  z80-*-coff)
+    basic_machine=z80-unknown
+    os=-sim
+    ;;
+  none)
+    basic_machine=none-none
+    os=-none
+    ;;
+
+# Here we handle the default manufacturer of certain CPU types.  It is in
+# some cases the only manufacturer, in others, it is the most popular.
+  w89k)
+    basic_machine=hppa1.1-winbond
+    ;;
+  op50n)
+    basic_machine=hppa1.1-oki
+    ;;
+  op60c)
+    basic_machine=hppa1.1-oki
+    ;;
+  romp)
+    basic_machine=romp-ibm
+    ;;
+  mmix)
+    basic_machine=mmix-knuth
+    ;;
+  rs6000)
+    basic_machine=rs6000-ibm
+    ;;
+  vax)
+    basic_machine=vax-dec
+    ;;
+  pdp10)
+    # there are many clones, so DEC is not a safe bet
+    basic_machine=pdp10-unknown
+    ;;
+  pdp11)
+    basic_machine=pdp11-dec
+    ;;
+  we32k)
+    basic_machine=we32k-att
+    ;;
+  sh[1234] | sh[24]a | sh[24]aeb | sh[34]eb | sh[1234]le | sh[23]ele)
+    basic_machine=sh-unknown
+    ;;
+  sparc | sparcv8 | sparcv9 | sparcv9b | sparcv9v)
+    basic_machine=sparc-sun
+    ;;
+  cydra)
+    basic_machine=cydra-cydrome
+    ;;
+  orion)
+    basic_machine=orion-highlevel
+    ;;
+  orion105)
+    basic_machine=clipper-highlevel
+    ;;
+  mac | mpw | mac-mpw)
+    basic_machine=m68k-apple
+    ;;
+  pmac | pmac-mpw)
+    basic_machine=powerpc-apple
+    ;;
+  *-unknown)
+    # Make sure to match an already-canonicalized machine name.
+    ;;
+  *)
+    echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2
+    exit 1
+    ;;
+esac
+
+# Here we canonicalize certain aliases for manufacturers.
+case $basic_machine in
+  *-digital*)
+    basic_machine=`echo $basic_machine | sed 's/digital.*/dec/'`
+    ;;
+  *-commodore*)
+    basic_machine=`echo $basic_machine | sed 's/commodore.*/cbm/'`
+    ;;
+  *)
+    ;;
+esac
+
+# Decode manufacturer-specific aliases for certain operating systems.
+
+if [ x"$os" != x"" ]
+then
+case $os in
+  # First match some system type aliases
+  # that might get confused with valid system types.
+  # -solaris* is a basic system type, with this one exception.
+  -auroraux)
+    os=-auroraux
+    ;;
+  -solaris1 | -solaris1.*)
+    os=`echo $os | sed -e 's|solaris1|sunos4|'`
+    ;;
+  -solaris)
+    os=-solaris2
+    ;;
+  -svr4*)
+    os=-sysv4
+    ;;
+  -unixware*)
+    os=-sysv4.2uw
+    ;;
+  -gnu/linux*)
+    os=`echo $os | sed -e 's|gnu/linux|linux-gnu|'`
+    ;;
+  # First accept the basic system types.
+  # The portable systems comes first.
+  # Each alternative MUST END IN A *, to match a version number.
+  # -sysv* is not here because it comes later, after sysvr4.
+  -gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \
+        | -*vms* | -sco* | -esix* | -isc* | -aix* | -cnk* | -sunos | -sunos[34]*\
+        | -hpux* | -unos* | -osf* | -luna* | -dgux* | -auroraux* | -solaris* \
+        | -sym* | -kopensolaris* \
+        | -amigaos* | -amigados* | -msdos* | -newsos* | -unicos* | -aof* \
+        | -aos* | -aros* \
+        | -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \
+        | -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \
+        | -hiux* | -386bsd* | -knetbsd* | -mirbsd* | -netbsd* \
+        | -openbsd* | -solidbsd* \
+        | -ekkobsd* | -kfreebsd* | -freebsd* | -riscix* | -lynxos* \
+        | -bosx* | -nextstep* | -cxux* | -aout* | -elf* | -oabi* \
+        | -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \
+        | -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \
+        | -chorusos* | -chorusrdb* | -cegcc* \
+        | -cygwin* | -pe* | -psos* | -moss* | -proelf* | -rtems* \
+        | -mingw32* | -linux-gnu* | -linux-android* \
+        | -linux-newlib* | -linux-uclibc* \
+        | -uxpv* | -beos* | -mpeix* | -udk* \
+        | -interix* | -uwin* | -mks* | -rhapsody* | -darwin* | -opened* \
+        | -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \
+        | -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \
+        | -os2* | -vos* | -palmos* | -uclinux* | -nucleus* \
+        | -morphos* | -superux* | -rtmk* | -rtmk-nova* | -windiss* \
+        | -powermax* | -dnix* | -nx6 | -nx7 | -sei* | -dragonfly* \
+        | -skyos* | -haiku* | -rdos* | -toppers* | -drops* | -es* | -bitrig*)
+  # Remember, each alternative MUST END IN *, to match a version number.
+    ;;
+  -qnx*)
+    case $basic_machine in
+        x86-* | i*86-*)
+      ;;
+        *)
+      os=-nto$os
+      ;;
+    esac
+    ;;
+  -nto-qnx*)
+    ;;
+  -nto*)
+    os=`echo $os | sed -e 's|nto|nto-qnx|'`
+    ;;
+  -sim | -es1800* | -hms* | -xray | -os68k* | -none* | -v88r* \
+        | -windows* | -osx | -abug | -netware* | -os9* | -beos* | -haiku* \
+        | -macos* | -mpw* | -magic* | -mmixware* | -mon960* | -lnews*)
+    ;;
+  -mac*)
+    os=`echo $os | sed -e 's|mac|macos|'`
+    ;;
+  -linux-dietlibc)
+    os=-linux-dietlibc
+    ;;
+  -linux*)
+    os=`echo $os | sed -e 's|linux|linux-gnu|'`
+    ;;
+  -sunos5*)
+    os=`echo $os | sed -e 's|sunos5|solaris2|'`
+    ;;
+  -sunos6*)
+    os=`echo $os | sed -e 's|sunos6|solaris3|'`
+    ;;
+  -opened*)
+    os=-openedition
+    ;;
+  -os400*)
+    os=-os400
+    ;;
+  -wince*)
+    os=-wince
+    ;;
+  -osfrose*)
+    os=-osfrose
+    ;;
+  -osf*)
+    os=-osf
+    ;;
+  -utek*)
+    os=-bsd
+    ;;
+  -dynix*)
+    os=-bsd
+    ;;
+  -acis*)
+    os=-aos
+    ;;
+  -atheos*)
+    os=-atheos
+    ;;
+  -syllable*)
+    os=-syllable
+    ;;
+  -386bsd)
+    os=-bsd
+    ;;
+  -ctix* | -uts*)
+    os=-sysv
+    ;;
+  -nova*)
+    os=-rtmk-nova
+    ;;
+  -ns2 )
+    os=-nextstep2
+    ;;
+  -nsk*)
+    os=-nsk
+    ;;
+  # Preserve the version number of sinix5.
+  -sinix5.*)
+    os=`echo $os | sed -e 's|sinix|sysv|'`
+    ;;
+  -sinix*)
+    os=-sysv4
+    ;;
+  -tpf*)
+    os=-tpf
+    ;;
+  -triton*)
+    os=-sysv3
+    ;;
+  -oss*)
+    os=-sysv3
+    ;;
+  -svr4)
+    os=-sysv4
+    ;;
+  -svr3)
+    os=-sysv3
+    ;;
+  -sysvr4)
+    os=-sysv4
+    ;;
+  # This must come after -sysvr4.
+  -sysv*)
+    ;;
+  -ose*)
+    os=-ose
+    ;;
+  -es1800*)
+    os=-ose
+    ;;
+  -xenix)
+    os=-xenix
+    ;;
+  -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*)
+    os=-mint
+    ;;
+  -aros*)
+    os=-aros
+    ;;
+  -kaos*)
+    os=-kaos
+    ;;
+  -zvmoe)
+    os=-zvmoe
+    ;;
+  -dicos*)
+    os=-dicos
+    ;;
+  -nacl*)
+    ;;
+  -ps4)
+    ;;
+  -none)
+    ;;
+  *)
+    # Get rid of the `-' at the beginning of $os.
+    os=`echo $os | sed 's/[^-]*-//'`
+    echo Invalid configuration \`$1\': system \`$os\' not recognized 1>&2
+    exit 1
+    ;;
+esac
+else
+
+# Here we handle the default operating systems that come with various machines.
+# The value should be what the vendor currently ships out the door with their
+# machine or put another way, the most popular os provided with the machine.
+
+# Note that if you're going to try to match "-MANUFACTURER" here (say,
+# "-sun"), then you have to tell the case statement up towards the top
+# that MANUFACTURER isn't an operating system.  Otherwise, code above
+# will signal an error saying that MANUFACTURER isn't an operating
+# system, and we'll never get to this point.
+
+case $basic_machine in
+  score-*)
+    os=-elf
+    ;;
+  spu-*)
+    os=-elf
+    ;;
+  *-acorn)
+    os=-riscix1.2
+    ;;
+  arm*-rebel)
+    os=-linux
+    ;;
+  arm*-semi)
+    os=-aout
+    ;;
+  c4x-* | tic4x-*)
+    os=-coff
+    ;;
+  tic54x-*)
+    os=-coff
+    ;;
+  tic55x-*)
+    os=-coff
+    ;;
+  tic6x-*)
+    os=-coff
+    ;;
+  # This must come before the *-dec entry.
+  pdp10-*)
+    os=-tops20
+    ;;
+  pdp11-*)
+    os=-none
+    ;;
+  *-dec | vax-*)
+    os=-ultrix4.2
+    ;;
+  m68*-apollo)
+    os=-domain
+    ;;
+  i386-sun)
+    os=-sunos4.0.2
+    ;;
+  m68000-sun)
+    os=-sunos3
+    # This also exists in the configure program, but was not the
+    # default.
+    # os=-sunos4
+    ;;
+  m68*-cisco)
+    os=-aout
+    ;;
+  mep-*)
+    os=-elf
+    ;;
+  mips*-cisco)
+    os=-elf
+    ;;
+  mips*-*)
+    os=-elf
+    ;;
+  or32-*)
+    os=-coff
+    ;;
+  *-tti)  # must be before sparc entry or we get the wrong os.
+    os=-sysv3
+    ;;
+  sparc-* | *-sun)
+    os=-sunos4.1.1
+    ;;
+  *-be)
+    os=-beos
+    ;;
+  *-haiku)
+    os=-haiku
+    ;;
+  *-ibm)
+    os=-aix
+    ;;
+  *-knuth)
+    os=-mmixware
+    ;;
+  *-wec)
+    os=-proelf
+    ;;
+  *-winbond)
+    os=-proelf
+    ;;
+  *-oki)
+    os=-proelf
+    ;;
+  *-hp)
+    os=-hpux
+    ;;
+  *-hitachi)
+    os=-hiux
+    ;;
+  i860-* | *-att | *-ncr | *-altos | *-motorola | *-convergent)
+    os=-sysv
+    ;;
+  *-cbm)
+    os=-amigaos
+    ;;
+  *-dg)
+    os=-dgux
+    ;;
+  *-dolphin)
+    os=-sysv3
+    ;;
+  m68k-ccur)
+    os=-rtu
+    ;;
+  m88k-omron*)
+    os=-luna
+    ;;
+  *-next )
+    os=-nextstep
+    ;;
+  *-sequent)
+    os=-ptx
+    ;;
+  *-crds)
+    os=-unos
+    ;;
+  *-ns)
+    os=-genix
+    ;;
+  i370-*)
+    os=-mvs
+    ;;
+  *-next)
+    os=-nextstep3
+    ;;
+  *-gould)
+    os=-sysv
+    ;;
+  *-highlevel)
+    os=-bsd
+    ;;
+  *-encore)
+    os=-bsd
+    ;;
+  *-sgi)
+    os=-irix
+    ;;
+  *-siemens)
+    os=-sysv4
+    ;;
+  *-masscomp)
+    os=-rtu
+    ;;
+  f30[01]-fujitsu | f700-fujitsu)
+    os=-uxpv
+    ;;
+  *-rom68k)
+    os=-coff
+    ;;
+  *-*bug)
+    os=-coff
+    ;;
+  *-apple)
+    os=-macos
+    ;;
+  *-atari*)
+    os=-mint
+    ;;
+  *)
+    os=-none
+    ;;
+esac
+fi
+
+# Here we handle the case where we know the os, and the CPU type, but not the
+# manufacturer.  We pick the logical manufacturer.
+vendor=unknown
+case $basic_machine in
+  *-unknown)
+    case $os in
+      -riscix*)
+        vendor=acorn
+        ;;
+      -sunos*)
+        vendor=sun
+        ;;
+      -cnk*|-aix*)
+        vendor=ibm
+        ;;
+      -beos*)
+        vendor=be
+        ;;
+      -hpux*)
+        vendor=hp
+        ;;
+      -mpeix*)
+        vendor=hp
+        ;;
+      -hiux*)
+        vendor=hitachi
+        ;;
+      -unos*)
+        vendor=crds
+        ;;
+      -dgux*)
+        vendor=dg
+        ;;
+      -luna*)
+        vendor=omron
+        ;;
+      -genix*)
+        vendor=ns
+        ;;
+      -mvs* | -opened*)
+        vendor=ibm
+        ;;
+      -os400*)
+        vendor=ibm
+        ;;
+      -ptx*)
+        vendor=sequent
+        ;;
+      -tpf*)
+        vendor=ibm
+        ;;
+      -vxsim* | -vxworks* | -windiss*)
+        vendor=wrs
+        ;;
+      -aux*)
+        vendor=apple
+        ;;
+      -hms*)
+        vendor=hitachi
+        ;;
+      -mpw* | -macos*)
+        vendor=apple
+        ;;
+      -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*)
+        vendor=atari
+        ;;
+      -vos*)
+        vendor=stratus
+        ;;
+    esac
+    basic_machine=`echo $basic_machine | sed "s/unknown/$vendor/"`
+    ;;
+esac
+
+echo $basic_machine$os
+exit
+
+# Local variables:
+# eval: (add-hook 'write-file-hooks 'time-stamp)
+# time-stamp-start: "timestamp='"
+# time-stamp-format: "%:y-%02m-%02d"
+# time-stamp-end: "'"
+# End:

cmd/gllgo/gllgo.go

func runPasses(opts *driverOptions, tm llvm.TargetMachine, m llvm.Module) {
   mpm := llvm.NewPassManager()
   defer mpm.Dispose()
 
   pmb := llvm.NewPassManagerBuilder()
   defer pmb.Dispose()
 
   pmb.SetOptLevel(opts.optLevel)
   pmb.SetSizeLevel(opts.sizeLevel)
 
-  target := tm.TargetData()
-  mpm.Add(target)
-  fpm.Add(target)
   tm.AddAnalysisPasses(mpm)
   tm.AddAnalysisPasses(fpm)
 
   mpm.AddVerifierPass()
   fpm.AddVerifierPass()
 
   pmb.Populate(mpm)
   pmb.PopulateFunc(fpm)
 
if opts.gccgoPath == "" {
           args = append(args, "-Wl,-rpath,"+libdir)
         }
       }
 
       args = append(args, "-lgobegin-llgo")
       if opts.staticLibgo {
         args = append(args, "-Wl,-Bstatic", "-lgo-llgo", "-Wl,-Bdynamic", "-lpthread", "-lm")
       } else {
-        args = append(args, "-lgo-llgo")
+        args = append(args, "-lgo-llgo", "-lm")
       }
     } else {
       linkerPath = opts.gccgoPath
       if opts.staticLibgo {
         args = append(args, "-static-libgo")
       }
     }
 

irgen/runtime.go

type runtimeInterface struct {
 
   // Exception handling support
   gccgoPersonality   llvm.Value
   gccgoExceptionType llvm.Type
 
   // Runtime intrinsics
   append,
   assertInterface,
+  byteArrayToString,
   canRecover,
   chanCap,
   chanLen,
   chanrecv2,
   checkDefer,
   checkInterfaceType,
   builtinClose,
   convertInterface,
type runtimeInterface struct {
   mapiter2,
   mapiterinit,
   mapiternext,
   mapIndex,
   mapLen,
   New,
   newChannel,
   newMap,
-  NewNopointers,
   newSelect,
   panic,
   printBool,
   printComplex,
   printDouble,
   printEmptyInterface,
   printInterface,
   printInt64,
type runtimeInterface struct {
   selectsend,
   selectgo,
   sendBig,
   setDeferRetaddr,
   strcmp,
   stringiter2,
   stringPlus,
   stringSlice,
+  stringToByteArray,
   stringToIntArray,
   typeDescriptorsEqual,
   undefer runtimeFnInfo
 }
 
 func newRuntimeInterface(module llvm.Module, tm *llvmTypeMap) (*runtimeInterface, error) {
   var ri runtimeInterface
 
   Bool := types.Typ[types.Bool]
   Complex128 := types.Typ[types.Complex128]
   Float64 := types.Typ[types.Float64]
   Int32 := types.Typ[types.Int32]
   Int64 := types.Typ[types.Int64]
   Int := types.Typ[types.Int]
   Rune := types.Typ[types.Rune]
   String := types.Typ[types.String]
   Uintptr := types.Typ[types.Uintptr]
   UnsafePointer := types.Typ[types.UnsafePointer]
 
   EmptyInterface := types.NewInterface(nil, nil)
+  ByteSlice := types.NewSlice(types.Typ[types.Byte])
   IntSlice := types.NewSlice(types.Typ[types.Int])
 
   for _, rt := range [...]struct {
     name      string
     rfi       *runtimeFnInfo
     args, res []types.Type
     attrs     []llvm.Attribute
   }{
     {
       name: "__go_append",
       rfi:  &ri.append,
       args: []types.Type{IntSlice, UnsafePointer, Uintptr, Uintptr},
       res:  []types.Type{IntSlice},
     },
     {
       name: "__go_assert_interface",
       rfi:  &ri.assertInterface,
       args: []types.Type{UnsafePointer, UnsafePointer},
       res:  []types.Type{UnsafePointer},
     },
     {
+      name:  "__go_byte_array_to_string",
+      rfi:   &ri.byteArrayToString,
+      args:  []types.Type{UnsafePointer, Int},
+      res:   []types.Type{String},
+      attrs: []llvm.Attribute{llvm.NoUnwindAttribute},
+    },
+    {
       name: "__go_can_recover",
       rfi:  &ri.canRecover,
       args: []types.Type{UnsafePointer},
       res:  []types.Type{Bool},
     },
     {
       name: "__go_chan_cap",
       rfi:  &ri.chanCap,
for _, rt := range [...]struct {
     },
     {
       name: "__go_map_len",
       rfi:  &ri.mapLen,
       args: []types.Type{UnsafePointer},
       res:  []types.Type{Int},
     },
     {
-      name: "__go_new",
-      rfi:  &ri.New,
-      args: []types.Type{UnsafePointer, Uintptr},
-      res:  []types.Type{UnsafePointer},
+      name:  "__go_new",
+      rfi:   &ri.New,
+      args:  []types.Type{UnsafePointer, Uintptr},
+      res:   []types.Type{UnsafePointer},
+      attrs: []llvm.Attribute{llvm.NoUnwindAttribute},
     },
     {
       name: "__go_new_channel",
       rfi:  &ri.newChannel,
       args: []types.Type{UnsafePointer, Uintptr},
       res:  []types.Type{UnsafePointer},
     },
     {
       name: "__go_new_map",
       rfi:  &ri.newMap,
       args: []types.Type{UnsafePointer, Uintptr},
       res:  []types.Type{UnsafePointer},
     },
     {
-      name: "__go_new_nopointers",
-      rfi:  &ri.NewNopointers,
-      args: []types.Type{UnsafePointer, Uintptr},
-      res:  []types.Type{UnsafePointer},
-    },
-    {
       name: "runtime.newselect",
       rfi:  &ri.newSelect,
       args: []types.Type{Int32},
       res:  []types.Type{UnsafePointer},
     },
     {
       name:  "__go_panic",
       rfi:   &ri.panic,
for _, rt := range [...]struct {
     },
     {
       name: "__go_string_slice",
       rfi:  &ri.stringSlice,
       args: []types.Type{String, Int, Int},
       res:  []types.Type{String},
     },
     {
+      name:  "__go_string_to_byte_array",
+      rfi:   &ri.stringToByteArray,
+      args:  []types.Type{String},
+      res:   []types.Type{ByteSlice},
+      attrs: []llvm.Attribute{llvm.NoUnwindAttribute},
+    },
+    {
       name: "__go_string_to_int_array",
       rfi:  &ri.stringToIntArray,
       args: []types.Type{String},
       res:  []types.Type{IntSlice},
     },
     {
       name: "runtime.stringiter2",
       rfi:  &ri.stringiter2,
func (fr *frame) createZExtOrTrunc(v llvm.Value, t llvm.Type, name string) llvm.Value {
   case n < 0:
     v = fr.builder.CreateZExt(v, fr.target.IntPtrType(), name)
   case n > 0:
     v = fr.builder.CreateTrunc(v, fr.target.IntPtrType(), name)
   }
   return v
 }
 
-func (fr *frame) createMalloc(size llvm.Value) llvm.Value {
-  return fr.runtime.NewNopointers.callOnly(fr,
-    llvm.ConstNull(llvm.PointerType(llvm.Int8Type(), 0)),
-    fr.createZExtOrTrunc(size, fr.target.IntPtrType(), ""))[0]
-}
-
 func (fr *frame) createTypeMalloc(t types.Type) llvm.Value {
   size := llvm.ConstInt(fr.target.IntPtrType(), uint64(fr.llvmtypes.Sizeof(t)), false)
   malloc := fr.runtime.New.callOnly(fr, fr.types.ToRuntime(t), size)[0]
   return fr.builder.CreateBitCast(malloc, llvm.PointerType(fr.types.ToLLVM(t), 0), "")
 }
 
 func (fr *frame) memsetZero(ptr llvm.Value, size llvm.Value) {
   memset := fr.runtime.memset

irgen/ssa.go

for _, local := range f.Locals {
     value := newValue(bcalloca, local.Type())
     fr.env[local] = value
   }
 
   // If the function contains any defers, we must first create
   // an unwind block. We can short-circuit the check for defers with
   // f.Recover != nil.
   if f.Recover != nil || hasDefer(f) {
-    fr.unwindBlock = llvm.AddBasicBlock(fr.function, "")
+    fr.unwindBlock = llvm.AddBasicBlock(fr.function, "unwind")
     fr.frameptr = fr.builder.CreateAlloca(llvm.Int8Type(), "")
   }
 
   // Keep track of the block into which we need to insert the call
   // to __go_register_gc_roots. This needs to be inserted after the
   // init guard check under the llgo ABI.
   var registerGcBlock llvm.BasicBlock
 
if llblock.IsNil() {
       continue
     }
     fr.translateBlock(block, llblock)
   }
 
   fr.fixupPhis()
 
   if !fr.unwindBlock.IsNil() {
-    fr.setupUnwindBlock(f.Recover, f.Signature.Results())
+    fr.setupUnwindBlock(f.Recover)
   }
 
   // The init function needs to register the GC roots first. We do this
   // after generating code for it because allocations may have caused
   // additional GC roots to be created.
   if fr.isInit {
     fr.builder.SetInsertPointBefore(registerGcBlock.FirstInstruction())
     fr.registerGcRoots()
func (fr *frame) runDefers() {
   fr.createLandingPad(false)
   fr.runtime.checkDefer.callOnly(fr, fr.frameptr)
   fr.builder.CreateBr(loopbb)
 
   fr.builder.SetInsertPointAtEnd(loopbb)
   fr.runtime.undefer.invoke(fr, retrylpad, fr.frameptr)
 }
 
-func (fr *frame) setupUnwindBlock(rec *ssa.BasicBlock, results *types.Tuple) {
-  recoverbb := llvm.AddBasicBlock(fr.function, "")
+func (fr *frame) setupUnwindBlock(rec *ssa.BasicBlock) {
+  var recoverbb llvm.BasicBlock
   if rec != nil {
-    fr.translateBlock(rec, recoverbb)
-  } else if results.Len() == 0 || results.At(0).Anonymous() {
-    // TODO(pcc): Remove this code after https://codereview.appspot.com/87210044/ lands
-    fr.builder.SetInsertPointAtEnd(recoverbb)
-    values := make([]llvm.Value, results.Len())
-    for i := range values {
-      values[i] = llvm.ConstNull(fr.llvmtypes.ToLLVM(results.At(i).Type()))
-    }
-    fr.retInf.encode(llvm.GlobalContext(), fr.allocaBuilder, fr.builder, values)
+    recoverbb = fr.blocks[rec.Index]
   } else {
+    recoverbb = llvm.AddBasicBlock(fr.function, "recover")
     fr.builder.SetInsertPointAtEnd(recoverbb)
     fr.builder.CreateUnreachable()
   }
 
   checkunwindbb := llvm.AddBasicBlock(fr.function, "")
   fr.builder.SetInsertPointAtEnd(checkunwindbb)
   exc := fr.createLandingPad(true)
   fr.runDefers()

irgen/targets.go

func llvmDataLayout(triple string) (string, error) {
   for target := llvm.FirstTarget(); target.C != nil; target = target.NextTarget() {
     if arch == target.Name() {
       machine := target.CreateTargetMachine(
         triple, "", "",
         llvm.CodeGenLevelDefault,
         llvm.RelocDefault,
         llvm.CodeModelDefault,
       )
-      target := machine.TargetData().String()
+      targetData := machine.CreateTargetData()
+      targetDataLayout := targetData.String()
+      targetData.Dispose()
       machine.Dispose()
-      return target, nil
+      return targetDataLayout, nil
     }
   }
   return "", fmt.Errorf("Invalid target triple: %s", triple)
 }
 
 // Based on parseArch from LLVM's lib/Support/Triple.cpp.
 // This is used to match the target machine type.
 func parseArch(arch string) string {

irgen/typemap.go

type TypeMap struct {
 
   commonTypeType, uncommonTypeType, ptrTypeType, funcTypeType, arrayTypeType, sliceTypeType, mapTypeType, chanTypeType, interfaceTypeType, structTypeType llvm.Type
   mapDescType                                                                                                                                             llvm.Type
 
   methodType, imethodType, structFieldType llvm.Type
 
   typeSliceType, methodSliceType, imethodSliceType, structFieldSliceType llvm.Type
 
+  funcValType             llvm.Type
   hashFnType, equalFnType llvm.Type
 
-  hashFnEmptyInterface, hashFnInterface, hashFnFloat, hashFnComplex, hashFnString, hashFnIdentity, hashFnError        llvm.Value
-  equalFnEmptyInterface, equalFnInterface, equalFnFloat, equalFnComplex, equalFnString, equalFnIdentity, equalFnError llvm.Value
+  algsEmptyInterface,
+  algsInterface,
+  algsFloat,
+  algsComplex,
+  algsString,
+  algsIdentity,
+  algsError algorithms
+}
 
-  zeroType  llvm.Type
-  zeroValue llvm.Value
+type algorithms struct {
+  hash, hashDescriptor, equal, equalDescriptor llvm.Value
 }
 
 func NewLLVMTypeMap(ctx llvm.Context, target llvm.TargetData) *llvmTypeMap {
   // spec says int is either 32-bit or 64-bit.
   // ABI currently requires sizeof(int) == sizeof(uint) == sizeof(uintptr).
   inttype := ctx.IntType(8 * target.PointerSize())
 
   i8ptr := llvm.PointerType(llvm.Int8Type(), 0)
func NewTypeMap(pkg *ssa.Package, llvmtm *llvmTypeMap, module llvm.Module, r *runtimeInterface, mr MethodResolver) *TypeMap {
 
   tm.mc.init(pkg.Prog, &tm.MethodSetCache)
 
   uintptrType := tm.inttype
   voidPtrType := llvm.PointerType(tm.ctx.Int8Type(), 0)
   boolType := llvm.Int8Type()
   stringPtrType := llvm.PointerType(tm.stringType, 0)
 
-  // Create runtime algorithm function types.
+  tm.funcValType = tm.ctx.StructCreateNamed("funcVal")
+  tm.funcValType.StructSetBody([]llvm.Type{
+    llvm.PointerType(llvm.FunctionType(llvm.VoidType(), []llvm.Type{}, false), 0),
+  }, false)
+
   params := []llvm.Type{voidPtrType, uintptrType}
   tm.hashFnType = llvm.FunctionType(uintptrType, params, false)
   params = []llvm.Type{voidPtrType, voidPtrType, uintptrType}
   tm.equalFnType = llvm.FunctionType(boolType, params, false)
 
-  tm.hashFnEmptyInterface = llvm.AddFunction(tm.module, "__go_type_hash_empty_interface", tm.hashFnType)
-  tm.hashFnInterface = llvm.AddFunction(tm.module, "__go_type_hash_interface", tm.hashFnType)
-  tm.hashFnFloat = llvm.AddFunction(tm.module, "__go_type_hash_float", tm.hashFnType)
-  tm.hashFnComplex = llvm.AddFunction(tm.module, "__go_type_hash_complex", tm.hashFnType)
-  tm.hashFnString = llvm.AddFunction(tm.module, "__go_type_hash_string", tm.hashFnType)
-  tm.hashFnIdentity = llvm.AddFunction(tm.module, "__go_type_hash_identity", tm.hashFnType)
-  tm.hashFnError = llvm.AddFunction(tm.module, "__go_type_hash_error", tm.hashFnType)
-
-  tm.equalFnEmptyInterface = llvm.AddFunction(tm.module, "__go_type_equal_empty_interface", tm.equalFnType)
-  tm.equalFnInterface = llvm.AddFunction(tm.module, "__go_type_equal_interface", tm.equalFnType)
-  tm.equalFnFloat = llvm.AddFunction(tm.module, "__go_type_equal_float", tm.equalFnType)
-  tm.equalFnComplex = llvm.AddFunction(tm.module, "__go_type_equal_complex", tm.equalFnType)
-  tm.equalFnString = llvm.AddFunction(tm.module, "__go_type_equal_string", tm.equalFnType)
-  tm.equalFnIdentity = llvm.AddFunction(tm.module, "__go_type_equal_identity", tm.equalFnType)
-  tm.equalFnError = llvm.AddFunction(tm.module, "__go_type_equal_error", tm.equalFnType)
-
-  // The body of this type is set in emitTypeDescInitializers once we have scanned
-  // every type, as it needs to be as large and well aligned as the
-  // largest/most aligned type.
-  tm.zeroType = tm.ctx.StructCreateNamed("zero")
-  tm.zeroValue = llvm.AddGlobal(tm.module, tm.zeroType, "go$zerovalue")
-  tm.zeroValue.SetLinkage(llvm.CommonLinkage)
-  tm.zeroValue.SetInitializer(llvm.ConstNull(tm.zeroType))
+  typeAlgorithms := [...]struct {
+    Name string
+    *algorithms
+  }{
+    {"empty_interface", &tm.algsEmptyInterface},
+    {"interface", &tm.algsInterface},
+    {"float", &tm.algsFloat},
+    {"complex", &tm.algsComplex},
+    {"string", &tm.algsString},
+    {"identity", &tm.algsIdentity},
+    {"error", &tm.algsError},
+  }
+  for _, typeAlgs := range typeAlgorithms {
+    hashFnName := "__go_type_hash_" + typeAlgs.Name
+    hashDescriptorName := hashFnName + "_descriptor"
+    equalFnName := "__go_type_equal_" + typeAlgs.Name
+    equalDescriptorName := equalFnName + "_descriptor"
+    typeAlgs.hash = llvm.AddGlobal(tm.module, tm.hashFnType, hashFnName)
+    typeAlgs.hashDescriptor = llvm.AddGlobal(tm.module, tm.funcValType, hashDescriptorName)
+    typeAlgs.equal = llvm.AddGlobal(tm.module, tm.equalFnType, equalFnName)
+    typeAlgs.equalDescriptor = llvm.AddGlobal(tm.module, tm.funcValType, equalDescriptorName)
+  }
 
   tm.commonTypeType = tm.ctx.StructCreateNamed("commonType")
   commonTypeTypePtr := llvm.PointerType(tm.commonTypeType, 0)
 
   tm.methodType = tm.ctx.StructCreateNamed("method")
   tm.methodType.StructSetBody([]llvm.Type{
     stringPtrType,     // name
     stringPtrType,     // pkgPath
func NewTypeMap(pkg *ssa.Package, llvmtm *llvmTypeMap, module llvm.Module, r *runtimeInterface, mr MethodResolver) *TypeMap {
   }, false)
 
   tm.commonTypeType.StructSetBody([]llvm.Type{
     tm.ctx.Int8Type(),                        // Kind
     tm.ctx.Int8Type(),                        // align
     tm.ctx.Int8Type(),                        // fieldAlign
     uintptrType,                              // size
     tm.ctx.Int32Type(),                       // hash
-    llvm.PointerType(tm.hashFnType, 0),       // hashfn
-    llvm.PointerType(tm.equalFnType, 0),      // equalfn
+    llvm.PointerType(tm.funcValType, 0),      // hashfn
+    llvm.PointerType(tm.funcValType, 0),      // equalfn
     voidPtrType,                              // gc
     stringPtrType,                            // string
     llvm.PointerType(tm.uncommonTypeType, 0), // uncommonType
     commonTypeTypePtr,                        // ptrToThis
-    llvm.PointerType(tm.zeroType, 0),         // zero
   }, false)
 
   tm.typeSliceType = tm.makeNamedSliceType("typeSlice", commonTypeTypePtr)
 
   tm.ptrTypeType = tm.ctx.StructCreateNamed("ptrType")
   tm.ptrTypeType.StructSetBody([]llvm.Type{
     tm.commonTypeType,
     commonTypeTypePtr,
if changed {
           maxSize = size
         }
         if align := tm.Alignof(t.typ); align > maxAlign {
           maxAlign = align
         }
       }
     }
   }
-
-  tm.zeroType.StructSetBody([]llvm.Type{llvm.ArrayType(tm.ctx.Int8Type(), int(maxSize))}, false)
-  tm.zeroValue.SetAlignment(int(maxAlign))
 }
 
 const (
   // From libgo/runtime/mgc0.h
   gcOpcodeEND = iota
   gcOpcodePTR
   gcOpcodeAPTR
   gcOpcodeARRAY_START
case *types.Struct:
     return tm.makeStructType(t, u)
   case *types.Interface:
     return tm.makeInterfaceType(t, u)
   default:
     panic(fmt.Sprintf("unhandled type: %#v", t))
   }
 }
 
-type algorithmFns struct {
-  hash, equal llvm.Value
-}
-
-func (tm *TypeMap) getStructAlgorithmFunctions(st *types.Struct) (hash, equal llvm.Value) {
-  if algs, ok := tm.algs.At(st).(algorithmFns); ok {
-    return algs.hash, algs.equal
+func (tm *TypeMap) getStructAlgorithms(st *types.Struct) algorithms {
+  if algs, ok := tm.algs.At(st).(algorithms); ok {
+    return algs
   }
 
   hashes := make([]llvm.Value, st.NumFields())
   equals := make([]llvm.Value, st.NumFields())
 
   for i := range hashes {
-    fhash, fequal := tm.getAlgorithmFunctions(st.Field(i).Type())
-    if fhash == tm.hashFnError {
-      return fhash, fequal
+    algs := tm.getAlgorithms(st.Field(i).Type())
+    if algs.hashDescriptor == tm.algsError.hashDescriptor {
+      return algs
     }
-    hashes[i], equals[i] = fhash, fequal
+    hashes[i], equals[i] = algs.hash, algs.equal
   }
 
   i8ptr := llvm.PointerType(tm.ctx.Int8Type(), 0)
   llsptrty := llvm.PointerType(tm.ToLLVM(st), 0)
 
   builder := tm.ctx.NewBuilder()
   defer builder.Dispose()
 
-  hash = llvm.AddFunction(tm.module, tm.mc.mangleHashFunctionName(st), tm.hashFnType)
+  hashFunctionName := tm.mc.mangleHashFunctionName(st)
+  hash := llvm.AddFunction(tm.module, hashFunctionName, tm.hashFnType)
   hash.SetLinkage(llvm.LinkOnceODRLinkage)
+  hashDescriptor := tm.createAlgorithmDescriptor(hashFunctionName+"_descriptor", hash)
+
   builder.SetInsertPointAtEnd(llvm.AddBasicBlock(hash, "entry"))
   sptr := builder.CreateBitCast(hash.Param(0), llsptrty, "")
 
   hashval := llvm.ConstNull(tm.inttype)
   i33 := llvm.ConstInt(tm.inttype, 33, false)
 
   for i, fhash := range hashes {
     fptr := builder.CreateStructGEP(sptr, i, "")
     fptr = builder.CreateBitCast(fptr, i8ptr, "")
-
     fsize := llvm.ConstInt(tm.inttype, uint64(tm.sizes.Sizeof(st.Field(i).Type())), false)
-
     hashcall := builder.CreateCall(fhash, []llvm.Value{fptr, fsize}, "")
     hashval = builder.CreateMul(hashval, i33, "")
     hashval = builder.CreateAdd(hashval, hashcall, "")
   }
 
   builder.CreateRet(hashval)
 
-  equal = llvm.AddFunction(tm.module, tm.mc.mangleEqualFunctionName(st), tm.equalFnType)
+  equalFunctionName := tm.mc.mangleEqualFunctionName(st)
+  equal := llvm.AddFunction(tm.module, equalFunctionName, tm.equalFnType)
   equal.SetLinkage(llvm.LinkOnceODRLinkage)
+  equalDescriptor := tm.createAlgorithmDescriptor(equalFunctionName+"_descriptor", equal)
+
   eqentrybb := llvm.AddBasicBlock(equal, "entry")
   eqretzerobb := llvm.AddBasicBlock(equal, "retzero")
-
   builder.SetInsertPointAtEnd(eqentrybb)
   s1ptr := builder.CreateBitCast(equal.Param(0), llsptrty, "")
   s2ptr := builder.CreateBitCast(equal.Param(1), llsptrty, "")
 
   zerobool := llvm.ConstNull(tm.ctx.Int8Type())
   onebool := llvm.ConstInt(tm.ctx.Int8Type(), 1, false)
 
   for i, fequal := range equals {
     f1ptr := builder.CreateStructGEP(s1ptr, i, "")
     f1ptr = builder.CreateBitCast(f1ptr, i8ptr, "")
     f2ptr := builder.CreateStructGEP(s2ptr, i, "")
     f2ptr = builder.CreateBitCast(f2ptr, i8ptr, "")
-
     fsize := llvm.ConstInt(tm.inttype, uint64(tm.sizes.Sizeof(st.Field(i).Type())), false)
-
     equalcall := builder.CreateCall(fequal, []llvm.Value{f1ptr, f2ptr, fsize}, "")
     equaleqzero := builder.CreateICmp(llvm.IntEQ, equalcall, zerobool, "")
-
     contbb := llvm.AddBasicBlock(equal, "cont")
     builder.CreateCondBr(equaleqzero, eqretzerobb, contbb)
-
     builder.SetInsertPointAtEnd(contbb)
   }
 
   builder.CreateRet(onebool)
 
   builder.SetInsertPointAtEnd(eqretzerobb)
   builder.CreateRet(zerobool)
 
-  tm.algs.Set(st, algorithmFns{hash, equal})
-  return
+  algs := algorithms{
+    hash:            hash,
+    hashDescriptor:  hashDescriptor,
+    equal:           equal,
+    equalDescriptor: equalDescriptor,
+  }
+  tm.algs.Set(st, algs)
+  return algs
 }
 
-func (tm *TypeMap) getArrayAlgorithmFunctions(at *types.Array) (hash, equal llvm.Value) {
-  if algs, ok := tm.algs.At(at).(algorithmFns); ok {
-    return algs.hash, algs.equal
+func (tm *TypeMap) getArrayAlgorithms(at *types.Array) algorithms {
+  if algs, ok := tm.algs.At(at).(algorithms); ok {
+    return algs
   }
 
-  ehash, eequal := tm.getAlgorithmFunctions(at.Elem())
-  if ehash == tm.hashFnError {
-    return ehash, eequal
+  elemAlgs := tm.getAlgorithms(at.Elem())
+  if elemAlgs.hashDescriptor == tm.algsError.hashDescriptor {
+    return elemAlgs
   }
 
   i8ptr := llvm.PointerType(tm.ctx.Int8Type(), 0)
   llelemty := llvm.PointerType(tm.ToLLVM(at.Elem()), 0)
 
   i1 := llvm.ConstInt(tm.inttype, 1, false)
   alen := llvm.ConstInt(tm.inttype, uint64(at.Len()), false)
   esize := llvm.ConstInt(tm.inttype, uint64(tm.sizes.Sizeof(at.Elem())), false)
 
   builder := tm.ctx.NewBuilder()
   defer builder.Dispose()
 
-  hash = llvm.AddFunction(tm.module, tm.mc.mangleHashFunctionName(at), tm.hashFnType)
+  hashFunctionName := tm.mc.mangleHashFunctionName(at)
+  hash := llvm.AddFunction(tm.module, hashFunctionName, tm.hashFnType)
   hash.SetLinkage(llvm.LinkOnceODRLinkage)
+  hashDescriptor := tm.createAlgorithmDescriptor(hashFunctionName+"_descriptor", hash)
+  equalFunctionName := tm.mc.mangleHashFunctionName(at)
+  equal := llvm.AddFunction(tm.module, equalFunctionName, tm.equalFnType)
+  equal.SetLinkage(llvm.LinkOnceODRLinkage)
+  equalDescriptor := tm.createAlgorithmDescriptor(equalFunctionName+"_descriptor", equal)
+  algs := algorithms{
+    hash:            hash,
+    hashDescriptor:  hashDescriptor,
+    equal:           equal,
+    equalDescriptor: equalDescriptor,
+  }
+  tm.algs.Set(at, algs)
+
   hashentrybb := llvm.AddBasicBlock(hash, "entry")
   builder.SetInsertPointAtEnd(hashentrybb)
   if at.Len() == 0 {
     builder.CreateRet(llvm.ConstNull(tm.inttype))
   } else {
     i33 := llvm.ConstInt(tm.inttype, 33, false)
 
     aptr := builder.CreateBitCast(hash.Param(0), llelemty, "")
     loopbb := llvm.AddBasicBlock(hash, "loop")
     builder.CreateBr(loopbb)
 
     exitbb := llvm.AddBasicBlock(hash, "exit")
 
     builder.SetInsertPointAtEnd(loopbb)
     indexphi := builder.CreatePHI(tm.inttype, "")
     index := indexphi
     hashvalphi := builder.CreatePHI(tm.inttype, "")
     hashval := hashvalphi
 
     eptr := builder.CreateGEP(aptr, []llvm.Value{index}, "")
     eptr = builder.CreateBitCast(eptr, i8ptr, "")
 
-    hashcall := builder.CreateCall(ehash, []llvm.Value{eptr, esize}, "")
+    hashcall := builder.CreateCall(elemAlgs.hash, []llvm.Value{eptr, esize}, "")
     hashval = builder.CreateMul(hashval, i33, "")
     hashval = builder.CreateAdd(hashval, hashcall, "")
 
     index = builder.CreateAdd(index, i1, "")
 
     indexphi.AddIncoming(
       []llvm.Value{llvm.ConstNull(tm.inttype), index},
       []llvm.BasicBlock{hashentrybb, loopbb},
     )
     hashvalphi.AddIncoming(
       []llvm.Value{llvm.ConstNull(tm.inttype), hashval},
       []llvm.BasicBlock{hashentrybb, loopbb},
     )
 
     exit := builder.CreateICmp(llvm.IntEQ, index, alen, "")
     builder.CreateCondBr(exit, exitbb, loopbb)
 
     builder.SetInsertPointAtEnd(exitbb)
     builder.CreateRet(hashval)
   }
 
   zerobool := llvm.ConstNull(tm.ctx.Int8Type())
   onebool := llvm.ConstInt(tm.ctx.Int8Type(), 1, false)
 
-  equal = llvm.AddFunction(tm.module, tm.mc.mangleEqualFunctionName(at), tm.equalFnType)
-  equal.SetLinkage(llvm.LinkOnceODRLinkage)
   eqentrybb := llvm.AddBasicBlock(equal, "entry")
   builder.SetInsertPointAtEnd(eqentrybb)
   if at.Len() == 0 {
     builder.CreateRet(onebool)
   } else {
     a1ptr := builder.CreateBitCast(equal.Param(0), llelemty, "")
     a2ptr := builder.CreateBitCast(equal.Param(1), llelemty, "")
     loopbb := llvm.AddBasicBlock(equal, "loop")
     builder.CreateBr(loopbb)
 
     exitbb := llvm.AddBasicBlock(equal, "exit")
     retzerobb := llvm.AddBasicBlock(equal, "retzero")
 
     builder.SetInsertPointAtEnd(loopbb)
     indexphi := builder.CreatePHI(tm.inttype, "")
     index := indexphi
 
     e1ptr := builder.CreateGEP(a1ptr, []llvm.Value{index}, "")
     e1ptr = builder.CreateBitCast(e1ptr, i8ptr, "")
     e2ptr := builder.CreateGEP(a2ptr, []llvm.Value{index}, "")
     e2ptr = builder.CreateBitCast(e2ptr, i8ptr, "")
 
-    equalcall := builder.CreateCall(eequal, []llvm.Value{e1ptr, e2ptr, esize}, "")
+    equalcall := builder.CreateCall(elemAlgs.equal, []llvm.Value{e1ptr, e2ptr, esize}, "")
     equaleqzero := builder.CreateICmp(llvm.IntEQ, equalcall, zerobool, "")
 
     contbb := llvm.AddBasicBlock(equal, "cont")
     builder.CreateCondBr(equaleqzero, retzerobb, contbb)
 
     builder.SetInsertPointAtEnd(contbb)
 
     index = builder.CreateAdd(index, i1, "")
 
     indexphi.AddIncoming(
       []llvm.Value{llvm.ConstNull(tm.inttype), index},
       []llvm.BasicBlock{eqentrybb, contbb},
     )
 
     exit := builder.CreateICmp(llvm.IntEQ, index, alen, "")
     builder.CreateCondBr(exit, exitbb, loopbb)
 
     builder.SetInsertPointAtEnd(exitbb)
     builder.CreateRet(onebool)
 
     builder.SetInsertPointAtEnd(retzerobb)
     builder.CreateRet(zerobool)
   }
 
-  tm.algs.Set(at, algorithmFns{hash, equal})
-  return
+  return algs
+}
+
+func (tm *TypeMap) createAlgorithmDescriptor(name string, fn llvm.Value) llvm.Value {
+  d := llvm.AddGlobal(tm.module, tm.funcValType, name)
+  d.SetLinkage(llvm.LinkOnceODRLinkage)
+  d.SetGlobalConstant(true)
+  fn = llvm.ConstBitCast(fn, tm.funcValType.StructElementTypes()[0])
+  init := llvm.ConstNull(tm.funcValType)
+  init = llvm.ConstInsertValue(init, fn, []uint32{0})
+  d.SetInitializer(init)
+  return d
 }
 
-func (tm *TypeMap) getAlgorithmFunctions(t types.Type) (hash, equal llvm.Value) {
+func (tm *TypeMap) getAlgorithms(t types.Type) algorithms {
   switch t := t.Underlying().(type) {
   case *types.Interface:
     if t.NumMethods() == 0 {
-      hash = tm.hashFnEmptyInterface
-      equal = tm.equalFnEmptyInterface
-    } else {
-      hash = tm.hashFnInterface
-      equal = tm.equalFnInterface
+      return tm.algsEmptyInterface
     }
+    return tm.algsInterface
   case *types.Basic:
     switch t.Kind() {
     case types.Float32, types.Float64:
-      hash = tm.hashFnFloat
-      equal = tm.equalFnFloat
+      return tm.algsFloat
     case types.Complex64, types.Complex128:
-      hash = tm.hashFnComplex
-      equal = tm.equalFnComplex
+      return tm.algsComplex
     case types.String:
-      hash = tm.hashFnString
-      equal = tm.equalFnString
-    default:
-      hash = tm.hashFnIdentity
-      equal = tm.equalFnIdentity
+      return tm.algsString
     }
+    return tm.algsIdentity
   case *types.Signature, *types.Map, *types.Slice:
-    hash = tm.hashFnError
-    equal = tm.equalFnError
+    return tm.algsError
   case *types.Struct:
-    hash, equal = tm.getStructAlgorithmFunctions(t)
+    return tm.getStructAlgorithms(t)
   case *types.Array:
-    hash, equal = tm.getArrayAlgorithmFunctions(t)
-  default:
-    hash = tm.hashFnIdentity
-    equal = tm.equalFnIdentity
+    return tm.getArrayAlgorithms(t)
   }
-
-  return
+  return tm.algsIdentity
 }
 
 func (tm *TypeMap) getTypeDescInfo(t types.Type) *typeDescInfo {
   if tdi, ok := tm.types.At(t).(*typeDescInfo); ok {
     return tdi
   }
 
   var b bytes.Buffer
   tm.mc.mangleTypeDescriptorName(t, &b)
func runtimeTypeKind(t types.Type) (k uint8) {
   if !hasPointers(t) {
     k |= gccgoRuntimeTypeKindNO_POINTERS
   }
 
   return
 }
 
 func (tm *TypeMap) makeCommonType(t types.Type) llvm.Value {
-  var vals [12]llvm.Value
+  var vals [11]llvm.Value
   vals[0] = llvm.ConstInt(tm.ctx.Int8Type(), uint64(runtimeTypeKind(t)), false)
   vals[1] = llvm.ConstInt(tm.ctx.Int8Type(), uint64(tm.Alignof(t)), false)
   vals[2] = vals[1]
   vals[3] = llvm.ConstInt(tm.inttype, uint64(tm.Sizeof(t)), false)
   vals[4] = llvm.ConstInt(tm.ctx.Int32Type(), uint64(tm.getTypeHash(t)), false)
-  hash, equal := tm.getAlgorithmFunctions(t)
-  vals[5] = hash
-  vals[6] = equal
+  algs := tm.getAlgorithms(t)
+  vals[5] = algs.hashDescriptor
+  vals[6] = algs.equalDescriptor
   vals[7] = tm.getGcPointer(t)
   var b bytes.Buffer
   tm.writeType(t, &b)
   vals[8] = tm.globalStringPtr(b.String())
   vals[9] = tm.makeUncommonTypePtr(t)
-  if _, ok := t.(*types.Named); ok {
+  switch t.(type) {
+  case *types.Named, *types.Struct:
     vals[10] = tm.getTypeDescriptorPointer(types.NewPointer(t))
-  } else {
+  default:
     vals[10] = llvm.ConstPointerNull(llvm.PointerType(tm.commonTypeType, 0))
   }
-  vals[11] = tm.zeroValue
-
   return llvm.ConstNamedStruct(tm.commonTypeType, vals[:])
 }
 
 func (tm *TypeMap) makeBasicType(t types.Type, u *types.Basic) llvm.Value {
   return tm.makeCommonType(t)
 }
 
 func (tm *TypeMap) makeArrayType(t types.Type, a *types.Array) llvm.Value {

irgen/value.go

 //
 //===----------------------------------------------------------------------===//
 
 package irgen
 
 import (
   "fmt"
   "go/token"
+
   "llvm.org/llgo/third_party/gotools/go/exact"
   "llvm.org/llgo/third_party/gotools/go/types"
   "llvm.org/llvm/bindings/go/llvm"
 )
 
 // govalue contains an LLVM value and a Go type,
 // representing the result of a Go expression.
 type govalue struct {
if isString(srctyp) {
     // (untyped) string -> string
     // XXX should untyped strings be able to escape go/types?
     if isString(dsttyp) {
       return newValue(v.value, origdsttyp)
     }
 
     // string -> []byte
     if isSlice(dsttyp, types.Byte) {
-      value := v.value
-      strdata := fr.builder.CreateExtractValue(value, 0, "")
-      strlen := fr.builder.CreateExtractValue(value, 1, "")
-
-      // Data must be copied, to prevent changes in
-      // the byte slice from mutating the string.
-      newdata := fr.createMalloc(strlen)
-      fr.memcpy(newdata, strdata, strlen)
-
-      struct_ := llvm.Undef(fr.types.ToLLVM(dsttyp))
-      struct_ = fr.builder.CreateInsertValue(struct_, newdata, 0, "")
-      struct_ = fr.builder.CreateInsertValue(struct_, strlen, 1, "")
-      struct_ = fr.builder.CreateInsertValue(struct_, strlen, 2, "")
-      return newValue(struct_, origdsttyp)
+      sliceValue := fr.runtime.stringToByteArray.callOnly(fr, v.value)[0]
+      return newValue(sliceValue, origdsttyp)
     }
 
     // string -> []rune
     if isSlice(dsttyp, types.Rune) {
       return fr.stringToRuneSlice(v)
     }
   }
 
   // []byte -> string
   if isSlice(srctyp, types.Byte) && isString(dsttyp) {
-    value := v.value
-    data := fr.builder.CreateExtractValue(value, 0, "")
-    len := fr.builder.CreateExtractValue(value, 1, "")
-
-    // Data must be copied, to prevent changes in
-    // the byte slice from mutating the string.
-    newdata := fr.createMalloc(len)
-    fr.memcpy(newdata, data, len)
-
-    struct_ := llvm.Undef(fr.types.ToLLVM(types.Typ[types.String]))
-    struct_ = fr.builder.CreateInsertValue(struct_, newdata, 0, "")
-    struct_ = fr.builder.CreateInsertValue(struct_, len, 1, "")
-    return newValue(struct_, types.Typ[types.String])
+    data := fr.builder.CreateExtractValue(v.value, 0, "")
+    len := fr.builder.CreateExtractValue(v.value, 1, "")
+    stringValue := fr.runtime.byteArrayToString.callOnly(fr, data, len)[0]
+    return newValue(stringValue, dsttyp)
   }
 
   // []rune -> string
   if isSlice(srctyp, types.Rune) && isString(dsttyp) {
     return fr.runeSliceToString(v)
   }
 
   // rune -> string

libgo-check-failures.diff

 @@ -62,6 +62,7 @@
     }()
     <-done
     runtime.GC()
 +   runtime.GC()
     select {
     case <-ch:
     case <-time.After(time.Second * 4):
-diff -r a6e10414311a libgo/go/runtime/runtime_test.go
---- a/libgo/go/runtime/runtime_test.go  Fri Jan 16 07:57:02 2015 -0800
-+++ b/libgo/go/runtime/runtime_test.go  Fri Apr 03 15:07:47 2015 -0700
-@@ -176,6 +176,8 @@
- }
- 
- func TestSetPanicOnFault(t *testing.T) {
-+ t.Skip("skipping for llgo due to lack of non-call exception support")
-+
-  // This currently results in a fault in the signal trampoline on
-  // dragonfly/386 - see issue 7421.
-  if GOOS == "dragonfly" && GOARCH == "386" {

update_third_party.sh

 #!/bin/sh -e
 
 scriptpath=$(readlink -f "$0")
 llgosrcdir=$(dirname "$scriptpath")
 cd $llgosrcdir
 
-gofrontendrepo=https://code.google.com/p/gofrontend
-gofrontendrev=15a24202fa42
+gofrontendrepo=https://go.googlesource.com/gofrontend
+gofrontendrev=81eb6a3f425b2158c67ee32c0cc973a72ce9d6be
 
 gccrepo=svn://gcc.gnu.org/svn/gcc/trunk
 gccrev=219477
 
 gotoolsrepo=https://go.googlesource.com/tools
 gotoolsrev=d4e70101500b43ffe705d4c45e50dd4f1c8e3b2e
 
 linerrepo=https://github.com/peterh/liner.git
-linerrev=1bb0d1c1a25ed393d8feb09bab039b2b1b1fbced
+linerrev=4d47685ab2fd2dbb46c66b831344d558bc4be5b9
 
 tempdir=$(mktemp -d /tmp/update_third_party.XXXXXX)
 gofrontenddir=$tempdir/gofrontend
 gotoolsdir=$tempdir/go.tools
 linerdir=third_party/liner
 
 rm -rf third_party
 mkdir -p third_party/gofrontend third_party/gotools
 
+git_clone() {
+    repo=$1
+    dir=$2
+    rev=$3
+    git clone $repo $dir
+    (
+        cd $dir
+        git checkout $rev
+        rm -fr .git
+    )
+}
+
 # --------------------- gofrontend ---------------------
 
-hg clone -r $gofrontendrev $gofrontendrepo $gofrontenddir
+git_clone $gofrontendrepo $gofrontenddir $gofrontendrev
 
 cp -r $gofrontenddir/LICENSE $gofrontenddir/libgo third_party/gofrontend
 
 # Apply a diff that eliminates use of the unnamed struct extension beyond what
 # -fms-extensions supports.
 (cd third_party/gofrontend && patch -p1) < libgo-noext.diff
 # Apply a diff that disables testing of packages known to fail.
 (cd third_party/gofrontend && patch -p1) < libgo-check-failures.diff

 
 mkdir -p third_party/gofrontend/include third_party/gofrontend/libgcc
 
 # Copy in our versions of GCC files.
 cp include/dwarf2.h third_party/gofrontend/include/
 cp include/filenames.h third_party/gofrontend/include/
 cp include/unwind-pe.h third_party/gofrontend/libgcc/
 
 # Note: this expects the llgo source tree to be located at llvm/tools/llgo.
-cp ../../autoconf/config.guess third_party/gofrontend/
-cp ../../autoconf/config.sub third_party/gofrontend/
+cp ../../cmake/config.guess third_party/gofrontend/
+cp autoconf/config.sub third_party/gofrontend/
 
 for d in libbacktrace libffi ; do
   svn export -r $gccrev $gccrepo/$d third_party/gofrontend/$d
 done
 
 # Remove GPL licensed files, and files that confuse our license check.
 rm \
   third_party/gofrontend/libffi/ChangeLog \

 
 # The build requires these files to exist.
 touch \
   third_party/gofrontend/include/dwarf2.def \
   third_party/gofrontend/libffi/doc/libffi.texi
 
 # --------------------- go.tools ---------------------
 
-git clone $gotoolsrepo $gotoolsdir
-(cd $gotoolsdir && git checkout $gotoolsrev)
+git_clone $gotoolsrepo $gotoolsdir $gotoolsrev
 
 cp -r $gotoolsdir/LICENSE $gotoolsdir/go third_party/gotools
 
 # Vendor the go.tools repository.
 find third_party/gotools -name '*.go' | xargs sed -i -e \
   's,"golang.org/x/tools/,"llvm.org/llgo/third_party/gotools/,g'
 
 # --------------------- peterh/liner -----------------
 
-git clone $linerrepo $linerdir
-(cd $linerdir && git checkout $linerrev && rm -rf .git)
+git_clone $linerrepo $linerdir $linerrev
 
 # --------------------- license check ---------------------
 
 # We don't want any GPL licensed code without an autoconf/libtool
 # exception, or any GPLv3 licensed code.
 
 for i in `grep -lr 'General Public License' third_party` ; do
   if grep -q 'configuration script generated by Autoconf, you may include it under' $i || \