lua/bpf: implement explicit PTR[0] operation

the BPF maps and pointers were previously
implicitly dereferenced whenever an operation
on them required a value and not a pointer.
the upside is that accessing map element data
didn’t require an explicit operation, the downside
is that it wasn’t possible to get the value
explicitly.

this makes it possible to dereference any pointer
and materialize the value in the register as long
as it’s shorter than register width using `ptr[0]`
element access operator.

src/lua/bpf/bpf.lua

@@ -615,6 +615,7 @@ local function MAP_SET(map_var, key, key_imm, src)
 	reg_alloc(stackslots, 4) -- Spill anything in R4 (unnamed tmp variable)
 	emit(BPF.ALU64 + BPF.MOV + BPF.K, 4, 0, 0, 0) -- BPF_ANY, create new element or update existing
 	-- Reserve R3 for value pointer
+	reg_alloc(stackslots, 3) -- Spill anything in R3 (unnamed tmp variable)
 	local val_size = ffi.sizeof(map.val_type)
 	local w = const_width[val_size] or BPF.DW
 	local pod_type = const_width[val_size]
@@ -627,14 +628,25 @@ local function MAP_SET(map_var, key, key_imm, src)
 		emit(BPF.MEM + BPF.ST + w, 10, 0, -sp, base)
 	-- Value is in register, spill it
 	elseif V[src].reg and pod_type then
-		emit(BPF.MEM + BPF.STX + w, 10, V[src].reg, -sp, 0)
+		-- Value is a pointer, derefernce it and spill it
+		if cdef.isptr(V[src].type) then
+			vderef(3, V[src].reg, V[src].const.__dissector)
+			emit(BPF.MEM + BPF.STX + w, 10, 3, -sp, 0)
+		else
+			emit(BPF.MEM + BPF.STX + w, 10, V[src].reg, -sp, 0)
+		end
 	-- We get a pointer to spilled register on stack
 	elseif V[src].spill then
 		-- If variable is a pointer, we can load it to R3 directly (save "LEA")
 		if cdef.isptr(V[src].type) then
 			reg_fill(src, 3)
-			emit(BPF.JMP + BPF.CALL, 0, 0, 0, HELPER.map_update_elem)
-			return
+			-- If variable is a stack pointer, we don't have to check it
+			if base.__base then
+				emit(BPF.JMP + BPF.CALL, 0, 0, 0, HELPER.map_update_elem)
+				return
+			end
+			vderef(3, V[src].reg, V[src].const.__dissector)
+			emit(BPF.MEM + BPF.STX + w, 10, 3, -sp, 0)
 		else
 			sp = V[src].spill
 		end
@@ -644,9 +656,8 @@ local function MAP_SET(map_var, key, key_imm, src)
 		sp = base.__base
 	-- Value is constant, materialize it on stack
 	else
-		error('VAR '..key..' is neither const-expr/register/stack/spilled')
+		error('VAR '.. key or key_imm ..' is neither const-expr/register/stack/spilled')
 	end
-	reg_alloc(stackslots, 3) -- Spill anything in R3 (unnamed tmp variable)
 	emit(BPF.ALU64 + BPF.MOV + BPF.X, 3, 10, 0, 0)
 	emit(BPF.ALU64 + BPF.ADD + BPF.K, 3, 0, 0, -sp)
 	emit(BPF.JMP + BPF.CALL, 0, 0, 0, HELPER.map_update_elem)
@@ -731,6 +742,12 @@ local BC = {
 		local base = V[b].const
 		if base.__map then -- BPF map read (constant)
 			MAP_GET(a, b, nil, d)
+		-- Specialise PTR[0] as dereference operator
+		elseif cdef.isptr(V[b].type) and d == 0 then
+			vcopy(a, b)
+			local dst_reg = vreg(a)
+			vderef(dst_reg, dst_reg, V[a].const.__dissector)
+			V[a].type = V[a].const.__dissector
 		else
 			LOAD(a, b, d, ffi.typeof('uint8_t'))
 		end
@@ -912,6 +929,10 @@ local BC = {
 	end,
 	RET1 = function (a, _, _, _) -- RET1
 		if V[a].reg ~= 0 then vreg(a, 0) end
+		-- Dereference pointer variables
+		if cdef.isptr(V[a].type) then
+			vderef(0, 0, V[a].const.__dissector)
+		end
 		emit(BPF.JMP + BPF.EXIT, 0, 0, 0, 0)
 		-- Free optimisation: spilled variable will not be filled again
 		for _,v in pairs(V) do if v.reg == 0 then v.reg = nil end end