Support opaque pointers in llvm_boilerplate/function skeletons

[RyanGlScott]

I have recently updated SAW to work with LLVM's opaque pointers, an LLVM language change that replaces pointers with explicit pointee types (e.g., i32*) with opaque pointers that lack pointee types. In an opaque pointer setting, all pointers have the type ptr, and LLVM determines how to interpret the underlying memory based on the types of instructions that the pointers are used in. For more information, see the following links:

• The LLVM page on opaque pointers: https://llvm.org/docs/OpaquePointers.html
• The llvm-pretty PR to support opaque pointers: More complete support for opaque pointers (required for LLVM 15+) llvm-pretty#110
• The llvm-pretty-bc-parser PR to support opaque pointers: More complete support for opaque pointers (required for LLVM 15+) llvm-pretty-bc-parser#221
• The crucible PR to support opaque pointers: More complete support for opaque pointers (required for LLVM 15+) crucible#1085

While most parts of SAW now fully support opaque pointers, there is one part of SAW that cannot handle them at the moment: the llvm_boilerplate command. This is because llvm_boilerplate inspects the skeletons of LLVM function types to determine what boilerplate code to generate, and this code necessarily inspects pointee types. Look at this code to see what I mean:

saw-script/src/SAWScript/Crucible/LLVM/Skeleton.hs

Lines 99 to 104 in 79f69bf

	parseType :: LLVM.Type -> IO TypeSkeleton
	parseType (LLVM.PtrTo t) = pure $ TypeSkeleton t True [SizeGuess 1 True "default guess of size 1"]
	parseType (LLVM.Array i t) = pure $ TypeSkeleton t True
	[ SizeGuess (fromIntegral i) True $ "default guess of size " <> Text.pack (show i)
	]
	parseType t = pure $ TypeSkeleton t False []

This code records which types are pointers and records the pointee types. Later, these TypeSkeletons are used to generate SAWScript code, and different code is generated for pointers that makes use of the pointee types:

saw-script/src/SAWScript/Crucible/LLVM/Boilerplate.hs

Lines 65 to 76 in 79f69bf

	typeBoilerplate :: TypeSkeleton -> Text
	typeBoilerplate t
	| t ^. typeSkelIsPointer
	, (s:_) <- t ^. typeSkelSizeGuesses
	= mconcat
	[ "(llvm_array "
	, Text.pack . show $ s ^. sizeGuessElems
	, " "
	, llvmTypeBoilerplate $ t ^. typeSkelLLVMType
	, ")"
	]
	| otherwise = llvmTypeBoilerplate $ t ^. typeSkelLLVMType

saw-script/src/SAWScript/Crucible/LLVM/Boilerplate.hs

Lines 104 to 113 in 79f69bf

	argPrecondition :: Int -> ArgSkeleton -> Text
	argPrecondition i a
	| a ^. argSkelType . typeSkelIsPointer
	, (s:_) <- a ^. argSkelType . typeSkelSizeGuesses
	, s ^. sizeGuessInitialized
	= mconcat
	[ " ", argName i a, " <- llvm_fresh_var \"", argName i a, "\" ", typeBoilerplate (a ^. argSkelType), ";\n"
	, " ", argName i a, "_ptr <- llvm_alloc ", typeBoilerplate (a ^. argSkelType), ";\n"
	, " llvm_points_to ", argName i a, "_ptr (llvm_term ", argName i a, ");\n\n"
	]

It is not obvious how to adapt this code to work with opaque pointers, which lack pointee types entirely. SAW's llvm_alloc command requires a type to use, so where would we get this type from? Some half-baked ideas I have include:

• Inspect the definitions of each LLVM function to see which instructions involve pointers, and use those instructions to infer the types of pointers' underlying memory. (This sounds quite complex in the general case.)
• Add a variant of the function_skeleton command that allows users to specify what the types of pointers' underlying memory should be. (I'm unclear on what the design for this should look like.)

Because I am unclear on what the right approach should be, I have opted to make SAW error out whener it attempts to construct a skeleton for an opaque pointer type.