Thanx for ur reply.I have a few more questions below:
Paolo Bonzini-2 wrote:
>
> Darthrader (sent by Nabble.com) wrote:
>> Is the AST[Abstract Syntax Tree] machine dependent?
>
> The nodes that are generated for the program as it is parsed are machine
> independent. However:
>
> 1) this can only be true if your source code is already preprocessed.
> Otherwise, the source code that GCC really sees it is different. If you
> use the "--save-temps" option, you will find a .i file which is what GCC
> has built the parse tree from.
> --------------------
> I saw the .i file but i could not make any sense out of it.Its the program
> code (mine was a very simple 4 line code) but in the part before main() it
> contains :
>
> # 1 "test.c"
> # 1 " "
> # 1 " "
> # 1 "test.c"
>
> What do these represent?
> --------------------
>
> 2) Some tree nodes are implicit in the compiler, and are always created
> even if the program does not mention them. You can imagine that every
> program had on top of it something like:
>
> typedef void __attribute__ ((mode (QI))) char;
> typedef void __attribute__ ((mode (HI))) short;
> typedef void __attribute__ ((mode (SI))) int;
> typedef void __attribute__ ((mode (__word__))) long;
> typedef void __attribute__ ((mode (DI))) long long;
>
> (which is not really valid C code, of course!) and so on. GCC's
> syntax tree nodes are heavily annotated with information on the nodes,
> and the information for these implicit nodes can be machine dependent:
> for example, long may have 4 bytes on some machines and 8 bytes on
> others. In your case, "algn" was the alignment required by the type.
>
> -----------------
> Kindly elaborate on algn.The alignment required by the type relative to what
> and why?
> -----------------
>
> 3) Some of the information percolates from the types to other tree
> nodes, such as the variables. So your "original" dump could contain
> some differences in the tree nodes for variables: these come from the
> machine dependent nodes I just described.
>
> 4) Finally, some minor optimizations in fold-const.c that are performed
> before the ".original" dump is emitted, so you could see differences
> because of that.
>
> You probably know that a compiler is roughly divided in front-ends
> (reads source code), middle-end (works on an intermediate
> representation), and back-end (uses the intermediate representation to
> emit assembly).
>
> Very roughly speaking, GCC's middle-end starts in fold-const.c. GCC's
> middle-end uses more or less four intermediate representation: GENERIC
> (a standardized form of syntax trees), GIMPLE (an even more standardized
> and simplified form of syntax trees), RTL, and "strict" RTL (where each
> instruction and each operand has an almost 1-1 mapping with the assembly
> language instructions and operands). In practice it is a bit more
> complicated because GENERIC is transformed to GIMPLE "slowly" and gradually.
>
> GCC's syntax trees are pretty well machine independent, enough
> independent that they work well as a machine independent intermediate
> representation for many optimization passes at the beginning in the
> compiler pipeline. As GCC switches from tree nodes to RTL and to strict
> RTL, more and more machine dependent pieces creep into its intermediate
> representation. In the end, things are so machine dependent that most
> non-trivial changes to the RTL middle-end had better be tested on more
> than one machine: they can work like a charm on i686 and break, say,
> powerpc or arm or s390 or all of these.
>
> Paolo
>
>
>
--
View this message in context:
http://www.nabble.com/Machine-Dependance-t1047440.html#a2725013
Sent from the gcc - Dev forum at Nabble.com.
