+2004-09-17 James Morrison <phython@gcc.gnu.org>
+
+ * doc/cfg.texi: Use @smallexample.
+ * doc/md.texi: Likewise.
+ * doc/tree-ssa.texi: Likewise.
+ * doc/extend.texi: Likewise. Use @r{} in comments.
+ * doc/trouble.texi: Use @r{} in comments.
+
2004-09-17 Hans-Peter Nilsson <hp@bitrange.com>
* configure.ac (gcc_cv_gld_version): Handle whitespace before
The following snippet will pretty-print all the statements of the
program in the GIMPLE representation.
-@example
+@smallexample
FOR_EACH_BB (bb)
@{
block_stmt_iterator si;
print_generic_stmt (stderr, stmt, 0);
@}
@}
-@end example
+@end smallexample
@node Edges
graphs by factoring computed jumps. For example, given the following
series of jumps,
-@example
+@smallexample
goto *x;
[ ... ]
goto *x;
[ ... ]
-@end example
+@end smallexample
@noindent
factoring the computed jumps results in the following code sequence
which has a much simpler flow graph:
-@example
+@smallexample
goto y;
[ ... ]
y:
goto *x;
-@end example
+@end smallexample
However, the classic problem with this transformation is that it has a
runtime cost in there resulting code: An extra jump. Therefore, the
@samp{memory}. As an example, if you access ten bytes of a string, you
can use a memory input like:
-@example
+@smallexample
@{"m"( (@{ struct @{ char x[10]; @} *p = (void *)ptr ; *p; @}) )@}.
-@end example
+@end smallexample
Note that in the following example the memory input is necessary,
otherwise GCC might optimize the store to @code{x} away:
-@example
+@smallexample
int foo ()
@{
int x = 42;
"=&d" (r) : "a" (y), "m" (*y));
return result;
@}
-@end example
+@end smallexample
You can put multiple assembler instructions together in a single
@code{asm} template, separated by the characters normally used in assembly
template <class T> struct A @{ @};
@}
using namespace debug __attribute ((__strong__));
- template <> struct A<int> @{ @}; // ok to specialize
+ template <> struct A<int> @{ @}; // @r{ok to specialize}
template <class T> void f (A<T>);
@}
int main()
@{
- f (std::A<float>()); // lookup finds std::f
+ f (std::A<float>()); // @r{lookup finds} std::f
f (std::A<int>());
@}
@end smallexample
@smallexample
struct S @{ ~S(); @};
- extern void bar(); // is written in Java, and may throw exceptions
+ extern void bar(); // @r{is written in Java, and may throw exceptions}
void foo()
@{
S s;
This is a slight variant on @code{register_operand} which works around
a limitation in the machine-description reader.
-@example
+@smallexample
(match_operand @var{n} "pmode_register_operand" @var{constraint})
-@end example
+@end smallexample
@noindent
means exactly what
-@example
+@smallexample
(match_operand:P @var{n} "register_operand" @var{constraint})
-@end example
+@end smallexample
@noindent
would mean, if the machine-description reader accepted @samp{:P}
For instance, consider the following function:
-@example
+@smallexample
foo (int i)
@{
int *p, *q, a, b;
a = b + 2;
return *p;
@}
-@end example
+@end smallexample
After aliasing analysis has finished, the type memory tag for
pointer @code{p} will have two aliases, namely variables @code{a} and
Every time pointer @code{p} is dereferenced, we want to mark the
operation as a potential reference to @code{a} and @code{b}.
-@example
+@smallexample
foo (int i)
@{
int *p, a, b;
# VUSE <b_8>;
return *p_1;
@}
-@end example
+@end smallexample
In certain cases, the list of may aliases for a pointer may grow
too large. This may cause an explosion in the number of virtual
struct A @{
template <typename T>
void f () @{
- foo (1); // 1
- int i = N; // 2
+ foo (1); // @r{1}
+ int i = N; // @r{2}
T t;
- t.bar(); // 3
- foo (t); // 4
+ t.bar(); // @r{3}
+ foo (t); // @r{4}
@}
static const int N;
projects / gcc.git / commitdiff