llvm dev - Jan 2007 - [LLVMdev] Request documentation for global var syntax

file://docs/LangRef.html#globalvars

The section describing the definition of global vars discusses that you
can specify an alignment and can also specify a section.  Could someone
provide an example that works in gccas in release 1.9 for both defining
which section the var is assigned to and defining the variables
alignment?

Also, is there another document that describes how you define sections
and their attributes?


-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://lists.llvm.org/pipermail/llvm-dev/attachments/20070111/c8a198fa/attachment.html>

On Thu, 11 Jan 2007, Schimmel, Mark wrote:
> file://docs/LangRef.html#globalvars
>
> The section describing the definition of global vars discusses that you
> can specify an alignment and can also specify a section.  Could someone
> provide an example that works in gccas in release 1.9 for both defining
> which section the var is assigned to and defining the variables
> alignment?
They are just comma separated:

%G = constant float 1.000000e+00, section "foo", align 4
> Also, is there another document that describes how you define sections
> and their attributes?
sections are target-specific, usually defined by the linker.

-Chris

-- 
http://nondot.org/sabre/
http://llvm.org/

Does anyone have any good ideas to verify that the layout of a struct
from the front end (field offsets and alignment) exactly match LLVM's
interpretation of that struct?  I want to support packing of structs and
pragmas/attributes for alignment and validate that the front end and
back end match.  [ This is a different front end (ie. Not GNU based). ]

For example:
	__packed struct S1 {
		char c;
		double d;
	};

If I wanted c at byte offset 0 and d at byte offset 1, how would I
communicate that to LLVM?  If the user applied another pragma/attribute
which aligned d at offset 2, how would I communicate that and validate
it?  The assumption here is that the user could declare a struct type
whose layout doesn't match the default layout from LLVM.

Perhaps I could extend llvm-as to accept additional annotations in type
declarations?

	%S1 = type align 1 { sbyte at 0, double at 2 }

I don't see anything like this in the 1.9 grammar.

-----Original Message-----
From: llvmdev-bounces at cs.uiuc.edu [mailto:llvmdev-bounces at cs.uiuc.edu]
On Behalf Of Chris Lattner
Sent: Saturday, January 13, 2007 4:35 PM
To: LLVM Developers Mailing List
Subject: Re: [LLVMdev] Request documentation for global var syntax

On Thu, 11 Jan 2007, Schimmel, Mark wrote:
> file://docs/LangRef.html#globalvars
>
> The section describing the definition of global vars discusses that
you
> can specify an alignment and can also specify a section.  Could
someone
> provide an example that works in gccas in release 1.9 for both
defining
> which section the var is assigned to and defining the variables
> alignment?
They are just comma separated:

%G = constant float 1.000000e+00, section "foo", align 4
> Also, is there another document that describes how you define sections
> and their attributes?
sections are target-specific, usually defined by the linker.

-Chris

-- 
http://nondot.org/sabre/
http://llvm.org/
_______________________________________________
LLVM Developers mailing list
LLVMdev at cs.uiuc.edu         http://llvm.cs.uiuc.edu
http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev

int %nlz10(uint %param.x) {
        %.t3 = shr uint %param.x, ubyte 1               ; <uint>
[#uses=1]
        %.t4 = or uint %.t3, %param.x           ; <uint> [#uses=2]
        %.t7 = shr uint %.t4, ubyte 2           ; <uint> [#uses=1]
        %.t8 = or uint %.t7, %.t4               ; <uint> [#uses=2]
        %.t11 = shr uint %.t8, ubyte 4          ; <uint> [#uses=1]
        %.t12 = or uint %.t11, %.t8             ; <uint> [#uses=2]
        %.t15 = shr uint %.t12, ubyte 8         ; <uint> [#uses=1]
        %.t16 = or uint %.t15, %.t12            ; <uint> [#uses=2]
        %.t19 = shr uint %.t16, ubyte 16                ; <uint>
[#uses=1]
        %.t20 = or uint %.t19, %.t16            ; <uint> [#uses=1]
        %.t22 = mul uint %.t20, 116069625               ; <uint>
[#uses=1]
        %.t25 = shr uint %.t22, ubyte 26                ; <uint>
[#uses=1]
        %.t28 = getelementptr [64 x ubyte]* %table, int 0, uint %.t25
; <ubyte*> [#uses=1]
        %.t28 = load ubyte* %.t28               ; <ubyte> [#uses=1]
        %.t31 = cast ubyte %.t28 to int         ; <int> [#uses=1]
        ret int %.t31
} 

This is the disassembled output after running the optimizer.  How can
%.t28 be written to twice?  That isn't my understanding of SSA.

Here's another similar situation:

        %x.2.i73 = cast uint %x.2.i73 to int            ; <int>
[#uses=1]

Why are we not assigning to a different ssa var?