Fix concurrent map access

bbq/compiler/compiler.go

@@ -103,7 +103,7 @@ func NewCompiler(
 		Elaboration:     elaboration,
 		Config:          &Config{},
 		globals:         make(map[string]*global),
-		importedGlobals: indexedNativeFunctions,
+		importedGlobals: NativeFunctions(),
 		typesInPool:     make(map[sema.TypeID]uint16),
 		constantsInPool: make(map[constantsCacheKey]*constant),
 		compositeTypeStack: &Stack[*sema.CompositeType]{

bbq/compiler/native_functions.go

@@ -24,9 +24,16 @@ import (
 	"github.com/onflow/cadence/bbq/commons"
 )
 
-var indexedNativeFunctions = make(map[string]*global)
 var nativeFunctions []*global
 
+func NativeFunctions() map[string]*global {
+	funcs := make(map[string]*global, len(nativeFunctions))
+	for _, value := range nativeFunctions {
+		funcs[value.name] = value
+	}
+	return funcs
+}
+
 var builtinTypes = []sema.Type{
 	sema.StringType,
 	sema.AccountType,
@@ -72,5 +79,4 @@ func addNativeFunction(name string) {
 		name: name,
 	}
 	nativeFunctions = append(nativeFunctions, global)
-	indexedNativeFunctions[name] = global
 }

bbq/vm/native_functions.go

@@ -28,15 +28,23 @@ import (
 	"github.com/onflow/cadence/stdlib"
 )
 
-var NativeFunctions = map[string]Value{}
+var nativeFunctions = map[string]Value{}
 
 // BuiltInLocation is the location of built-in constructs.
 // It's always nil.
 var BuiltInLocation common.Location = nil
 
+func NativeFunctions() map[string]Value {
+	funcs := make(map[string]Value, len(nativeFunctions))
+	for name, value := range nativeFunctions {
+		funcs[name] = value
+	}
+	return funcs
+}
+
 func RegisterFunction(functionName string, functionValue NativeFunctionValue) {
 	functionValue.Name = functionName
-	NativeFunctions[functionName] = functionValue
+	nativeFunctions[functionName] = functionValue
 }
 
 func RegisterTypeBoundFunction(typeName, functionName string, functionValue NativeFunctionValue) {

bbq/vm/vm.go

@@ -56,9 +56,10 @@ func NewVM(
 	// linkedGlobalsCache is a local cache-alike that is being used to hold already linked imports.
 	linkedGlobalsCache := map[common.Location]LinkedGlobals{
 		BuiltInLocation: {
-			// It is safe to re-use native functions map here because,
-			// once put into the cache, it will only be used for read-only operations.
-			indexedGlobals: NativeFunctions,
+			// It is NOT safe to re-use native functions map here because,
+			// once put into the cache, it will be updated by adding the
+			// globals of the current program.
+			indexedGlobals: NativeFunctions(),
 		},
 	}