[llgo] irgen: always use TargetMachine's data layout

[axw]

Summary

Another attempt at resolving the runtime assertion
in llgoi due to data layout mismatch between module
and execution engine.

The X86 data layout constant appears to be unnecessary,
and does not match what the execution engine picks.
Using the registered Target, we pick the same data
layout as the execution engine.

While I was in the vicinity, I deleted the last
remnants of PNaCl support.

[pcc]

lgtm

irgen/compiler.go

 
 import (
   "bytes"
   "go/ast"
   "go/token"
   "log"
   "sort"
   "strconv"
-  "strings"
 
   llgobuild "llvm.org/llgo/build"
   "llvm.org/llgo/debug"
   "llvm.org/llvm/bindings/go/llvm"
 
   "llvm.org/llgo/third_party/gotools/go/gccgoimporter"
   "llvm.org/llgo/third_party/gotools/go/importer"
   "llvm.org/llgo/third_party/gotools/go/loader"
type CompilerOptions struct {
 
   // Packages is used by go/types as the imported package map if non-nil.
   Packages map[string]*types.Package
 }
 
 type Compiler struct {
   opts       CompilerOptions
   dataLayout string
-  pnacl      bool
 }
 
 func NewCompiler(opts CompilerOptions) (*Compiler, error) {
   compiler := &Compiler{opts: opts}
-  if strings.ToLower(compiler.opts.TargetTriple) == "pnacl" {
-    compiler.opts.TargetTriple = PNaClTriple
-    compiler.pnacl = true
-  }
   dataLayout, err := llvmDataLayout(compiler.opts.TargetTriple)
   if err != nil {
     return nil, err
   }
   compiler.dataLayout = dataLayout
   return compiler, nil
 }
 
 func (c *Compiler) Compile(fset *token.FileSet, astFiles []*ast.File, importpath string) (m *Module, err error) {
   target := llvm.NewTargetData(c.dataLayout)
   compiler := &compiler{
     CompilerOptions: c.opts,
     dataLayout:      c.dataLayout,
     target:          target,
-    pnacl:           c.pnacl,
     llvmtypes:       NewLLVMTypeMap(llvm.GlobalContext(), target),
   }
   return compiler.compile(fset, astFiles, importpath)
 }
 
 type compiler struct {
   CompilerOptions
 
   module     *Module
   dataLayout string
   target     llvm.TargetData
   fileset    *token.FileSet
 
   runtime   *runtimeInterface
   llvmtypes *llvmTypeMap
   types     *TypeMap
 
-  // pnacl is set to true if the target triple was originally
-  // specified as "pnacl". This is necessary, as the TargetTriple
-  // field will have been updated to the true triple used to
-  // compile PNaCl modules.
-  pnacl bool
-
   debug *debug.DIBuilder
 }
 
 func (c *compiler) logf(format string, v ...interface{}) {
   if c.Logger != nil {
     c.Logger.Printf(format, v...)
   }
 }

irgen/targets.go

 
 import (
   "fmt"
   "strings"
 
   "llvm.org/llvm/bindings/go/llvm"
 )
 
-// PNaClTriple is the LLVM target triple that should be used to compile
-// modules to be compatible with PNaCl (Portable Native Client).
-const PNaClTriple = "armv7-none-linux-gnueabi"
-
-// Below are the target data representation constants generated by clang.
-// For unknown targets, we enumerate all targets known to LLVM and use
-// the first one with a matching architecture.
-const (
-  x86TargetData = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
-)
-
 // llvmDataLayout returns the data layout string
 // representation for the specified LLVM triple.
 func llvmDataLayout(triple string) (string, error) {
   // Triples are several fields separated by '-' characters.
   // The first field is the architecture. The architecture's
   // canonical form may include a '-' character, which would
   // have been translated to '_' for inclusion in a triple.
   arch := parseArch(triple[:strings.IndexRune(triple, '-')])
-  switch arch {
-  case "x86-64":
-    return x86TargetData, nil
-  }
   for target := llvm.FirstTarget(); target.C != nil; target = target.NextTarget() {
     if arch == target.Name() {
       machine := target.CreateTargetMachine(
         triple, "", "",
         llvm.CodeGenLevelDefault,
         llvm.RelocDefault,
         llvm.CodeModelDefault,
       )