native: add support for (elf) globals (#25016)

Eliyaan · web-flow · commit c49b9da04e8d · 2025-08-01T06:38:49.000+03:00
diff --git a/vlib/v/gen/native/amd64.v b/vlib/v/gen/native/amd64.v
@@ -334,7 +334,7 @@ fn (mut c Amd64) cmp_var_reg(var Var, reg Register, config VarConfig) {
 			c.g.println('cmp var `${var.name}`, ${reg}')
 		}
 		GlobalVar {
-			// TODO
+			c.g.n_error('${@LOCATION} unsupported var type ${var}')
 		}
 		ExternVar {
 			c.g.n_error('${@LOCATION} unsupported var type ${var}')
@@ -383,7 +383,7 @@ fn (mut c Amd64) cmp_var(var Var, val i32, config VarConfig) {
 			c.g.println('cmp var `${var.name}` ${val}')
 		}
 		GlobalVar {
-			// TODO
+			c.g.n_error('${@LOCATION} unsupported var type ${var}')
 		}
 		ExternVar {
 			c.g.n_error('${@LOCATION} unsupported var type ${var}')
@@ -433,7 +433,7 @@ fn (mut c Amd64) dec_var(var Var, config VarConfig) {
 			c.g.println('dec_var `${var.name}`')
 		}
 		GlobalVar {
-			// TODO
+			c.g.n_error('${@LOCATION} unsupported var type ${var}')
 		}
 		ExternVar {
 			c.g.n_error('${@LOCATION} unsupported var type ${var}')
@@ -507,8 +507,7 @@ fn (mut c Amd64) inc_var(var Var, config VarConfig) {
 			c.g.println('inc_var ${size_str} `${var.name}`')
 		}
 		GlobalVar {
-			c.g.n_error('${@LOCATION} Global variables incrementation is not supported yet')
-			// TODO
+			c.g.n_error('${@LOCATION} unsupported var type ${var}')
 		}
 		ExternVar {
 			c.g.n_error('${@LOCATION} unsupported var type ${var}')
@@ -794,8 +793,24 @@ fn (mut c Amd64) mov_reg_to_var(var Var, r Register, config VarConfig) {
 			c.g.println('mov ${size_str} PTR [rbp-${int(offset).hex2()}],${reg} ; `${var.name}`')
 		}
 		GlobalVar {
-			// TODO
-			c.g.n_error('${@LOCATION} Unsupported GlobalVar')
+			size := match c.g.get_type_size(var.typ) {
+				1 { Size._8 }
+				2 { Size._16 }
+				4 { Size._32 }
+				8 { Size._64 }
+				else { c.g.n_error('${@LOCATION} unsupported size of global var') }
+			}
+			mut addr_reg := Amd64Register.rdx
+			if reg == .rdx || reg == .edx {
+				addr_reg = .rax
+			}
+			c.push(addr_reg)
+			c.g.global_vars[c.g.pos() + 2] = var.name // +2 for the mov64 instruction
+			c.mov64(addr_reg, i64(0))
+			c.g.println('; will get patched by relocs')
+			c.mov_store(addr_reg, reg, size)
+			c.pop(addr_reg)
+			c.g.println('; mov global:`${var.name}` ${reg}')
 		}
 		ExternVar {
 			c.g.n_error('${@LOCATION} unsupported var type ${var}')
@@ -886,7 +901,7 @@ fn (mut c Amd64) mov_int_to_var(var Var, integer i32, config VarConfig) {
 			}
 		}
 		GlobalVar {
-			// TODO
+			c.g.n_error('${@LOCATION} unsupported var type ${var}')
 		}
 		ExternVar {
 			c.g.n_error('${@LOCATION} unsupported var type ${var}')
@@ -1009,7 +1024,20 @@ fn (mut c Amd64) mov_var_to_reg(reg Register, var Var, config VarConfig) {
 			c.g.println('${instruction} ${reg}, ${size_str} PTR [rbp-${int(offset).hex2()}] ; `${var.name}`')
 		}
 		GlobalVar {
-			c.g.n_error('${@LOCATION} Unsupported GlobalVar')
+			if c.g.get_type_size(var.typ) > 8 {
+				c.g.n_error('${@LOCATION} unsupported size of global var')
+			}
+			mut addr_reg := Amd64Register.rdx
+			if reg as Amd64Register == .rdx || reg as Amd64Register == .edx {
+				addr_reg = .rax
+			}
+			c.push(addr_reg)
+			c.g.global_vars[c.g.pos() + 2] = var.name // +2 for the mov64 instruction
+			c.mov64(addr_reg, i64(0))
+			c.g.println('; will get patched by relocs')
+			c.mov_deref(reg, addr_reg, var.typ)
+			c.pop(addr_reg)
+			c.g.println('; mov ${reg} global:`${var.name}`')
 		}
 		ExternVar {
 			c.g.n_error('${@LOCATION} unsupported var type ${var}')
@@ -3859,7 +3887,7 @@ fn (mut c Amd64) init_struct(var Var, init ast.StructInit) {
 			}
 		}
 		GlobalVar {
-			c.g.n_error('${@LOCATION} GlobalVar not implemented for ast.StructInit')
+			c.g.n_error('${@LOCATION} unsupported var type ${var}')
 		}
 		ExternVar {
 			c.g.n_error('${@LOCATION} unsupported var type ${var}')
@@ -3932,7 +3960,7 @@ fn (mut c Amd64) init_array(var Var, node ast.ArrayInit) {
 			}
 		}
 		GlobalVar {
-			c.g.n_error('${@LOCATION} GlobalVar not implemented for ast.ArrayInit')
+			c.g.n_error('${@LOCATION} unsupported var type ${var}')
 		}
 		ExternVar {
 			c.g.n_error('${@LOCATION} unsupported var type ${var}')
@@ -4265,7 +4293,7 @@ fn (mut c Amd64) mov_ssereg_to_var(var Var, reg Amd64SSERegister, config VarConf
 			c.g.println('${inst} [rbp-${int(offset).hex2()}], ${reg}')
 		}
 		GlobalVar {
-			// TODO
+			c.g.n_error('${@LOCATION} unsupported var type ${var}')
 		}
 		ExternVar {
 			c.g.n_error('${@LOCATION} unsupported var type ${var}')
@@ -4321,7 +4349,7 @@ fn (mut c Amd64) mov_var_to_ssereg(reg Amd64SSERegister, var Var, config VarConf
 			c.g.println('${inst} ${reg}, [rbp-${int(offset).hex2()}]')
 		}
 		GlobalVar {
-			// TODO
+			c.g.n_error('${@LOCATION} unsupported var type ${var}')
 		}
 		ExternVar {
 			c.g.n_error('${@LOCATION} unsupported var type ${var}')
diff --git a/vlib/v/gen/native/blacklist.v b/vlib/v/gen/native/blacklist.v
@@ -55,6 +55,13 @@ const blacklist = {
 	'string.last_index':    true
 	'string.last_index_u8': false
 	'string.contains_u8':   false
+	'malloc_noscan':        true
+	'vmemcpy':              false
+	'eprint':               false
+	'eprintln':             false
+	'_write_buf_to_fd':     false
+	'_writeln_to_fd':       false
+	'_memory_panic':        true
 }
 
 const windows_blacklist = {
diff --git a/vlib/v/gen/native/elf.v b/vlib/v/gen/native/elf.v
@@ -4,6 +4,7 @@
 module native
 
 import os
+import ast
 
 const elf_class32 = 1
 const elf_class64 = 2
@@ -300,6 +301,8 @@ mut:
 	size  i64 // Symbol size.
 }
 
+// see for more details: https://gist.github.com/x0nu11byt3/bcb35c3de461e5fb66173071a2379779
+// https://www.etherington.xyz/elfguide#symtab-section-entries
 fn (mut g Gen) create_symbol_table_section(str_name string, info u8, bind u8, other i8, value i64, size i64,
 	shndx i16) SymbolTableSection {
 	return SymbolTableSection{
@@ -615,7 +618,6 @@ fn (mut g Gen) gen_section_data(sections []Section) {
 				for rela in data {
 					g.write64(rela.offset)
 					g.fn_addr[rela.name] = rela.offset // that's wierd it's the call offset, not the fn
-					g.fn_names << rela.name
 					g.write64(rela.info)
 					g.write64(rela.addend)
 					g.println('; SHT_RELA `${rela.name}` (${rela.offset}, ${rela.info}, ${rela.addend})')
@@ -711,6 +713,23 @@ pub fn (mut g Gen) generate_linkable_elf_header() {
 			elf_stv_default, 0, 0, 0),
 	]
 
+	mut sym_data_offset := 0 // offset from the beggining of the data section
+	for f in g.files {
+		for s in f.stmts {
+			if s is ast.GlobalDecl {
+				for fi in s.fields {
+					size := g.get_type_size(fi.typ)
+					if size > 0 {
+						g.symbol_table << g.create_symbol_table_section(fi.name, elf_stt_object,
+							elf_stb_global, elf_stv_default, sym_data_offset, size, i16(g.find_section_header('.data',
+							sections)))
+					}
+					sym_data_offset += size
+				}
+			}
+		}
+	}
+
 	for symbol in g.extern_symbols {
 		g.symbol_table << g.create_symbol_table_section(symbol[2..], elf_stt_notype, elf_stb_global,
 			elf_stv_default, 0, 0, 0)
@@ -742,6 +761,37 @@ pub fn (mut g Gen) generate_linkable_elf_header() {
 
 	g.elf_rela_section = sections[g.find_section_header('.rela.text', sections)]
 
+	// Init data section
+	// TODO: use .bss for uninitialized data or generate the data
+	data_section := sections[g.find_section_header('.data', sections)]
+	g.elf_data_header_addr = data_section.header.offset
+
+	data_pos := g.pos()
+	g.println('\ndata_start_pos = ${data_pos.hex()}')
+	g.write64_at(g.elf_data_header_addr + 24, data_pos)
+	for f in g.files {
+		for s in f.stmts {
+			if s is ast.GlobalDecl {
+				for fi in s.fields {
+					size := g.get_type_size(fi.typ)
+					match size {
+						1 { g.write8(0xF) }
+						2 { g.write16(0xF) }
+						4 { g.write32(0xF) }
+						8 { g.write64(i64(0xF)) }
+						else { println('${@LOCATION} unsupported size ${size} for global ${fi}') }
+					}
+					g.println('; global ${fi.name}, size: ${size}')
+				}
+			}
+		}
+	}
+	g.write64_at(g.elf_data_header_addr + 32, g.pos() - data_pos)
+	// TODO: pre-calculate .data instead of genetating it at runtime
+
+	// It is wierd, the init section has something in it but I did not find
+	// where does it come from
+
 	// user code starts here
 	if g.pref.is_verbose {
 		eprintln('code_start_pos = ${g.buf.len.hex()}')
@@ -752,11 +802,29 @@ pub fn (mut g Gen) generate_linkable_elf_header() {
 	// if g.start_symbol_addr > 0 {
 	//	g.write64_at(g.start_symbol_addr + native.elf_symtab_size - 16, g.code_start_pos)
 	//}
-
 	text_section := sections[g.find_section_header('.text', sections)]
 	g.elf_text_header_addr = text_section.header.offset
 	g.write64_at(g.elf_text_header_addr + 24, g.pos()) // write the code start pos to the text section
 
+	g.println('; fill .data')
+	for f in g.files {
+		for s in f.stmts {
+			if s is ast.GlobalDecl {
+				for fi in s.fields {
+					size := g.get_type_size(fi.typ)
+					if size > 8 || size <= 0 {
+						println('${@LOCATION} unsupported size ${size} for global ${fi}')
+					} else if fi.expr !is ast.EmptyExpr {
+						g.expr(fi.expr)
+						g.code_gen.mov_reg_to_var(GlobalVar{fi.name, fi.typ}, g.code_gen.main_reg())
+						g.println('; global ${fi.name}, size: ${size}')
+					}
+				}
+			}
+		}
+	}
+
+	g.elf_main_call_pos = g.pos()
 	g.code_gen.call(placeholder)
 	g.println('; call main.main')
 	g.code_gen.mov64(g.code_gen.main_reg(), i64(0))
@@ -848,9 +916,13 @@ pub fn (mut g Gen) gen_rela_section() {
 			g.symtab_get_index(g.symbol_table, symbol[2..]), elf_r_amd64_gotpcrelx, -4)
 	}
 	for var_pos, symbol in g.extern_vars {
-		relocations << g.create_rela_section(symbol, var_pos - g.code_start_pos + 2, g.symtab_get_index(g.symbol_table,
+		relocations << g.create_rela_section(symbol, var_pos - g.code_start_pos, g.symtab_get_index(g.symbol_table,
 			symbol[2..]), elf_r_amd64_64, 0)
 	}
+	for var_pos, symbol in g.global_vars {
+		relocations << g.create_rela_section(symbol, var_pos - g.code_start_pos, g.symtab_get_index(g.symbol_table,
+			symbol), elf_r_amd64_64, 0)
+	}
 	g.elf_rela_section.data = relocations
 	g.gen_section_data([g.elf_rela_section])
 }
@@ -872,15 +944,15 @@ pub fn (mut g Gen) generate_elf_footer() {
 	g.write64_at(g.file_size_pos + 8, file_size)
 	if g.pref.arch == .arm64 {
 		bl_next := u32(0x94000001)
-		g.write32_at(g.code_start_pos, i32(bl_next))
+		g.write32_at(g.elf_main_call_pos, i32(bl_next))
 	} else {
 		// amd64
 		// call main function, it's not guaranteed to be the first
 		// we generated call(0) ("e8 0")
 		// now need to replace "0" with a relative address of the main function
 		// +1 is for "e8"
 		// -5 is for "e8 00 00 00 00"
-		g.write32_at(g.code_start_pos + 1, i32(g.main_fn_addr - g.code_start_pos) - 5)
+		g.write32_at(g.elf_main_call_pos + 1, i32(g.main_fn_addr - g.elf_main_call_pos) - 5)
 	}
 	g.create_executable()
 }
diff --git a/vlib/v/gen/native/expr.v b/vlib/v/gen/native/expr.v
@@ -196,7 +196,7 @@ fn (mut g Gen) local_var_ident(ident ast.Ident, var LocalVar) {
 fn (mut g Gen) extern_var_ident(var ExternVar) {
 	if g.pref.os == .linux {
 		main_reg := g.code_gen.main_reg()
-		g.extern_vars[g.pos()] = var.name
+		g.extern_vars[g.pos() + 2] = var.name // + 2 for the mov64 instruction
 		g.code_gen.mov64(main_reg, Number(i64(0)))
 		g.code_gen.mov_deref(main_reg, main_reg, ast.u64_type_idx)
 	} else if g.pref.os == .macos {
diff --git a/vlib/v/gen/native/gen.v b/vlib/v/gen/native/gen.v
@@ -39,8 +39,9 @@ mut:
 	extern_symbols            []string
 	linker_include_paths      []string
 	linker_libs               []string
-	extern_vars               map[i64]string
-	extern_fn_calls           map[i64]string
+	global_vars               map[i64]string // used to patch
+	extern_vars               map[i64]string // used to patch
+	extern_fn_calls           map[i64]string // used to patch
 	fn_addr                   map[string]i64
 	fn_names                  []string
 	var_offset                map[string]i32 // local var stack offset
@@ -65,7 +66,9 @@ mut:
 	return_type               ast.Type
 	comptime_omitted_branches []ast.IfBranch
 	// elf specific
+	elf_main_call_pos    i64
 	elf_text_header_addr i64 = -1
+	elf_data_header_addr i64 = -1
 	elf_rela_section     Section
 	// macho specific
 	macho_ncmds   i32
@@ -253,7 +256,10 @@ struct PreprocVar {
 	val  i64
 }
 
-struct GlobalVar {}
+struct GlobalVar {
+	name string
+	typ  ast.Type
+}
 
 @[params]
 struct VarConfig {
@@ -300,7 +306,9 @@ fn (mut g Gen) get_var_from_ident(ident ast.Ident) IdentVar {
 		return PreprocVar{ident.info.typ, ident.name, preprocessed_val}
 	}
 	mut obj := ident.obj
-	if obj !in [ast.Var, ast.ConstField, ast.GlobalField, ast.AsmRegister] {
+	if obj is ast.GlobalField {
+		return GlobalVar{obj.name, obj.typ}
+	} else if obj !in [ast.Var, ast.ConstField, ast.AsmRegister] {
 		obj = ident.scope.find(ident.name) or {
 			g.n_error('${@LOCATION} unknown variable ${ident.name}')
 		}
@@ -389,6 +397,7 @@ pub fn gen(files []&ast.File, mut table ast.Table, out_name string, pref_ &pref.
 	g.init_builtins()
 	g.calculate_all_size_align()
 	g.calculate_enum_fields()
+	g.fn_names = g.table.fns.keys()
 	for file in g.files {
 		/*
 		if file.warnings.len > 0 {
@@ -1175,7 +1184,6 @@ fn (mut g Gen) fn_decl(node ast.FnDecl) {
 	g.stack_var_pos = 0
 	g.stack_depth = 0
 	g.register_function_address(name)
-	g.fn_names << name
 	g.labels = &LabelTable{}
 	g.defer_stmts.clear()
 	g.return_type = node.return_type
@@ -1225,6 +1233,7 @@ fn (mut g Gen) println(comment string) {
 @[noreturn]
 pub fn (mut g Gen) n_error(s string) {
 	print_backtrace()
+	flush_stdout()
 	util.verror('native error', s)
 }
 
diff --git a/vlib/v/gen/native/stmt.c.v b/vlib/v/gen/native/stmt.c.v
@@ -106,8 +106,10 @@ fn (mut g Gen) stmt(node ast.Stmt) {
 			g.gen_assert(node)
 		}
 		ast.GlobalDecl {
-			if !g.is_builtin_mod && !g.pref.experimental {
-				g.warning('globals are not supported yet', node.pos)
+			if g.pref.os == .linux {
+				// handled in elf generator
+			} else if !g.is_builtin_mod && !g.pref.experimental {
+				g.warning('global variables are not supported', node.pos)
 			}
 		}
 		ast.Import {} // do nothing here
diff --git a/vlib/v/gen/native/tests/linux.vv b/vlib/v/gen/native/tests/linux.vv
diff --git a/vlib/v/gen/native/tests/native_test.v b/vlib/v/gen/native/tests/native_test.v

Original file line number	Diff line number	Diff line change
`@@ -334,7 +334,7 @@ fn (mut c Amd64) cmp_var_reg(var Var, reg Register, config VarConfig) {`
`334`	`334`	c.g.println('cmp var `${var.name}`, ${reg}')
`335`	`335`	`}`
`336`	`336`	`GlobalVar {`
`337`		`- // TODO`
	`337`	`+ c.g.n_error('${@LOCATION} unsupported var type ${var}')`
`338`	`338`	`}`
`339`	`339`	`ExternVar {`
`340`	`340`	`c.g.n_error('${@LOCATION} unsupported var type ${var}')`
`@@ -383,7 +383,7 @@ fn (mut c Amd64) cmp_var(var Var, val i32, config VarConfig) {`
`383`	`383`	c.g.println('cmp var `${var.name}` ${val}')
`384`	`384`	`}`
`385`	`385`	`GlobalVar {`
`386`		`- // TODO`
	`386`	`+ c.g.n_error('${@LOCATION} unsupported var type ${var}')`
`387`	`387`	`}`
`388`	`388`	`ExternVar {`
`389`	`389`	`c.g.n_error('${@LOCATION} unsupported var type ${var}')`
`@@ -433,7 +433,7 @@ fn (mut c Amd64) dec_var(var Var, config VarConfig) {`
`433`	`433`	c.g.println('dec_var `${var.name}`')
`434`	`434`	`}`
`435`	`435`	`GlobalVar {`
`436`		`- // TODO`
	`436`	`+ c.g.n_error('${@LOCATION} unsupported var type ${var}')`
`437`	`437`	`}`
`438`	`438`	`ExternVar {`
`439`	`439`	`c.g.n_error('${@LOCATION} unsupported var type ${var}')`
`@@ -507,8 +507,7 @@ fn (mut c Amd64) inc_var(var Var, config VarConfig) {`
`507`	`507`	c.g.println('inc_var ${size_str} `${var.name}`')
`508`	`508`	`}`
`509`	`509`	`GlobalVar {`
`510`		`- c.g.n_error('${@LOCATION} Global variables incrementation is not supported yet')`
`511`		`- // TODO`
	`510`	`+ c.g.n_error('${@LOCATION} unsupported var type ${var}')`
`512`	`511`	`}`
`513`	`512`	`ExternVar {`
`514`	`513`	`c.g.n_error('${@LOCATION} unsupported var type ${var}')`
`@@ -794,8 +793,24 @@ fn (mut c Amd64) mov_reg_to_var(var Var, r Register, config VarConfig) {`
`794`	`793`	c.g.println('mov ${size_str} PTR [rbp-${int(offset).hex2()}],${reg} ; `${var.name}`')
`795`	`794`	`}`
`796`	`795`	`GlobalVar {`
`797`		`- // TODO`
`798`		`- c.g.n_error('${@LOCATION} Unsupported GlobalVar')`
	`796`	`+ size := match c.g.get_type_size(var.typ) {`
	`797`	`+ 1 { Size._8 }`
	`798`	`+ 2 { Size._16 }`
	`799`	`+ 4 { Size._32 }`
	`800`	`+ 8 { Size._64 }`
	`801`	`+ else { c.g.n_error('${@LOCATION} unsupported size of global var') }`
	`802`	`+ }`
	`803`	`+ mut addr_reg := Amd64Register.rdx`
	`804`	`+ if reg == .rdx \|\| reg == .edx {`
	`805`	`+ addr_reg = .rax`
	`806`	`+ }`
	`807`	`+ c.push(addr_reg)`
	`808`	`+ c.g.global_vars[c.g.pos() + 2] = var.name // +2 for the mov64 instruction`
	`809`	`+ c.mov64(addr_reg, i64(0))`
	`810`	`+ c.g.println('; will get patched by relocs')`
	`811`	`+ c.mov_store(addr_reg, reg, size)`
	`812`	`+ c.pop(addr_reg)`
	`813`	+ c.g.println('; mov global:`${var.name}` ${reg}')
`799`	`814`	`}`
`800`	`815`	`ExternVar {`
`801`	`816`	`c.g.n_error('${@LOCATION} unsupported var type ${var}')`
`@@ -886,7 +901,7 @@ fn (mut c Amd64) mov_int_to_var(var Var, integer i32, config VarConfig) {`
`886`	`901`	`}`
`887`	`902`	`}`
`888`	`903`	`GlobalVar {`
`889`		`- // TODO`
	`904`	`+ c.g.n_error('${@LOCATION} unsupported var type ${var}')`
`890`	`905`	`}`
`891`	`906`	`ExternVar {`
`892`	`907`	`c.g.n_error('${@LOCATION} unsupported var type ${var}')`
`@@ -1009,7 +1024,20 @@ fn (mut c Amd64) mov_var_to_reg(reg Register, var Var, config VarConfig) {`
`1009`	`1024`	c.g.println('${instruction} ${reg}, ${size_str} PTR [rbp-${int(offset).hex2()}] ; `${var.name}`')
`1010`	`1025`	`}`
`1011`	`1026`	`GlobalVar {`
`1012`		`- c.g.n_error('${@LOCATION} Unsupported GlobalVar')`
	`1027`	`+ if c.g.get_type_size(var.typ) > 8 {`
	`1028`	`+ c.g.n_error('${@LOCATION} unsupported size of global var')`
	`1029`	`+ }`
	`1030`	`+ mut addr_reg := Amd64Register.rdx`
	`1031`	`+ if reg as Amd64Register == .rdx \|\| reg as Amd64Register == .edx {`
	`1032`	`+ addr_reg = .rax`
	`1033`	`+ }`
	`1034`	`+ c.push(addr_reg)`
	`1035`	`+ c.g.global_vars[c.g.pos() + 2] = var.name // +2 for the mov64 instruction`
	`1036`	`+ c.mov64(addr_reg, i64(0))`
	`1037`	`+ c.g.println('; will get patched by relocs')`
	`1038`	`+ c.mov_deref(reg, addr_reg, var.typ)`
	`1039`	`+ c.pop(addr_reg)`
	`1040`	+ c.g.println('; mov ${reg} global:`${var.name}`')
`1013`	`1041`	`}`
`1014`	`1042`	`ExternVar {`
`1015`	`1043`	`c.g.n_error('${@LOCATION} unsupported var type ${var}')`
`@@ -3859,7 +3887,7 @@ fn (mut c Amd64) init_struct(var Var, init ast.StructInit) {`
`3859`	`3887`	`}`
`3860`	`3888`	`}`
`3861`	`3889`	`GlobalVar {`
`3862`		`- c.g.n_error('${@LOCATION} GlobalVar not implemented for ast.StructInit')`
	`3890`	`+ c.g.n_error('${@LOCATION} unsupported var type ${var}')`
`3863`	`3891`	`}`
`3864`	`3892`	`ExternVar {`
`3865`	`3893`	`c.g.n_error('${@LOCATION} unsupported var type ${var}')`
`@@ -3932,7 +3960,7 @@ fn (mut c Amd64) init_array(var Var, node ast.ArrayInit) {`
`3932`	`3960`	`}`
`3933`	`3961`	`}`
`3934`	`3962`	`GlobalVar {`
`3935`		`- c.g.n_error('${@LOCATION} GlobalVar not implemented for ast.ArrayInit')`
	`3963`	`+ c.g.n_error('${@LOCATION} unsupported var type ${var}')`
`3936`	`3964`	`}`
`3937`	`3965`	`ExternVar {`
`3938`	`3966`	`c.g.n_error('${@LOCATION} unsupported var type ${var}')`
`@@ -4265,7 +4293,7 @@ fn (mut c Amd64) mov_ssereg_to_var(var Var, reg Amd64SSERegister, config VarConf`
`4265`	`4293`	`c.g.println('${inst} [rbp-${int(offset).hex2()}], ${reg}')`
`4266`	`4294`	`}`
`4267`	`4295`	`GlobalVar {`
`4268`		`- // TODO`
	`4296`	`+ c.g.n_error('${@LOCATION} unsupported var type ${var}')`
`4269`	`4297`	`}`
`4270`	`4298`	`ExternVar {`
`4271`	`4299`	`c.g.n_error('${@LOCATION} unsupported var type ${var}')`
`@@ -4321,7 +4349,7 @@ fn (mut c Amd64) mov_var_to_ssereg(reg Amd64SSERegister, var Var, config VarConf`
`4321`	`4349`	`c.g.println('${inst} ${reg}, [rbp-${int(offset).hex2()}]')`
`4322`	`4350`	`}`
`4323`	`4351`	`GlobalVar {`
`4324`		`- // TODO`
	`4352`	`+ c.g.n_error('${@LOCATION} unsupported var type ${var}')`
`4325`	`4353`	`}`
`4326`	`4354`	`ExternVar {`
`4327`	`4355`	`c.g.n_error('${@LOCATION} unsupported var type ${var}')`
Original file line number	Diff line number	Diff line change
`@@ -106,8 +106,10 @@ fn (mut g Gen) stmt(node ast.Stmt) {`
`106`	`106`	`g.gen_assert(node)`
`107`	`107`	`}`
`108`	`108`	`ast.GlobalDecl {`
`109`		`- if !g.is_builtin_mod && !g.pref.experimental {`
`110`		`- g.warning('globals are not supported yet', node.pos)`
	`109`	`+ if g.pref.os == .linux {`
	`110`	`+ // handled in elf generator`
	`111`	`+ } else if !g.is_builtin_mod && !g.pref.experimental {`
	`112`	`+ g.warning('global variables are not supported', node.pos)`
`111`	`113`	`}`
`112`	`114`	`}`
`113`	`115`	`ast.Import {} // do nothing here`