This is the mail archive of the
mailing list for the GNU Fortran project.
Some thoughts on temporaries for the front-end
- From: Daniel Kraft <d at domob dot eu>
- To: Fortran List <fortran at gcc dot gnu dot org>
- Date: Tue, 05 Aug 2008 18:28:06 +0200
- Subject: Some thoughts on temporaries for the front-end
for finalization of derived-types, the most puzzling pieces still
missing are probably those two cases (already discussed in somewhat detail):
x = foo (x)
(CALL) foo (bar ())
In the first case, we need to evaluate the RHS, finalize x afterwards,
and execute the assignment last. For this we probably need to generate
temp = foo (x)
x = temp
In the second case, if the result of bar is of a finalizable
derived-type, we need to finalize it after the value has been used. That
temp = bar ()
(CALL) foo (temp)
In any case, a reliable method of generating and using "temporaries" is
needed in the front-end where finalization is handled; I already tried
it by simply generating variables and this works except for some special
cases where we need to have temporaries for arrays whose shape/size
might not even be known at compile time and such.
The trans-code however already deals with such issues as it uses
temporaries itself; I'd like to make the logic there accessible to the
front-end to be used to resolve the two finalization cases and maybe
also for further needs. I was thinking about how to do this best, and
here's what I'm thinking of at the moment; I tried to make this as
"clean" and generally usable as possible, but of course my focus was on
getting it capable for the two finalization points:
1.) We need a capability to tell the trans code a given expression
should be converted using a temporary; I think this is currently done
for parentheses like "(expr)", but maybe we could add a flag or
something like that to make it even clearer and easier to use. I
believe adding parentheses is somewhat a "hack"...
2.) Add something equivalent to "post" and "pre" to gfc_expr's; maybe
only for expressions marked as needing a temporary as in 1); that should
suffice if it is easier to do. These sections would consist of
gfc_code's and could be translated into the pre and post blocks during
trans (is this possible easily?).
The post-section could be used for finalizing the function result after
it has been used while the pre-section (executed after the temporary is
initialized and before it is actually used for x = temp) could be used
to finalize the old value of x in the assignment.
3.) In order to reference the temporary variable itself in the
finalizers, we could for instance introduce a new expression type
EXPR_TEMPORARY that would point to the gfc_expr it is a temporary for
and that would in the translation phase simply be converted using the
correct temporary variable. We could impose a restriction that such
expressions might only be used within the mirrored expression's pre and
post blocks to guard against abuses making things complicated.
What do you think about this ideas? I admit that I don't have much
knowledge about certain areas of gfortran and can't fully tell if
something like that can be implemented and would be worth the effort.
And of course, this is only a very rough draft at the moment, outlining
the points I believe are necessary.
Done: Arc-Bar-Sam-Val-Wiz, Dwa-Elf-Gno-Hum-Orc, Law-Neu-Cha, Fem-Mal
To go: Cav-Hea-Kni-Mon-Pri-Ran-Rog-Tou