malloc and strcpy in LLVM

[ghost]

Hi everyone,

I'm still discovering LLIR/LLVM. I need to support global string variables in my target language. My goal is:

• define a global point to string
• allocate a block of memory with malloc
• copy a string constant in the allocated block
• copy the address of the block to the global variable
• ... // in real word, do something else
• get memory address from global variable
• free memory

So I wrote the following prototype code the implement this:

func TestStrAllocGEN(*testing.T) {
	// Create a new LLVM IR module.
	m := ir.NewModule()
	// Convenience types and values.
	i32 := types.I32
	i8 := types.I8
	i8ptr := types.NewPointer(i8)

	// create link to stdlib.h
	// add string functions
	strcpy := m.NewFunc("strcpy", i8ptr, ir.NewParam("dst", i8ptr), ir.NewParam("src", i8ptr))
	puts := m.NewFunc("puts", i32, ir.NewParam("s", i8ptr))

	// memory management
	malloc := m.NewFunc("malloc", i8ptr, ir.NewParam("size", types.I32))
	free := m.NewFunc("free", types.Void, ir.NewParam("ptr", i8ptr))

	// Create a global variable of type string.
	str := m.NewGlobal("str", i8ptr)
	str.Init = constant.NewNull(i8ptr)

	// Create a new function main which returns an i32.
	main := m.NewFunc("main", types.I32)
	entry := main.NewBlock("")

	// create temporary string
	str0 := constant.NewCharArrayFromString("Hello, World!\n\x00")
	length := int64(len(str0.X))
	// allocate memory on heap
	str1 := entry.NewCall(malloc, constant.NewInt(types.I32, length))
	// copy string to allocated memory
	// gep := constant.NewGetElementPtr(str0.Typ, str0, zero, zero)
	entry.NewCall(strcpy, str1, str0)
	// store pointer to global string
	entry.NewStore(str1, str)

	// capture the pointer to the string
	str2 := entry.NewLoad(i8ptr, str)
	// call puts
	entry.NewCall(puts, str2) // verify we have the proper content

	// free memory
	entry.NewCall(free, str2)

	// Return 0 from main.
	entry.NewRet(constant.NewInt(types.I32, 0))
	fmt.Println(m)
}

This generated this LLVM:

@str = global i8* null

declare i8* @strcpy(i8* %dst, i8* %src)

declare i32 @puts(i8* %s)

declare i8* @malloc(i32 %size)

declare void @free(i8* %ptr)

define i32 @main() {
0:
	%1 = call i8* @malloc(i32 15)
    
	%2 = call i8* @strcpy(i8* %1, [15 x i8] c"Hello, World!\0A\00"). ; <-- error is here
	store i8* %1, i8** @str. ; <<-- from here and below, not tested yet!
	%3 = load i8*, i8** @str
	%4 = call i32 @puts(i8* %3)
	call void @free(i8* %1)
	ret i32 0
}

I get a segmentation fault error in the strcpy call. Could you help me figuring out what is wrong? Thank you in advance for your precious time.

[ghost]

Here is my own solution (Thanks to C and clang).

for those interested, here is the revised code:

func TestStrAllocGEN(*testing.T) {
	// Create a new LLVM IR module.
	m := ir.NewModule()
	// Convenience types and values.
	i32 := types.I32
	i8 := types.I8
	i8ptr := types.NewPointer(i8)

	// create link to stdlib.h
	// add string functions
	strcpy := m.NewFunc("strcpy", i8ptr, ir.NewParam("dst", i8ptr), ir.NewParam("src", i8ptr))
	puts := m.NewFunc("puts", i32, ir.NewParam("s", i8ptr))

	// memory management
	malloc := m.NewFunc("malloc", i8ptr, ir.NewParam("size", types.I32))
	free := m.NewFunc("free", types.Void, ir.NewParam("ptr", i8ptr))

	// Create a global variable of type string.
	str := m.NewGlobal("str", i8ptr)
	str.Init = constant.NewNull(i8ptr)

	// test constant
	constantStr0 := constant.NewCharArrayFromString("Hello, World!\n\x00")
	constantStr1 := m.NewGlobalDef(".str0", constantStr0)

	// ---------------------------------------------------------
	// main ()
	// ---------------------------------------------------------
	// Create a new function main which returns an i32.
	main := m.NewFunc("main", types.I32)
	entry := main.NewBlock("")

	length := int64(len(constantStr0.X))
	// allocate heap memory for global strings
	str2 := entry.NewCall(malloc, constant.NewInt(types.I32, length))
	entry.NewStore(str2, str)

	// copy string to allocated memory
	str3 := entry.NewLoad(i8ptr, str)
	entry.NewCall(strcpy, str3, constantStr1)

	// capture the pointer to the string
	str10 := entry.NewLoad(i8ptr, str)
	// call puts
	entry.NewCall(puts, str10)

	// free memory
	entry.NewCall(free, str10)

	// Return 0 from main.
	entry.NewRet(constant.NewInt(types.I32, 0))
	fmt.Println(m)
}

And the resulting LLVM:

@str = global i8* null
@.str0 = global [15 x i8] c"Hello, World!\0A\00"

declare i8* @strcpy(i8* %dst, i8* %src)

declare i32 @puts(i8* %s)

declare i8* @malloc(i32 %size)

declare void @free(i8* %ptr)

define i32 @main() {
0:
        %1 = call i8* @malloc(i32 15)
        store i8* %1, i8** @str
        %2 = load i8*, i8** @str
        %3 = call i8* @strcpy(i8* %2, [15 x i8]* @.str0)
        %4 = load i8*, i8** @str
        %5 = call i32 @puts(i8* %4)
        call void @free(i8* %4)
        ret i32 0
}