[llgo]: Somewhat revive it and make it buildable with current trunk.

[kristina]

Summary

Make llgo buildable with current LLVM.

Some caveats:

• No compiler-rt support for now (That may be fixed soon, depending on other factors).
• No test coverage either as I'm not familiar with LLGO test structure enough.

[kristina]

Changes to runtime.go address the regression caused by rL322965.

[pcc]

For testing -fsplit-stack you probably want to add a test under llgo/test/irgen. They are standard lit tests.

cmd/gllgo/gllgo.go

201

I don't see where this is used.

[kristina]

Currently actual tests would require using libgcc, as compiler-rt does not support split stack yet. If libgcc is required for tests then I don't think I can accurately make one. So if you require a test for this, it's likely that I'll have to mark this as "Changes Planned" for now until compiler-rt is sufficient to link this, unfortunately. Up to you really, though in my opinion even without tests this is better than it failing to compile. And the reasons for avoiding libgcc are fairly complicated, my intentions currently are to stay as far away from GNU runtime components as possible.

cmd/gllgo/gllgo.go

201

Currently it's not, in this patch, so I can revise it to remove it. Though flags still need to be handled.

[kristina]

Ping.

[pcc]

LGTM

cmd/gllgo/gllgo.go

201

Please move the code handling -fsplit-stack into a separate patch.

[kristina]

Revised, landing it without split stack stuff, should autoupdate the revision here.

cmd/gllgo/gllgo.go

 func (san *sanitizerOptions) addPasses(mpm, fpm llvm.PassManager) {
   switch {
   case san.address:
     mpm.AddAddressSanitizerModulePass()
     fpm.AddAddressSanitizerFunctionPass()
   case san.thread:
     mpm.AddThreadSanitizerPass()
   case san.memory:
-    mpm.AddMemorySanitizerPass()
+    mpm.AddMemorySanitizerLegacyPassPass()
   case san.dataflow:
     blacklist := san.blacklist
     if blacklist == "" {
       blacklist = filepath.Join(san.resourcePath(), "dfsan_abilist.txt")
     }
     mpm.AddDataFlowSanitizerPass([]string{blacklist})
   }
 }
type driverOptions struct {
   plugins         []string
   prefix          string
   sanitizer       sanitizerOptions
   sizeLevel       int
   staticLibgcc    bool
   staticLibgo     bool
   staticLink      bool
   triple          string
+  splitStack      bool
 }
 
 func getInstPrefix() (string, error) {
   path, err := exec.LookPath(os.Args[0])
   if err != nil {
     return "", err
   }
 
for len(args) > 0 {
 
     case args[0] == "-fload-plugin":
       if len(args) == 1 {
         return opts, errors.New("missing argument after '-fload-plugin'")
       }
       opts.plugins = append(opts.plugins, args[1])
       consumedArgs = 2
 
+    case args[0] == "-fno-split-stack":
+      opts.splitStack = false
+
+    case args[0] == "-fsplit-stack":
+      opts.splitStack = true    
+
     case args[0] == "-fno-toplevel-reorder":
       // This is a GCC-specific code generation option. Ignore.
 
     case args[0] == "-emit-llvm":
       opts.emitIR = true
 
     case args[0] == "-flto":
       opts.lto = true

irgen/runtime.go

func newRuntimeInterface(module llvm.Module, tm *llvmTypeMap) (*runtimeInterface, error) {
 
   memsetName := "llvm.memset.p0i8.i" + strconv.Itoa(tm.target.IntPtrType().IntTypeWidth())
   memsetType := llvm.FunctionType(
     llvm.VoidType(),
     []llvm.Type{
       llvm.PointerType(llvm.Int8Type(), 0),
       llvm.Int8Type(),
       tm.target.IntPtrType(),
-      llvm.Int32Type(),
       llvm.Int1Type(),
     },
     false,
   )
   ri.memset = llvm.AddFunction(module, memsetName, memsetType)
 
   memcpyName := "llvm.memcpy.p0i8.p0i8.i" + strconv.Itoa(tm.target.IntPtrType().IntTypeWidth())
   memcpyType := llvm.FunctionType(
     llvm.VoidType(),
     []llvm.Type{
       llvm.PointerType(llvm.Int8Type(), 0),
       llvm.PointerType(llvm.Int8Type(), 0),
-      tm.target.IntPtrType(),
-      llvm.Int32Type(),
+      llvm.Int64Type(),
       llvm.Int1Type(),
     },
     false,
   )
   ri.memcpy = llvm.AddFunction(module, memcpyName, memcpyType)
 
   returnaddressType := llvm.FunctionType(
     llvm.PointerType(llvm.Int8Type(), 0),
func (fr *frame) createTypeMalloc(t types.Type) llvm.Value {
   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
   ptr = fr.builder.CreateBitCast(ptr, llvm.PointerType(llvm.Int8Type(), 0), "")
   fill := llvm.ConstNull(llvm.Int8Type())
   size = fr.createZExtOrTrunc(size, fr.target.IntPtrType(), "")
-  align := llvm.ConstInt(llvm.Int32Type(), 1, false)
   isvolatile := llvm.ConstNull(llvm.Int1Type())
-  fr.builder.CreateCall(memset, []llvm.Value{ptr, fill, size, align, isvolatile}, "")
+  fr.builder.CreateCall(memset, []llvm.Value{ptr, fill, size, isvolatile}, "")
 }
 
 func (fr *frame) memcpy(dest llvm.Value, src llvm.Value, size llvm.Value) {
   memcpy := fr.runtime.memcpy
   dest = fr.builder.CreateBitCast(dest, llvm.PointerType(llvm.Int8Type(), 0), "")
   src = fr.builder.CreateBitCast(src, llvm.PointerType(llvm.Int8Type(), 0), "")
   size = fr.createZExtOrTrunc(size, fr.target.IntPtrType(), "")
-  align := llvm.ConstInt(llvm.Int32Type(), 1, false)
   isvolatile := llvm.ConstNull(llvm.Int1Type())
-  fr.builder.CreateCall(memcpy, []llvm.Value{dest, src, size, align, isvolatile}, "")
+  fr.builder.CreateCall(memcpy, []llvm.Value{dest, src, size, isvolatile}, "")
 }
 
 func (fr *frame) returnAddress(level uint64) llvm.Value {
   returnaddress := fr.runtime.returnaddress
   levelValue := llvm.ConstInt(llvm.Int32Type(), level, false)
   return fr.builder.CreateCall(returnaddress, []llvm.Value{levelValue}, "")
 }