llvm dev - Jul 2008 - [LLVMdev] allocating an array

How can I allocate an array with a size that is not known at compile time?

The language reference says that the array size must be a constant
integer value. It also says that variable sized arrays are represented
by using zero as the number of elements. Obviously I cannot use zero
in the array type when it is allocated. llvm-gcc seems to use a
pointer type instead of an array type, so compiling a simple C program
that uses an array with a runtime size and looking at the resulting
bitcode didn't provide an answer to my question.


Regards,
Kevin André

On Jul 16, 2008, at 11:07 AM, HyperQuantum wrote:
> How can I allocate an array with a size that is not known at compile  
> time?
>
Call malloc()?

--Owen

On Wed, Jul 16, 2008 at 11:07 AM, HyperQuantum <hyperquantum at gmail.com>
wrote:
> How can I allocate an array with a size that is not known at compile time?
>
> The language reference says that the array size must be a constant
> integer value. It also says that variable sized arrays are represented
> by using zero as the number of elements. Obviously I cannot use zero
> in the array type when it is allocated. llvm-gcc seems to use a
> pointer type instead of an array type, so compiling a simple C program
> that uses an array with a runtime size and looking at the resulting
> bitcode didn't provide an answer to my question.
>
Do you mean a variable length array (as in C99) or something else?
LLVM will convert VLAs into an "alloca":

int foo(int X) {
  int a[X];
...
}

define i32 @foo(i32 %X) nounwind  {
entry:
	%tmp23 = alloca i32, i32 %X		; <i32*> [#uses=2]
...
}

If you are doing the zero-sized array hack, then you'll have to call
malloc on it anyway. Something like:

struct a {
  char c;
  int d[0];
};

And then in your program do something like this:

void bar(int z) {
  struct a *fnord = malloc(sizeof(struct a) + z * sizeof(int));
...
}

LLVM will generate the obvious code for that.

-bw

On Wed, Jul 16, 2008 at 8:19 PM, Bill Wendling <isanbard at gmail.com>
wrote:
> On Wed, Jul 16, 2008 at 11:07 AM, HyperQuantum <hyperquantum at
gmail.com> wrote:
>> How can I allocate an array with a size that is not known at compile
time?
> Do you mean a variable length array (as in C99) or something else?
I guess I should have explained what I'm trying to do. I'm working on
a front end for my programming language and using the LLVM libraries
as back end. The arrays in my language are currently represented by an
LLVM structure type that contains integer fields to hold the size for
each array dimension, and then an array type with the actual data for
the array.

A simple example, an array with 3 integers:

  var x : [3] int

For this example the following code is generated:

%x = alloca { i32, [3 x i32] }          ; <{ i32, [3 x i32] }*> [#uses=4]
getelementptr { i32, [3 x i32] }* %x, i32 0, i32 0     ; <i32*>:1
[#uses=1]
store i32 3, i32* %1

(and followed by a loop that initializes the three elements)

But I only tested this with arrays that have an integer constant as
size. Now if I try it with a size that comes from an expression like
this:

  var size : nat = 9
  var x : [size] int

Then my compiler does not know the size of the array and uses a zero
for the type:

%size = alloca i32              ; <i32*> [#uses=2]
store i32 9, i32* %size
%x = alloca { i32, [0 x i32] }          ; <{ i32, [0 x i32] }*> [#uses=4]
load i32* %size         ; <i32>:1 [#uses=1]
getelementptr { i32, [0 x i32] }* %x, i32 0, i32 0              ;
<i32*>:2 [#uses=1]
store i32 %1, i32* %2

Obviously this is wrong, but I don't see how I can use the value from
'size' to allocate the necessary space for this array with alloca. I
could use a pointer to an array in the struct type, instead of a
direct array, and use two allocas (one for the struct and one for the
array data). But then there is no real reason to use the array type
anymore, a pointer to the first element (like llvm-gcc generates for
C/C++ arrays) would be much simpler. Or am I missing something?


Regards,
Kevin André