all: remove LLVM 14 support

This is a big change: apart from removing LLVM 14 it also removes typed
pointer support (which was only fully supported in LLVM up to version
14). This removes about 200 lines of code, but more importantly removes
a ton of special cases for LLVM 14.

.circleci/config.yml

@@ -98,17 +98,17 @@ commands:
             - /go/pkg/mod
 
 jobs:
-  test-llvm14-go118:
+  test-llvm15-go118:
     docker:
       - image: golang:1.18-buster
     steps:
       - test-linux:
-          llvm: "14"
+          llvm: "15"
     resource_class: large
 
 workflows:
   test-all:
     jobs:
       # This tests our lowest supported versions of Go and LLVM, to make sure at
       # least the smoke tests still pass.
-      - test-llvm14-go118
+      - test-llvm15-go118

Makefile

@@ -10,7 +10,7 @@ LLD_SRC ?= $(LLVM_PROJECTDIR)/lld
 
 # Try to autodetect LLVM build tools.
 # Versions are listed here in descending priority order.
-LLVM_VERSIONS = 16 15 14 13 12 11
+LLVM_VERSIONS = 16 15
 errifempty = $(if $(1),$(1),$(error $(2)))
 detect = $(shell which $(call errifempty,$(firstword $(foreach p,$(2),$(shell command -v $(p) 2> /dev/null && echo $(p)))),failed to locate $(1) at any of: $(2)))
 toolSearchPathsVersion = $(1)-$(2)

builder/build.go

@@ -528,13 +528,13 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 			irbuilder := mod.Context().NewBuilder()
 			defer irbuilder.Dispose()
 			irbuilder.SetInsertPointAtEnd(block)
-			i8ptrType := llvm.PointerType(mod.Context().Int8Type(), 0)
+			ptrType := llvm.PointerType(mod.Context().Int8Type(), 0)
 			for _, pkg := range lprogram.Sorted() {
 				pkgInit := mod.NamedFunction(pkg.Pkg.Path() + ".init")
 				if pkgInit.IsNil() {
 					panic("init not found for " + pkg.Pkg.Path())
 				}
-				irbuilder.CreateCall(pkgInit.GlobalValueType(), pkgInit, []llvm.Value{llvm.Undef(i8ptrType)}, "")
+				irbuilder.CreateCall(pkgInit.GlobalValueType(), pkgInit, []llvm.Value{llvm.Undef(ptrType)}, "")
 			}
 			irbuilder.CreateRetVoid()
 
@@ -760,7 +760,7 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 			if sizeLevel >= 2 {
 				// Workaround with roughly the same effect as
 				// https://reviews.llvm.org/D119342.
-				// Can hopefully be removed in LLVM 15.
+				// Can hopefully be removed in LLVM 18.
 				ldflags = append(ldflags,
 					"-mllvm", "--rotation-max-header-size=0")
 			}

builder/library.go

@@ -178,12 +178,6 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 	if strings.HasPrefix(target, "riscv64-") {
 		args = append(args, "-march=rv64gc")
 	}
-	if strings.HasPrefix(target, "xtensa") {
-		// Hack to work around an issue in the Xtensa port:
-		// https://github.com/espressif/llvm-project/issues/52
-		// Hopefully this will be fixed soon (LLVM 14).
-		args = append(args, "-D__ELF__")
-	}
 
 	var once sync.Once
 

builder/musl.go

@@ -6,12 +6,10 @@ import (
 	"os"
 	"path/filepath"
 	"regexp"
-	"strconv"
 	"strings"
 
 	"github.com/tinygo-org/tinygo/compileopts"
 	"github.com/tinygo-org/tinygo/goenv"
-	"tinygo.org/x/go-llvm"
 )
 
 var Musl = Library{
@@ -93,6 +91,7 @@ var Musl = Library{
 			"-Wno-string-plus-int",
 			"-Wno-ignored-pragmas",
 			"-Wno-tautological-constant-out-of-range-compare",
+			"-Wno-deprecated-non-prototype",
 			"-Qunused-arguments",
 			// Select include dirs. Don't include standard library includes
 			// (that would introduce host dependencies and other complications),
@@ -106,11 +105,6 @@ var Musl = Library{
 			"-I" + muslDir + "/include",
 			"-fno-stack-protector",
 		}
-		llvmMajor, _ := strconv.Atoi(strings.SplitN(llvm.Version, ".", 2)[0])
-		if llvmMajor >= 15 {
-			// This flag was added in Clang 15. It is not present in LLVM 14.
-			cflags = append(cflags, "-Wno-deprecated-non-prototype")
-		}
 		return cflags
 	},
 	sourceDir: func() string { return filepath.Join(goenv.Get("TINYGOROOT"), "lib/musl/src") },

cgo/libclang_config_llvm16.go

@@ -1,4 +1,4 @@
-//go:build !byollvm && !llvm14 && !llvm15
+//go:build !byollvm && !llvm15
 
 package cgo
 

compiler/atomic.go

@@ -35,17 +35,7 @@ func (b *builder) createAtomicOp(name string) llvm.Value {
 	case "SwapInt32", "SwapInt64", "SwapUint32", "SwapUint64", "SwapUintptr", "SwapPointer":
 		ptr := b.getValue(b.fn.Params[0], getPos(b.fn))
 		val := b.getValue(b.fn.Params[1], getPos(b.fn))
-		isPointer := val.Type().TypeKind() == llvm.PointerTypeKind
-		if isPointer {
-			// atomicrmw only supports integers, so cast to an integer.
-			// TODO: this is fixed in LLVM 15.
-			val = b.CreatePtrToInt(val, b.uintptrType, "")
-			ptr = b.CreateBitCast(ptr, llvm.PointerType(val.Type(), 0), "")
-		}
 		oldVal := b.CreateAtomicRMW(llvm.AtomicRMWBinOpXchg, ptr, val, llvm.AtomicOrderingSequentiallyConsistent, true)
-		if isPointer {
-			oldVal = b.CreateIntToPtr(oldVal, b.i8ptrType, "")
-		}
 		return oldVal
 	case "CompareAndSwapInt32", "CompareAndSwapInt64", "CompareAndSwapUint32", "CompareAndSwapUint64", "CompareAndSwapUintptr", "CompareAndSwapPointer":
 		ptr := b.getValue(b.fn.Params[0], getPos(b.fn))
@@ -63,24 +53,6 @@ func (b *builder) createAtomicOp(name string) llvm.Value {
 	case "StoreInt32", "StoreInt64", "StoreUint32", "StoreUint64", "StoreUintptr", "StorePointer":
 		ptr := b.getValue(b.fn.Params[0], getPos(b.fn))
 		val := b.getValue(b.fn.Params[1], getPos(b.fn))
-		if strings.HasPrefix(b.Triple, "avr") {
-			// SelectionDAGBuilder is currently missing the "are unaligned atomics allowed" check for stores.
-			vType := val.Type()
-			isPointer := vType.TypeKind() == llvm.PointerTypeKind
-			if isPointer {
-				// libcalls only supports integers, so cast to an integer.
-				vType = b.uintptrType
-				val = b.CreatePtrToInt(val, vType, "")
-				ptr = b.CreateBitCast(ptr, llvm.PointerType(vType, 0), "")
-			}
-			name := fmt.Sprintf("__atomic_store_%d", vType.IntTypeWidth()/8)
-			fn := b.mod.NamedFunction(name)
-			if fn.IsNil() {
-				fn = llvm.AddFunction(b.mod, name, llvm.FunctionType(vType, []llvm.Type{ptr.Type(), vType, b.uintptrType}, false))
-			}
-			b.createCall(fn.GlobalValueType(), fn, []llvm.Value{ptr, val, llvm.ConstInt(b.uintptrType, 5, false)}, "")
-			return llvm.Value{}
-		}
 		store := b.CreateStore(val, ptr)
 		store.SetOrdering(llvm.AtomicOrderingSequentiallyConsistent)
 		store.SetAlignment(b.targetData.PrefTypeAlignment(val.Type())) // required

compiler/calls.go

@@ -45,7 +45,7 @@ func (b *builder) createRuntimeCallCommon(fnName string, args []llvm.Value, name
 	if llvmFn.IsNil() {
 		panic("trying to call non-existent function: " + fn.RelString(nil))
 	}
-	args = append(args, llvm.Undef(b.i8ptrType)) // unused context parameter
+	args = append(args, llvm.Undef(b.dataPtrType)) // unused context parameter
 	if isInvoke {
 		return b.createInvoke(fnType, llvmFn, args, name)
 	}

compiler/channel.go

@@ -33,28 +33,27 @@ func (b *builder) createChanSend(instr *ssa.Send) {
 	// store value-to-send
 	valueType := b.getLLVMType(instr.X.Type())
 	isZeroSize := b.targetData.TypeAllocSize(valueType) == 0
-	var valueAlloca, valueAllocaCast, valueAllocaSize llvm.Value
+	var valueAlloca, valueAllocaSize llvm.Value
 	if isZeroSize {
-		valueAlloca = llvm.ConstNull(llvm.PointerType(valueType, 0))
-		valueAllocaCast = llvm.ConstNull(b.i8ptrType)
+		valueAlloca = llvm.ConstNull(b.dataPtrType)
 	} else {
-		valueAlloca, valueAllocaCast, valueAllocaSize = b.createTemporaryAlloca(valueType, "chan.value")
+		valueAlloca, valueAllocaSize = b.createTemporaryAlloca(valueType, "chan.value")
 		b.CreateStore(chanValue, valueAlloca)
 	}
 
 	// Allocate blockedlist buffer.
 	channelBlockedList := b.getLLVMRuntimeType("channelBlockedList")
-	channelBlockedListAlloca, channelBlockedListAllocaCast, channelBlockedListAllocaSize := b.createTemporaryAlloca(channelBlockedList, "chan.blockedList")
+	channelBlockedListAlloca, channelBlockedListAllocaSize := b.createTemporaryAlloca(channelBlockedList, "chan.blockedList")
 
 	// Do the send.
-	b.createRuntimeCall("chanSend", []llvm.Value{ch, valueAllocaCast, channelBlockedListAlloca}, "")
+	b.createRuntimeCall("chanSend", []llvm.Value{ch, valueAlloca, channelBlockedListAlloca}, "")
 
 	// End the lifetime of the allocas.
 	// This also works around a bug in CoroSplit, at least in LLVM 8:
 	// https://bugs.llvm.org/show_bug.cgi?id=41742
-	b.emitLifetimeEnd(channelBlockedListAllocaCast, channelBlockedListAllocaSize)
+	b.emitLifetimeEnd(channelBlockedListAlloca, channelBlockedListAllocaSize)
 	if !isZeroSize {
-		b.emitLifetimeEnd(valueAllocaCast, valueAllocaSize)
+		b.emitLifetimeEnd(valueAlloca, valueAllocaSize)
 	}
 }
 
@@ -66,28 +65,27 @@ func (b *builder) createChanRecv(unop *ssa.UnOp) llvm.Value {
 
 	// Allocate memory to receive into.
 	isZeroSize := b.targetData.TypeAllocSize(valueType) == 0
-	var valueAlloca, valueAllocaCast, valueAllocaSize llvm.Value
+	var valueAlloca, valueAllocaSize llvm.Value
 	if isZeroSize {
-		valueAlloca = llvm.ConstNull(llvm.PointerType(valueType, 0))
-		valueAllocaCast = llvm.ConstNull(b.i8ptrType)
+		valueAlloca = llvm.ConstNull(b.dataPtrType)
 	} else {
-		valueAlloca, valueAllocaCast, valueAllocaSize = b.createTemporaryAlloca(valueType, "chan.value")
+		valueAlloca, valueAllocaSize = b.createTemporaryAlloca(valueType, "chan.value")
 	}
 
 	// Allocate blockedlist buffer.
 	channelBlockedList := b.getLLVMRuntimeType("channelBlockedList")
-	channelBlockedListAlloca, channelBlockedListAllocaCast, channelBlockedListAllocaSize := b.createTemporaryAlloca(channelBlockedList, "chan.blockedList")
+	channelBlockedListAlloca, channelBlockedListAllocaSize := b.createTemporaryAlloca(channelBlockedList, "chan.blockedList")
 
 	// Do the receive.
-	commaOk := b.createRuntimeCall("chanRecv", []llvm.Value{ch, valueAllocaCast, channelBlockedListAlloca}, "")
+	commaOk := b.createRuntimeCall("chanRecv", []llvm.Value{ch, valueAlloca, channelBlockedListAlloca}, "")
 	var received llvm.Value
 	if isZeroSize {
 		received = llvm.ConstNull(valueType)
 	} else {
 		received = b.CreateLoad(valueType, valueAlloca, "chan.received")
-		b.emitLifetimeEnd(valueAllocaCast, valueAllocaSize)
+		b.emitLifetimeEnd(valueAlloca, valueAllocaSize)
 	}
-	b.emitLifetimeEnd(channelBlockedListAllocaCast, channelBlockedListAllocaSize)
+	b.emitLifetimeEnd(channelBlockedListAlloca, channelBlockedListAllocaSize)
 
 	if unop.CommaOk {
 		tuple := llvm.Undef(b.ctx.StructType([]llvm.Type{valueType, b.ctx.Int1Type()}, false))
@@ -159,19 +157,18 @@ func (b *builder) createSelect(expr *ssa.Select) llvm.Value {
 			sendValue := b.getValue(state.Send, state.Pos)
 			alloca := llvmutil.CreateEntryBlockAlloca(b.Builder, sendValue.Type(), "select.send.value")
 			b.CreateStore(sendValue, alloca)
-			ptr := b.CreateBitCast(alloca, b.i8ptrType, "")
-			selectState = b.CreateInsertValue(selectState, ptr, 1, "")
+			selectState = b.CreateInsertValue(selectState, alloca, 1, "")
 		default:
 			panic("unreachable")
 		}
 		selectStates = append(selectStates, selectState)
 	}
 
 	// Create a receive buffer, where the received value will be stored.
-	recvbuf := llvm.Undef(b.i8ptrType)
+	recvbuf := llvm.Undef(b.dataPtrType)
 	if recvbufSize != 0 {
 		allocaType := llvm.ArrayType(b.ctx.Int8Type(), int(recvbufSize))
-		recvbufAlloca, _, _ := b.createTemporaryAlloca(allocaType, "select.recvbuf.alloca")
+		recvbufAlloca, _ := b.createTemporaryAlloca(allocaType, "select.recvbuf.alloca")
 		recvbufAlloca.SetAlignment(recvbufAlign)
 		recvbuf = b.CreateGEP(allocaType, recvbufAlloca, []llvm.Value{
 			llvm.ConstInt(b.ctx.Int32Type(), 0, false),
@@ -181,7 +178,7 @@ func (b *builder) createSelect(expr *ssa.Select) llvm.Value {
 
 	// Create the states slice (allocated on the stack).
 	statesAllocaType := llvm.ArrayType(chanSelectStateType, len(selectStates))
-	statesAlloca, statesI8, statesSize := b.createTemporaryAlloca(statesAllocaType, "select.states.alloca")
+	statesAlloca, statesSize := b.createTemporaryAlloca(statesAllocaType, "select.states.alloca")
 	for i, state := range selectStates {
 		// Set each slice element to the appropriate channel.
 		gep := b.CreateGEP(statesAllocaType, statesAlloca, []llvm.Value{
@@ -202,7 +199,7 @@ func (b *builder) createSelect(expr *ssa.Select) llvm.Value {
 		// Stack-allocate operation structures.
 		// If these were simply created as a slice, they would heap-allocate.
 		chBlockAllocaType := llvm.ArrayType(b.getLLVMRuntimeType("channelBlockedList"), len(selectStates))
-		chBlockAlloca, chBlockAllocaPtr, chBlockSize := b.createTemporaryAlloca(chBlockAllocaType, "select.block.alloca")
+		chBlockAlloca, chBlockSize := b.createTemporaryAlloca(chBlockAllocaType, "select.block.alloca")
 		chBlockLen := llvm.ConstInt(b.uintptrType, uint64(len(selectStates)), false)
 		chBlockPtr := b.CreateGEP(chBlockAllocaType, chBlockAlloca, []llvm.Value{
 			llvm.ConstInt(b.ctx.Int32Type(), 0, false),
@@ -216,7 +213,7 @@ func (b *builder) createSelect(expr *ssa.Select) llvm.Value {
 		}, "select.result")
 
 		// Terminate the lifetime of the operation structures.
-		b.emitLifetimeEnd(chBlockAllocaPtr, chBlockSize)
+		b.emitLifetimeEnd(chBlockAlloca, chBlockSize)
 	} else {
 		results = b.createRuntimeCall("tryChanSelect", []llvm.Value{
 			recvbuf,
@@ -225,7 +222,7 @@ func (b *builder) createSelect(expr *ssa.Select) llvm.Value {
 	}
 
 	// Terminate the lifetime of the states alloca.
-	b.emitLifetimeEnd(statesI8, statesSize)
+	b.emitLifetimeEnd(statesAlloca, statesSize)
 
 	// The result value does not include all the possible received values,
 	// because we can't load them in advance. Instead, the *ssa.Extract
@@ -265,7 +262,6 @@ func (b *builder) getChanSelectResult(expr *ssa.Extract) llvm.Value {
 		// it to the correct type, and dereference it.
 		recvbuf := b.selectRecvBuf[expr.Tuple.(*ssa.Select)]
 		typ := b.getLLVMType(expr.Type())
-		ptr := b.CreateBitCast(recvbuf, llvm.PointerType(typ, 0), "")
-		return b.CreateLoad(typ, ptr, "")
+		return b.CreateLoad(typ, recvbuf, "")
 	}
 }