Version 2, June 1991
Copyright © 1989, 1991 Free Software Foundation, Inc. 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.
The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Library General Public License instead.) You can apply it to your programs, too.
When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it.
For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights.
We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software.
Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations.
Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all.
The precise terms and conditions for copying, distribution and modification follow.
NO WARRANTY
If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found.
one line to give the program's name and a brief idea of what it does. Copyright (C) 19yy name of author This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
Also add information on how to contact you by electronic and paper mail.
If the program is interactive, make it output a short notice like this when it starts in an interactive mode:
Gnomovision version 69, Copyright (C) 19yy name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program.
You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. signature of Ty Coon, 1 April 1989 Ty Coon, President of Vice
This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Library General Public License instead of this License.
GNU Pascal is the work of Jukka Virtanen. Several people have contributed to GNU Pascal.
GNU Pascal is based on GNU CC by Richard Stallman. Several people have contributed to GNU CC.
protoize and unprotoize
tools, the support for Dwarf symbolic debugging information, and much of
the support for System V Release 4. He has also worked heavily on the
Intel 386 and 860 support.
If you want to have more free software a few years from now, it makes sense for you to help encourage people to contribute funds for its development. The most effective approach known is to encourage commercial redistributors to donate.
Users of free software systems can boost the pace of development by encouraging for-a-fee distributors to donate part of their selling price to free software developers--the Free Software Foundation, and others.
The way to convince distributors to do this is to demand it and expect it from them. So when you compare distributors, judge them partly by how much they give to free software development. Show distributors they must compete to be the one who gives the most.
To make this approach work, you must insist on numbers that you can compare, such as, "We will donate ten dollars to the Frobnitz project for each disk sold." Don't be satisfied with a vague promise, such as "A portion of the profits are donated," since it doesn't give a basis for comparison.
Even a precise fraction "of the profits from this disk" is not very meaningful, since creative accounting and unrelated business decisions can greatly alter what fraction of the sales price counts as profit. If the price you pay is $50, ten percent of the profit is probably less than a dollar; it might be a few cents, or nothing at all.
Some redistributors do development work themselves. This is useful too; but to keep everyone honest, you need to inquire how much they do, and what kind. Some kinds of development make much more long-term difference than others. For example, maintaining a separate version of a program contributes very little; maintaining the standard version of a program for the whole community contributes much. Easy new ports contribute little, since someone else would surely do them; difficult ports such as adding a new CPU to the GNU C compiler contribute more; major new features or packages contribute the most.
By establishing the idea that supporting further development is "the proper thing to do" when distributing free software for a fee, we can assure a steady flow of resources into making more free software.
Copyright (C) 1994 Free Software Foundation, Inc. Verbatim copying and redistribution of this section is permitted without royalty; alteration is not permitted.
This section is a political message from the League for Programming Freedom to the users of GNU CC. We have included it here because the issue of interface copyright is important to the GNU project.
Apple, Lotus, and now CDC have tried to create a new form of legal monopoly: a copyright on a user interface.
An interface is a kind of language--a set of conventions for communication between two entities, human or machine. Until a few years ago, the law seemed clear: interfaces were outside the domain of copyright, so programmers could program freely and implement whatever interface the users demanded. Imitating de-facto standard interfaces, sometimes with improvements, was standard practice in the computer field. These improvements, if accepted by the users, caught on and became the norm; in this way, much progress took place.
Computer users, and most software developers, were happy with this state of affairs. However, large companies such as Apple and Lotus would prefer a different system--one in which they can own interfaces and thereby rid themselves of all serious competitors. They hope that interface copyright will give them, in effect, monopolies on major classes of software.
Other large companies such as IBM and Digital also favor interface monopolies, for the same reason: if languages become property, they expect to own many de-facto standard languages. But Apple and Lotus are the ones who have actually sued. Apple's lawsuit was defeated, for reasons only partly related to the general issue of interface copyright.
Lotus won lawsuits against two small companies, which were thus put out of business. Then they sued Borland; they won in the trial court (no surprise, since it was the same court that had ruled for Lotus twice before), but the decision was reversed by the court of appeals, with help from the League for Programming Freedom in the form of a friend-of-the-court brief. We are now waiting to see if the Supreme Court will hear the case. If it does, the League for Programming Freedom will again submit a brief.
The battle is not over. Just this summer a company that produced a simulator for a CDC computer was shut down by a copyright lawsuit by CDC, which charged that the simulator infringed the copyright on the manuals for the computer.
If the monopolists get their way, they will hobble the software field:
If interface monopolies are accepted, other large companies are waiting to grab theirs:
Users invest a great deal of time and money in learning to use computer interfaces. Far more, in fact, than software developers invest in developing and even implementing the interfaces. Whoever can own an interface, has made its users into captives, and misappropriated their investment.
To protect our freedom from monopolies like these, a group of programmers and users have formed a grass-roots political organization, the League for Programming Freedom.
The purpose of the League is to oppose monopolistic practices such as interface copyright and software patents. The League calls for a return to the legal policies of the recent past, in which programmers could program freely. The League is not concerned with free software as an issue, and is not affiliated with the Free Software Foundation.
The League's activities include publicizing the issues, as is being done here, and filing friend-of-the-court briefs on behalf of defendants sued by monopolists.
The League's membership rolls include Donald Knuth, the foremost authority on algorithms, John McCarthy, inventor of Lisp, Marvin Minsky, founder of the MIT Artificial Intelligence lab, Guy L. Steele, Jr., author of well-known books on Lisp and C, as well as Richard Stallman, the developer of GNU CC. Please join and add your name to the list. Membership dues in the League are $42 per year for programmers, managers and professionals; $10.50 for students; $21 for others.
Activist members are especially important, but members who have no time to give are also important. Surveys at major ACM conferences have indicated a vast majority of attendees agree with the League on both issues (interface copyrights and software patents). If just ten percent of the programmers who agree with the League join the League, we will probably triumph.
To join, or for more information, phone (617) 243-4091 or write to:
League for Programming Freedom 1 Kendall Square #143 P.O. Box 9171 Cambridge, MA 02139
You can also send electronic mail to lpf@uunet.uu.net.
In addition to joining the League, here are some suggestions from the League for other things you can do to protect your freedom to write programs:
House Subcommittee on Intellectual Property 2137 Rayburn Bldg Washington, DC 20515 Senate Subcommittee on Patents, Trademarks and Copyrights United States Senate Washington, DC 20510(These committees have received lots of mail already; let's give them even more.)
Democracy means nothing if you don't use it. Stand up and be counted!
The GNU Manifesto which appears below was written by Richard Stallman at the beginning of the GNU project, to ask for participation and support. For the first few years, it was updated in minor ways to account for developments, but now it seems best to leave it unchanged as most people have seen it.
Since that time, we have learned about certain common misunderstandings that different wording could help avoid. Footnotes added in 1993 help clarify these points.
For up-to-date information about the available GNU software, please see the latest issue of the GNU's Bulletin. The list is much too long to include here.
GNU, which stands for Gnu's Not Unix, is the name for the complete Unix-compatible software system which I am writing so that I can give it away free to everyone who can use it.(1) Several other volunteers are helping me. Contributions of time, money, programs and equipment are greatly needed.
So far we have an Emacs text editor with Lisp for writing editor commands, a source level debugger, a yacc-compatible parser generator, a linker, and around 35 utilities. A shell (command interpreter) is nearly completed. A new portable optimizing C compiler has compiled itself and may be released this year. An initial kernel exists but many more features are needed to emulate Unix. When the kernel and compiler are finished, it will be possible to distribute a GNU system suitable for program development. We will use TeX as our text formatter, but an nroff is being worked on. We will use the free, portable X window system as well. After this we will add a portable Common Lisp, an Empire game, a spreadsheet, and hundreds of other things, plus on-line documentation. We hope to supply, eventually, everything useful that normally comes with a Unix system, and more.
GNU will be able to run Unix programs, but will not be identical to Unix. We will make all improvements that are convenient, based on our experience with other operating systems. In particular, we plan to have longer file names, file version numbers, a crashproof file system, file name completion perhaps, terminal-independent display support, and perhaps eventually a Lisp-based window system through which several Lisp programs and ordinary Unix programs can share a screen. Both C and Lisp will be available as system programming languages. We will try to support UUCP, MIT Chaosnet, and Internet protocols for communication.
GNU is aimed initially at machines in the 68000/16000 class with virtual memory, because they are the easiest machines to make it run on. The extra effort to make it run on smaller machines will be left to someone who wants to use it on them.
To avoid horrible confusion, please pronounce the `G' in the word `GNU' when it is the name of this project.
I consider that the golden rule requires that if I like a program I must share it with other people who like it. Software sellers want to divide the users and conquer them, making each user agree not to share with others. I refuse to break solidarity with other users in this way. I cannot in good conscience sign a nondisclosure agreement or a software license agreement. For years I worked within the Artificial Intelligence Lab to resist such tendencies and other inhospitalities, but eventually they had gone too far: I could not remain in an institution where such things are done for me against my will.
So that I can continue to use computers without dishonor, I have decided to put together a sufficient body of free software so that I will be able to get along without any software that is not free. I have resigned from the AI lab to deny MIT any legal excuse to prevent me from giving GNU away.
Unix is not my ideal system, but it is not too bad. The essential features of Unix seem to be good ones, and I think I can fill in what Unix lacks without spoiling them. And a system compatible with Unix would be convenient for many other people to adopt.
GNU is not in the public domain. Everyone will be permitted to modify and redistribute GNU, but no distributor will be allowed to restrict its further redistribution. That is to say, proprietary modifications will not be allowed. I want to make sure that all versions of GNU remain free.
I have found many other programmers who are excited about GNU and want to help.
Many programmers are unhappy about the commercialization of system software. It may enable them to make more money, but it requires them to feel in conflict with other programmers in general rather than feel as comrades. The fundamental act of friendship among programmers is the sharing of programs; marketing arrangements now typically used essentially forbid programmers to treat others as friends. The purchaser of software must choose between friendship and obeying the law. Naturally, many decide that friendship is more important. But those who believe in law often do not feel at ease with either choice. They become cynical and think that programming is just a way of making money.
By working on and using GNU rather than proprietary programs, we can be hospitable to everyone and obey the law. In addition, GNU serves as an example to inspire and a banner to rally others to join us in sharing. This can give us a feeling of harmony which is impossible if we use software that is not free. For about half the programmers I talk to, this is an important happiness that money cannot replace.
I am asking computer manufacturers for donations of machines and money. I'm asking individuals for donations of programs and work.
One consequence you can expect if you donate machines is that GNU will run on them at an early date. The machines should be complete, ready to use systems, approved for use in a residential area, and not in need of sophisticated cooling or power.
I have found very many programmers eager to contribute part-time work for GNU. For most projects, such part-time distributed work would be very hard to coordinate; the independently-written parts would not work together. But for the particular task of replacing Unix, this problem is absent. A complete Unix system contains hundreds of utility programs, each of which is documented separately. Most interface specifications are fixed by Unix compatibility. If each contributor can write a compatible replacement for a single Unix utility, and make it work properly in place of the original on a Unix system, then these utilities will work right when put together. Even allowing for Murphy to create a few unexpected problems, assembling these components will be a feasible task. (The kernel will require closer communication and will be worked on by a small, tight group.)
If I get donations of money, I may be able to hire a few people full or part time. The salary won't be high by programmers' standards, but I'm looking for people for whom building community spirit is as important as making money. I view this as a way of enabling dedicated people to devote their full energies to working on GNU by sparing them the need to make a living in another way.
Once GNU is written, everyone will be able to obtain good system software free, just like air.(2)
This means much more than just saving everyone the price of a Unix license. It means that much wasteful duplication of system programming effort will be avoided. This effort can go instead into advancing the state of the art.
Complete system sources will be available to everyone. As a result, a user who needs changes in the system will always be free to make them himself, or hire any available programmer or company to make them for him. Users will no longer be at the mercy of one programmer or company which owns the sources and is in sole position to make changes.
Schools will be able to provide a much more educational environment by encouraging all students to study and improve the system code. Harvard's computer lab used to have the policy that no program could be installed on the system if its sources were not on public display, and upheld it by actually refusing to install certain programs. I was very much inspired by this.
Finally, the overhead of considering who owns the system software and what one is or is not entitled to do with it will be lifted.
Arrangements to make people pay for using a program, including licensing of copies, always incur a tremendous cost to society through the cumbersome mechanisms necessary to figure out how much (that is, which programs) a person must pay for. And only a police state can force everyone to obey them. Consider a space station where air must be manufactured at great cost: charging each breather per liter of air may be fair, but wearing the metered gas mask all day and all night is intolerable even if everyone can afford to pay the air bill. And the TV cameras everywhere to see if you ever take the mask off are outrageous. It's better to support the air plant with a head tax and chuck the masks.
Copying all or parts of a program is as natural to a programmer as breathing, and as productive. It ought to be as free.
"Nobody will use it if it is free, because that means they can't rely on any support."
"You have to charge for the program to pay for providing the support."
If people would rather pay for GNU plus service than get GNU free without service, a company to provide just service to people who have obtained GNU free ought to be profitable.(3)
We must distinguish between support in the form of real programming work and mere handholding. The former is something one cannot rely on from a software vendor. If your problem is not shared by enough people, the vendor will tell you to get lost.
If your business needs to be able to rely on support, the only way is to have all the necessary sources and tools. Then you can hire any available person to fix your problem; you are not at the mercy of any individual. With Unix, the price of sources puts this out of consideration for most businesses. With GNU this will be easy. It is still possible for there to be no available competent person, but this problem cannot be blamed on distribution arrangements. GNU does not eliminate all the world's problems, only some of them.
Meanwhile, the users who know nothing about computers need handholding: doing things for them which they could easily do themselves but don't know how.
Such services could be provided by companies that sell just hand-holding and repair service. If it is true that users would rather spend money and get a product with service, they will also be willing to buy the service having got the product free. The service companies will compete in quality and price; users will not be tied to any particular one. Meanwhile, those of us who don't need the service should be able to use the program without paying for the service.
"You cannot reach many people without advertising, and you must charge for the program to support that."
"It's no use advertising a program people can get free."
There are various forms of free or very cheap publicity that can be used to inform numbers of computer users about something like GNU. But it may be true that one can reach more microcomputer users with advertising. If this is really so, a business which advertises the service of copying and mailing GNU for a fee ought to be successful enough to pay for its advertising and more. This way, only the users who benefit from the advertising pay for it.
On the other hand, if many people get GNU from their friends, and such companies don't succeed, this will show that advertising was not really necessary to spread GNU. Why is it that free market advocates don't want to let the free market decide this?(4)
"My company needs a proprietary operating system to get a competitive edge."
GNU will remove operating system software from the realm of competition. You will not be able to get an edge in this area, but neither will your competitors be able to get an edge over you. You and they will compete in other areas, while benefiting mutually in this one. If your business is selling an operating system, you will not like GNU, but that's tough on you. If your business is something else, GNU can save you from being pushed into the expensive business of selling operating systems.
I would like to see GNU development supported by gifts from many manufacturers and users, reducing the cost to each.(5)
"Don't programmers deserve a reward for their creativity?"
If anything deserves a reward, it is social contribution. Creativity can be a social contribution, but only in so far as society is free to use the results. If programmers deserve to be rewarded for creating innovative programs, by the same token they deserve to be punished if they restrict the use of these programs.
"Shouldn't a programmer be able to ask for a reward for his creativity?"
There is nothing wrong with wanting pay for work, or seeking to maximize one's income, as long as one does not use means that are destructive. But the means customary in the field of software today are based on destruction.
Extracting money from users of a program by restricting their use of it is destructive because the restrictions reduce the amount and the ways that the program can be used. This reduces the amount of wealth that humanity derives from the program. When there is a deliberate choice to restrict, the harmful consequences are deliberate destruction.
The reason a good citizen does not use such destructive means to become wealthier is that, if everyone did so, we would all become poorer from the mutual destructiveness. This is Kantian ethics; or, the Golden Rule. Since I do not like the consequences that result if everyone hoards information, I am required to consider it wrong for one to do so. Specifically, the desire to be rewarded for one's creativity does not justify depriving the world in general of all or part of that creativity.
"Won't programmers starve?"
I could answer that nobody is forced to be a programmer. Most of us cannot manage to get any money for standing on the street and making faces. But we are not, as a result, condemned to spend our lives standing on the street making faces, and starving. We do something else.
But that is the wrong answer because it accepts the questioner's implicit assumption: that without ownership of software, programmers cannot possibly be paid a cent. Supposedly it is all or nothing.
The real reason programmers will not starve is that it will still be possible for them to get paid for programming; just not paid as much as now.
Restricting copying is not the only basis for business in software. It is the most common basis because it brings in the most money. If it were prohibited, or rejected by the customer, software business would move to other bases of organization which are now used less often. There are always numerous ways to organize any kind of business.
Probably programming will not be as lucrative on the new basis as it is now. But that is not an argument against the change. It is not considered an injustice that sales clerks make the salaries that they now do. If programmers made the same, that would not be an injustice either. (In practice they would still make considerably more than that.)
"Don't people have a right to control how their creativity is used?"
"Control over the use of one's ideas" really constitutes control over other people's lives; and it is usually used to make their lives more difficult.
People who have studied the issue of intellectual property rights carefully (such as lawyers) say that there is no intrinsic right to intellectual property. The kinds of supposed intellectual property rights that the government recognizes were created by specific acts of legislation for specific purposes.
For example, the patent system was established to encourage inventors to disclose the details of their inventions. Its purpose was to help society rather than to help inventors. At the time, the life span of 17 years for a patent was short compared with the rate of advance of the state of the art. Since patents are an issue only among manufacturers, for whom the cost and effort of a license agreement are small compared with setting up production, the patents often do not do much harm. They do not obstruct most individuals who use patented products.
The idea of copyright did not exist in ancient times, when authors frequently copied other authors at length in works of non-fiction. This practice was useful, and is the only way many authors' works have survived even in part. The copyright system was created expressly for the purpose of encouraging authorship. In the domain for which it was invented--books, which could be copied economically only on a printing press--it did little harm, and did not obstruct most of the individuals who read the books.
All intellectual property rights are just licenses granted by society because it was thought, rightly or wrongly, that society as a whole would benefit by granting them. But in any particular situation, we have to ask: are we really better off granting such license? What kind of act are we licensing a person to do?
The case of programs today is very different from that of books a hundred years ago. The fact that the easiest way to copy a program is from one neighbor to another, the fact that a program has both source code and object code which are distinct, and the fact that a program is used rather than read and enjoyed, combine to create a situation in which a person who enforces a copyright is harming society as a whole both materially and spiritually; in which a person should not do so regardless of whether the law enables him to.
"Competition makes things get done better."
The paradigm of competition is a race: by rewarding the winner, we encourage everyone to run faster. When capitalism really works this way, it does a good job; but its defenders are wrong in assuming it always works this way. If the runners forget why the reward is offered and become intent on winning, no matter how, they may find other strategies--such as, attacking other runners. If the runners get into a fist fight, they will all finish late.
Proprietary and secret software is the moral equivalent of runners in a fist fight. Sad to say, the only referee we've got does not seem to object to fights; he just regulates them ("For every ten yards you run, you can fire one shot"). He really ought to break them up, and penalize runners for even trying to fight.
"Won't everyone stop programming without a monetary incentive?"
Actually, many people will program with absolutely no monetary incentive. Programming has an irresistible fascination for some people, usually the people who are best at it. There is no shortage of professional musicians who keep at it even though they have no hope of making a living that way.
But really this question, though commonly asked, is not appropriate to the situation. Pay for programmers will not disappear, only become less. So the right question is, will anyone program with a reduced monetary incentive? My experience shows that they will.
For more than ten years, many of the world's best programmers worked at the Artificial Intelligence Lab for far less money than they could have had anywhere else. They got many kinds of non-monetary rewards: fame and appreciation, for example. And creativity is also fun, a reward in itself.
Then most of them left when offered a chance to do the same interesting work for a lot of money.
What the facts show is that people will program for reasons other than riches; but if given a chance to make a lot of money as well, they will come to expect and demand it. Low-paying organizations do poorly in competition with high-paying ones, but they do not have to do badly if the high-paying ones are banned.
"We need the programmers desperately. If they demand that we stop helping our neighbors, we have to obey."
You're never so desperate that you have to obey this sort of demand. Remember: millions for defense, but not a cent for tribute!
"Programmers need to make a living somehow."
In the short run, this is true. However, there are plenty of ways that programmers could make a living without selling the right to use a program. This way is customary now because it brings programmers and businessmen the most money, not because it is the only way to make a living. It is easy to find other ways if you want to find them. Here are a number of examples.
A manufacturer introducing a new computer will pay for the porting of operating systems onto the new hardware.
The sale of teaching, hand-holding and maintenance services could also employ programmers.
People with new ideas could distribute programs as freeware, asking for donations from satisfied users, or selling hand-holding services. I have met people who are already working this way successfully.
Users with related needs can form users' groups, and pay dues. A group would contract with programming companies to write programs that the group's members would like to use.
All sorts of development can be funded with a Software Tax:
Suppose everyone who buys a computer has to pay x percent of the price as a software tax. The government gives this to an agency like the NSF to spend on software development.
But if the computer buyer makes a donation to software development himself, he can take a credit against the tax. He can donate to the project of his own choosing--often, chosen because he hopes to use the results when it is done. He can take a credit for any amount of donation up to the total tax he had to pay.
The total tax rate could be decided by a vote of the payers of the tax, weighted according to the amount they will be taxed on.
The consequences:
- The computer-using community supports software development.
- This community decides what level of support is needed.
- Users who care which projects their share is spent on can choose this for themselves.
In the long run, making programs free is a step toward the post-scarcity world, where nobody will have to work very hard just to make a living. People will be free to devote themselves to activities that are fun, such as programming, after spending the necessary ten hours a week on required tasks such as legislation, family counseling, robot repair and asteroid prospecting. There will be no need to be able to make a living from programming.
We have already greatly reduced the amount of work that the whole society must do for its actual productivity, but only a little of this has translated itself into leisure for workers because much nonproductive activity is required to accompany productive activity. The main causes of this are bureaucracy and isometric struggles against competition. Free software will greatly reduce these drains in the area of software production. We must do this, in order for technical gains in productivity to translate into less work for us.
The purpose of the GNU Pascal project is to produce a Pascal compiler (called GNU Pascal or GPC) which
Pascal was originally designed for teaching. GNU Pascal provides a smooth way to proceed to challenging programming tasks without learning a completely different language.
GNU Pascal compiler is part of the GNU Compiler family combining a language independent part of the GNU Compiler with a Pascal specific front end.
Other compilers of the family currently include compilers for the C, C++ and Objective C languages.
This chapter covers:
The preferred way to distribute GNU software is distribution of the source code. However it is nontrivial to compile GNU Pascal on non-UNIX systems, so we also provide ready-to-run binaries for the following platforms:
To install a binary distribution, cd to the main directory and unpack the archive while preserving the stored directory structure. In concrete, to install a ZIP archive under DOS with PKunzip, type
C:\> pkunzip -d archive
where archive is the name of the distribution file. To install a TGZ archive under Linux, become root, then extract the archive from the root of the filesystem:
# tar xzf archive.tar.gz
Binary distributions include `libgcc.' and `specs', files that are normally part of gcc. If you have gcc installed, they will be replaced unless you manually install the archive.
Compilation instructions for the different platforms and more about the extenders mentioned above follow.
GPC is based on GNU CC; you will need the GCC sources to build it. It must be the same version as the one GPC is implemented with. Although you need GCC to build the GNU Pascal compiler, you don't need GCC to compile Pascal programs once GNU Pascal is installed.
Here is the generic procedure for installing GNU Pascal on a Unix system. See See section System V compatible unices (e.g. Linux) for System V compatible unices (e.g. Linux), See section Alpha OSF/1 for Alpha OSF/1 systems.
% ../gcc/configure --prefix=/usrwill do the job. This creates all the necessary config files, links and Makefile in the GCC object directory.
--local-prefix option below.
fixincludes script.
PATH environment variable such that the necessary GNU tools come
before the standard system tools.
% make LANGUAGES=c(Just `make' would also build the C++ and Objective C compilers). You do not need to install the compiler you just built, but leave the objects in place, since GPC will directly load most of the GCC object files.
Configuration summary: GCC version: 2.7.2 GCC sources in: ../gcc-2.7.2 GCC object code in: ../gcc-i486-linux GPC sources in: . Installation path: /usr/bin, /usr/lib/gcc-lib/i486-linux/2.7.2 Compiler: gcc Compiler flags: -g -O RTS compiler: gcc Now, type "make" to build the compiler and runtime system.
makeOptionally, you may supply CFLAGS, LDFLAGS or RTSFLAGS. CFLAGS is used for compiler and RTS, RTSFLAGS are for RTS only, i.e.: 'make CFLAGS="-m486 -O2" RTSFLAGS=-Wall'
make -n install
command does, and if you are satisfied run it without the -n option
to install the compiler (gpc1), front end (gpc), run time system (libgpc.a)
to the same place where gcc was installed.
It is sort of stupid to have a separate incarnation of `gcc.c'; the
difference now is that "gpc" also searches from library `libgpc.a'
and `-lm'. In addition `gcc.c' specifies the interface to the
Pascal compiler (gpc1). This command will vanish when "gcc" knows how to
compile Pascal programs.
Configuration dependent notes:
Compiling the Runtime System (RTS) on a System V compatible unix requires "-DSYSV" to be set in CFLAGS. `configure' recognizes a number of System V compatible unices, but not all.
If you see:
../srcdir/rts/rts-rt0.c: In function `_p_initialize': ../srcdir/rts/rts-rt0.c:286: `SIGEMT' undeclared (first use this function) ../srcdir/rts/rts-rt0.c:290: `SIGSYS' undeclared (first use this function)
while building `libgpc.a', you have to add "-DSYSV" to your MY_CFLAGS.
Example:
% make MY_CFLAGS=-DSYSV other-make-flags-you-want-to-use
Please send a report, with the canonical name of the system to `gpc@kampi.hut.fi'
For alpha OSF/1 v3.2 (GCC 2.6.3): If your linker starts to output error messages like:
Warning: Linking some objects which contain exception information sections
and some which do not. This may cause fatal runtime exception handling
problems (last obj encountered without exceptions was <OBJ/LIB>)
I do not know why these started to appear, but you can get rid of these if you do as follows in the GPC object directory.
You need to trigger the Makefile dependencies, e.g. by doing the touch
command below. What happens is that it re-generates the version.c and
rts/version.c files, which need to be recompiled with ALPHA_BUG
defined.
Example:
% touch Makefile % make MY_CFLAGS=-DALPHA_BUG other-make-flags-you-want-to-use
You cannot build GNU CC (or GNU Pascal) by itself on MS-DOS; it will not compile under any MS-DOS compiler except itself. The official MS-DOS port of GCC is called djgpp, and it is available from `simtel.coast.net' and it's mirrors all over the world. The `configure' script is replaced by an MS-DOS batch file called `configure.bat' wich does essentially the same. A pre-configured source distribution should be available from the same site where you got djgpp.
EMX is a FreeWare 32-bit DOS extender which adds some properties of UNIX to the DOS and OS/2 operating systems written by Eberhard Mattes. You can find it, for example, via anonymous `ftp' on the server `ftp.uni-stuttgart.de' in the directory `pub/systems/os2/emx*'.
The EMX extender for DOS and OS/2 makes it relatively easy to port GNU
tools--such as the GNU Pascal Compiler--to these platforms. However,
it is not straightforward to compile it. There is no bash. No symbolic
links. 8.3 file names. Etc. It took me about two complete days to find
out what to do--not much when facing the about 15 MegaBytes of sources,
but enough. The method I finally did it through might be not the best
one but it works, and I document it here. If somebody finds a cleaner
way how to compile GNU Pascal for EMX, please let me know!
<peter.gerwinski@uni-essen.de>.
nmake make utility.
If you are using a DOS system, you are in trouble now,
because the required utility nmake is an OS/2 program.
I was not able to replace it with, for example, Borland
make; if you are, please inform me.
pkunzip -d c:\gccsrc? \
cd \emx\gnu pkunzip -d c:\gpc-272
rendir gcc-2.7 gcc-272(with OS/2: `ren')
cd gpc-272\emx nmake FS=FATBe patient -- this will take a while to complete.
CygWin32 is a project to make it easy to port Unix applications to machines which run an OS which supports the Win32 API - ie Windows 95 and Windows NT. Windows NT runs on more than just the 386 too. Currently, cygwin32 is in beta stage; it is available from `ftp://ftp.cygnus.com/pub/gnu-win32/' This (beta) GCC is incompatible with GNU Pascal, but neither gcc-2.6.3 nor gcc-2.7.2 does support the cygwin32 platform. To patch cygwin32 support into a regular GNU CC distribution, you need a special patch, available from the site where you got the GNU Pascal sources. Because of the unix-ish environment provided by cygwin32, configuring and building GNU Pascal is essentially the same as a unix configuration.
Currently, GNU Pascal does not support the stack calling convention of the Win32 API, thus making it impossible to access system DLL's.
GNU Pascal can function as a cross-compiler for many machines, but not all. Also, only a few combinations have been tested. If you need information about GNU tools in a cross-configuration, `ftp://ftp.cygnus.com/pub/embedded/crossgcc/' is the place to be.
Since GNU Pascal generates assembler code, you probably need a cross-assembler that GNU Pascal can run, in order to produce object files. If you want to link on other than the target machine, you need a cross-linker as well. You also need header files and libraries suitable for the target machine that you can install on the host machine.
To compile and run a program using a cross-compiler involves several steps:
It is most convenient to do all of these steps on the same host machine, since then you can do it all with a single invocation of GNU Pascal. This requires a suitable cross-assembler and cross-linker. For some targets, the GNU assembler and linker are available.
No special actions have to be taken to configure GNU Pascal as a crosscompiler. Cross-compiler specific configuration is done only for GCC. Section 4.2 of "Using and Porting GNU CC" deals with cross-configurations in great detail. Once cross-binutils and a C library for the target machine are in place, GCC can be configured (from the GCC object directory). Suppose we are on a Linux system and want a cross-compiler that produces code that runs on MS-DOS:
% ../gcc/configure --prefix=/usr --target=i386-go32
This creates all the necessary config files, links and Makefile in the GCC object directory. Now, proceed with the compilation and installation process like in the case of the native configuration described before. Do not remove files from the GCC object directory; the cross-compiler is used to compile the GNU Pascal runtime system (RTS) for the target system.
Once you have verified the C cross-compiler, the Pascal cross-compiler can be configured and built. Note that the `configure' script does not require any cross-compiler related switches because GPC inherits all of this from GNU CC. Assuming GCC object code is in `../gcc-i386-go32/',
% ../gpc/configure --srcdir=../gpc --gccdir=../gcc-i386-go32 --gccsrc=../gcc % make
Then, "make install" the cross-compiler.
When you invoke GPC, it normally does preprocessing, compilation, assembly and linking. The "overall options" allow you to stop this process at an intermediate stage. For example, the `-c' option says not to run the linker. Then the output consists of object files output by the assembler.
Other options are passed on to one stage of processing. Some options control the preprocessor and others the compiler itself. Yet other options control the assembler and linker; most of these are not documented here, since you rarely need to use any of them.
The gpc program accepts options and file names as operands. Many
options have multiletter names; therefore multiple single-letter options
may not be grouped: `-dr' is very different from `-d
-r'.
You can mix options and other arguments. For the most part, the order you use doesn't matter. Order does matter when you use several options of the same kind; for example, if you specify `-L' more than once, the directories are searched in the order specified.
Many options have long names starting with `-f' or with `-W'---for example, `-fforce-mem', `-fstrength-reduce', `-Wformat' and so on. Most of these have both positive and negative forms; the negative form of `-ffoo' would be `-fno-foo'. This manual documents only one of these two forms, whichever one is not the default.
Here is a summary of all the options, grouped by type. Explanations are in the following sections.
-c --automake -S -E -o file -pipe -v -x language
--nested-comments --char-escapes --c-numbers --standard-pascal --extended-pascal --object-pascal --borland-pascal --pascal-sc --extended-syntax
--short-circuit --lazy-io --setlimit --call-saved-reg --call-used-reg --fixed-reg --inhibit-size-directive --no-common --no-ident --no-gnu-linker --pcc-struct-return --pic --PIC --reg-struct-return --shared-data --short-enums --short-double --volatile --volatile-global --verbose-asm --pack-struct
--syntax-only --pedantic --pedantic-errors -w -W -Wall -Waggregate-return -Wbad-function-cast -Wcast-align -Wcast-qual -Wchar-subscript -Wcomment -Wconversion -Wenum-clash -Werror -Wformat -Wid-clash-len -Wimplicit -Wimport -Winline -Wlarger-than-len -Wmissing-declarations -Wmissing-prototypes -Wnested-externs -Wno-import -Woverloaded-virtual -Wparentheses -Wpointer-arith -Wredundant-decls -Wreorder -Wreturn-type -Wshadow -Wstrict-prototypes -Wswitch -Wsynth -Wtemplate-debugging -Wtraditional -Wtrigraphs -Wuninitialized -Wunused -Wwrite-strings
-a -dletters -fpretend-float -g -glevel -gcoff -gdwarf -gdwarf+ -ggdb -gstabs -gstabs+ -gxcoff -gxcoff+ -p -pg -print-file-name=library -print-libgcc-file-name -print-prog-name=program -print-search-dirs -save-temps --lines --debug-gpi
--caller-saves --cse-follow-jumps --cse-skip-blocks --delayed-branch --expensive-optimizations --fast-math --float-store --force-addr --force-mem --inline-functions --keep-inline-functions --no-default-inline --no-defer-pop --no-function-cse --no-inline --no-peephole --omit-frame-pointer --rerun-cse-after-loop --schedule-insns --schedule-insns2 --strength-reduce --thread-jumps --unroll-all-loops --unroll-loops -O -O0 -O1 -O2 -O3
-Aquestion(answer) -C -dD -dM -dN -Dmacro[=defn] -E -H -idirafter dir -include file -imacros file -iprefix file -iwithprefix dir -iwithprefixbefore dir -isystem dir -M -MD -MM -MMD -MG -nostdinc -P -trigraphs -undef -Umacro -Wp,option
-Wa,option
object-file-name -llibrary -nostartfiles -nodefaultlibs -nostdlib -s -static -shared -symbolic -Wl,option -Xlinker option -u symbol
-Bprefix -Idir -I- -Ldir
-b machine -V version
M680x0 Options -m68000 -m68020 -m68020-40 -m68030 -m68040 -m68881 -mbitfield -mc68000 -mc68020 -mfpa -mnobitfield -mrtd -mshort -msoft-float VAX Options -mg -mgnu -munix SPARC Options -mapp-regs -mcypress -mepilogue -mflat -mfpu -mhard-float -mhard-quad-float -mno-app-regs -mno-flat -mno-fpu -mno-epilogue -mno-unaligned-doubles -msoft-float -msoft-quad-float -msparclite -msupersparc -munaligned-doubles -mv8 SPARC V9 compilers support the following options in addition to the above: -mmedlow -mmedany -mint32 -mint64 -mlong32 -mlong64 -mno-stack-bias -mstack-bias Convex Options -mc1 -mc2 -mc32 -mc34 -mc38 -margcount -mnoargcount -mlong32 -mlong64 -mvolatile-cache -mvolatile-nocache AMD29K Options -m29000 -m29050 -mbw -mnbw -mdw -mndw -mlarge -mnormal -msmall -mkernel-registers -mno-reuse-arg-regs -mno-stack-check -mno-storem-bug -mreuse-arg-regs -msoft-float -mstack-check -mstorem-bug -muser-registers ARM Options -mapcs -m2 -m3 -m6 -mbsd -mxopen -mno-symrename M88K Options -m88000 -m88100 -m88110 -mbig-pic -mcheck-zero-division -mhandle-large-shift -midentify-revision -mno-check-zero-division -mno-ocs-debug-info -mno-ocs-frame-position -mno-optimize-arg-area -mno-serialize-volatile -mno-underscores -mocs-debug-info -mocs-frame-position -moptimize-arg-area -mserialize-volatile -mshort-data-num -msvr3 -msvr4 -mtrap-large-shift -muse-div-instruction -mversion-03.00 -mwarn-passed-structs RS/6000 and PowerPC Options -mcpu=cpu type -mpower -mno-power -mpower2 -mno-power2 -mpowerpc -mno-powerpc -mpowerpc-gpopt -mno-powerpc-gpopt -mpowerpc-gfxopt -mno-powerpc-gfxopt -mnew-mnemonics -mno-new-mnemonics -mfull-toc -mminimal-toc -mno-fop-in-toc -mno-sum-in-toc -msoft-float -mhard-float -mmultiple -mno-multiple -mstring -mno-string -mbit-align -mno-bit-align -mstrict-align -mno-strict-align -mrelocatable -mno-relocatable -mtoc -mno-toc -mtraceback -mno-traceback -mlittle -mlittle-endian -mbig -mbig-endian -mcall-aix -mcall-sysv -mprototype RT Options -mcall-lib-mul -mfp-arg-in-fpregs -mfp-arg-in-gregs -mfull-fp-blocks -mhc-struct-return -min-line-mul -mminimum-fp-blocks -mnohc-struct-return MIPS Options -mabicalls -mcpu=cpu type -membedded-data -membedded-pic -mfp32 -mfp64 -mgas -mgp32 -mgp64 -mgpopt -mhalf-pic -mhard-float -mint64 -mips1 -mips2 -mips3 -mlong64 -mlong-calls -mmemcpy -mmips-as -mmips-tfile -mno-abicalls -mno-embedded-data -mno-embedded-pic -mno-gpopt -mno-long-calls -mno-memcpy -mno-mips-tfile -mno-rnames -mno-stats -mrnames -msoft-float -m4650 -msingle-float -mmad -mstats -EL -EB -G num -nocpp i386 Options -m486 -m386 -mieee-fp -mno-fancy-math-387 -mno-fp-ret-in-387 -msoft-float -msvr3-shlib -mno-wide-multiply -mrtd -malign-double -mreg-alloc=list -mregparm=num -malign-jumps=num -malign-loops=num -malign-functions=num HPPA Options -mdisable-fpregs -mdisable-indexing -mfast-indirect-calls -mgas -mjump-in-delay -mlong-millicode-calls -mno-disable-fpregs -mno-disable-indexing -mno-fast-indirect-calls -mno-gas -mno-jump-in-delay -mno-millicode-long-calls -mno-portable-runtime -mno-soft-float -msoft-float -mpa-risc-1-0 -mpa-risc-1-1 -mportable-runtime -mschedule=list Intel 960 Options -mcpu type -masm-compat -mclean-linkage -mcode-align -mcomplex-addr -mleaf-procedures -mic-compat -mic2.0-compat -mic3.0-compat -mintel-asm -mno-clean-linkage -mno-code-align -mno-complex-addr -mno-leaf-procedures -mno-old-align -mno-strict-align -mno-tail-call -mnumerics -mold-align -msoft-float -mstrict-align -mtail-call DEC Alpha Options -mfp-regs -mno-fp-regs -mno-soft-float -msoft-float Clipper Options -mc300 -mc400 H8/300 Options -mrelax -mh System V Options -Qy -Qn -YP,paths -Ym,dir
Compilation can involve up to four stages: preprocessing, compilation proper, assembly and linking, always in that order. The first three stages apply to an individual source file, and end by producing an object file; linking combines all the object files (those newly compiled, and those specified as input) into an executable file.
For any given input file, the file name suffix determines what kind of compilation is done:
file.p
file.pas
file.i
file.h
file.s
file.S
other
You can specify the input language explicitly with the `-x' option:
-x language
pascal c objective-c c++ c-header cpp-output c++-cpp-output assembler assembler-with-cpp
-x none
If you only want some of the stages of compilation, you can use
`-x' (or filename suffixes) to tell gcc where to start, and
one of the options `-c', `-S', or `-E' to say where
gpc is to stop. Note that some combinations (for example,
`-x cpp-output -E' instruct gpc to do nothing at all.
-c
--automake
gpc --automake mainprog.pasOptions to be passed to "child" compilations must be given explicitely as a "String" argument to --automake, for example:
gpc -O --automake="-O" mainprog.pas(For an explanation of the -O option, see See section Options That Control Optimization.) WARNING: The AutoMake mechanism is a new feature in version 2.7.2 and may be unstable.
-S
-E
-o file
-v
-pipe
In cases where the different Pascal dialects contradict, GNU Pascal complies to the ISO standard by default. However you can change this behavior using command-line options or associated compiler switches.
--nested-comments (*$N+*)
$N is equivalent to --nested-comments
and allows local specifications.
A cross reference to compiler switches is in preparation.
--char-escapes (*$E+*)
--c-numbers (*$C+*)
--standard-pascal --extended-pascal --object-pascal --borland-pascal --pascal-sc
--borland-pascal implies --nested-comments
(see above), and --pascal-sc implies --extended-syntax
(see below).
--extended-syntax (*$X+*)
These machine-independent options control the interface conventions used in code generation.
Most of them have both positive and negative forms; the negative form of `-ffoo' would be `-fno-foo'. In the table below, only one of the forms is listed--the one which is not the default. You can figure out the other form by either removing `no-' or adding it.
--short-circuit (*$B-*)
--lazy-io (*$L+*)
put as soon as you can and
do get as late as you can.
--setlimit:number
--pcc-struct-return
Record values in memory like
longer ones, rather than in registers. This convention is less
efficient, but it has the advantage of allowing intercallability between
GNU Pascal-compiled files and files compiled with other compilers.
The precise convention for returning structures in memory depends
on the target configuration macros.
Short structures and unions are those whose size and alignment match
that of some integer type.
--reg-struct-return
Record values are
returned in registers when possible. This is more efficient for small
structures than `--pcc-struct-return'.
If you specify neither `--pcc-struct-return' nor its contrary
`--reg-struct-return', GNU Pascal defaults to whichever convention is
standard for the target. If there is no standard convention, GNU Pascal
defaults to `--pcc-struct-return', except on targets where GNU Pascal
is the principal compiler. In those cases, we can choose the standard,
and we chose the more efficient register return alternative.
--short-enums
--short-double
Real.
--shared-data
const variables of this
compilation be shared data rather than private data. The distinction
makes sense only on certain operating systems, where shared data is
shared between processes running the same program, while private data
exists in one copy per process.
--no-common
external) in
two different compilations, you will get an error when you link them.
The only reason this might be useful is if you wish to verify that the
program will work on other systems which always work this way.
--no-ident
--no-gnu-linker
collect2 program to make sure the system linker includes
constructors and destructors. (collect2 is included in the GNU Pascal
distribution.) For systems which must use collect2, the
compiler driver gpc is configured to do this automatically.
--inhibit-size-directive
.size assembler directive, or anything else that
would cause trouble if the function is split in the middle, and the
two halves are placed at locations far apart in memory. This option is
used when compiling `crtstuff.c'; you should not need to use it
for anything else.
--verbose-asm
--volatile
--volatile-global
--pic
--PIC
--fixed-reg
REGISTER_NAMES
macro in the machine description macro file.
This flag does not have a negative form, because it specifies a
three-way choice.
--call-used-reg
--call-saved-reg
--pack-struct
Warnings are diagnostic messages that report constructions which are not inherently erroneous but which are risky or suggest there may have been an error.
You can request many specific warnings with options beginning `-W', for example `-Wimplicit' to request warnings on implicit declarations. Each of these specific warning options also has a negative form beginning `-Wno-' to turn off warnings; for example, `-Wno-implicit'. This manual lists only one of the two forms, whichever is not the default.
These options control the amount and kinds of warnings produced by GNU Pascal:
GPC note: theses are all in toplev.c, but not all of them apply.
-fsyntax-only
-pedantic
__extension__. However, only system header files should use
these escape routes; application programs should avoid them.
This option is not intended to be useful; it exists only to satisfy
pedants who would otherwise claim that GNU CC fails to support the ANSI
standard.
Some users try to use `-pedantic' to check programs for strict ANSI
C conformance. They soon find that it does not do quite what they want:
it finds some non-ANSI practices, but not all--only those for which
ANSI C requires a diagnostic.
A feature to report any failure to conform to ANSI C might be useful in
some instances, but would require considerable additional work and would
be quite different from `-pedantic'. We recommend, rather, that
users take advantage of the extensions of GNU C and disregard the
limitations of other compilers. Aside from certain supercomputers and
obsolete small machines, there is less and less reason ever to use any
other C compiler other than for bootstrapping GNU CC.
-pedantic-errors
-w
-Wno-import
-Wchar-subscripts
char. This is a common cause
of error, as programmers often forget that this type is signed on some
machines.
-Wcomment
-Wformat
printf and scanf, etc., to make sure that
the arguments supplied have types appropriate to the format string
specified.
-Wimplicit
-Wparentheses
-Wreturn-type
int. Also warn about any return statement with no
return-value in a function whose return-type is not void.
-Wswitch
switch statement has an index of enumeral type
and lacks a case for one or more of the named codes of that
enumeration. (The presence of a default label prevents this
warning.) case labels outside the enumeration range also
provoke warnings when this option is used.
-Wtrigraphs
-Wunused
-Wuninitialized
volatile, or whose address is taken, or whose size
is other than 1, 2, 4 or 8 bytes. Also, they do not occur for
structures, unions or arrays, even when they are in registers.
Note that there may be no warning about a variable that is used only
to compute a value that itself is never used, because such
computations may be deleted by data flow analysis before the warnings
are printed.
These warnings are made optional because GNU CC is not smart
enough to see all the reasons why the code might be correct
despite appearing to have an error. Here is one example of how
this can happen:
{
int x;
switch (y)
{
case 1: x = 1;
break;
case 2: x = 4;
break;
case 3: x = 5;
}
foo (x);
}
If the value of y is always 1, 2 or 3, then x is
always initialized, but GNU CC doesn't know this. Here is
another common case:
{
int save_y;
if (change_y) save_y = y, y = new_y;
...
if (change_y) y = save_y;
}
This has no bug because save_y is used only if it is set.
Some spurious warnings can be avoided if you declare all the functions
you use that never return as noreturn.
-Wall
The remaining `-W...' options are not implied by `-Wall' because they warn about constructions that we consider reasonable to use, on occasion, in clean programs.
-W
longjmp. These warnings as well are possible only in
optimizing compilation.
The compiler sees only the calls to setjmp. It cannot know
where longjmp will be called; in fact, a signal handler could
call it at any point in the code. As a result, you may get a warning
even when there is in fact no problem because longjmp cannot
in fact be called at the place which would cause a problem.
foo (a)
{
if (a > 0)
return a;
}
static are not the first things in
a declaration. According to the C Standard, this usage is obsolescent.
x.h:
struct s { int f, g; };
struct t { struct s h; int i; };
struct t x = { 1, 2, 3 };
-Wtraditional
switch statement has an operand of type long.
-Wshadow
-Wid-clash-len
-Wlarger-than-len
-Wpointer-arith
void. GNU C assigns these types a size of 1, for
convenience in calculations with void * pointers and pointers
to functions.
-Wbad-function-cast
int malloc() is cast to anything *.
-Wcast-qual
const char * is cast
to an ordinary char *.
-Wcast-align
char * is cast to
an int * on machines where integers can only be accessed at
two- or four-byte boundaries.
-Wwrite-strings
const char[length] so that
copying the address of one into a non-const char *
pointer will get a warning. These warnings will help you find at
compile time code that can try to write into a string constant, but
only if you have been very careful about using const in
declarations and prototypes. Otherwise, it will just be a nuisance;
this is why we did not make `-Wall' request these warnings.
-Wconversion
x = -1 if x is unsigned. But do not warn about explicit
casts like (unsigned) -1.
-Waggregate-return
-Wstrict-prototypes
-Wmissing-prototypes
-Wmissing-declarations
-Wredundant-decls
-Wnested-externs
extern declaration is encountered within an function.
-Winline
-Woverloaded-virtual
-Wsynth (C++ only)
struct A {
operator int ();
A& operator = (int);
};
main ()
{
A a,b;
a = b;
}
In this example, g++ will synthesize a default `A& operator =
(const A&);', while cfront will use the user-defined `operator ='.
-Werror
GNU Pascal has various special options that are used for debugging either your program or GPC:
-g
-ggdb
-gstabs
-gstabs+
-gcoff
-gxcoff
-gxcoff+
-gdwarf
-gdwarf+
-glevel
-ggdblevel
-gstabslevel
-gcofflevel
-gxcofflevel
-gdwarflevel
-p
prof. You must use this option when compiling
the source files you want data about, and you must also use it when
linking.
-pg
gprof. You must use this option when compiling
the source files you want data about, and you must also use it when
linking.
-a
tcov. Note,
however, that the format of the data is not what tcov expects.
Eventually GNU gprof should be extended to process this data.
-dletters
-fpretend-float
-save-temps
-print-file-name=library
-print-prog-name=program
-print-libgcc-file-name
gcc -nostdlib files... `gcc -print-libgcc-file-name`
-print-search-dirs
GPC_EXEC_PREFIX to the directory where you installed them.
Don't forget the trailing '/'.
See section Environment Variables Affecting GNU Pascal.
These options control various sorts of optimizations:
-O
-O1
-O2
-O3
-O0
Options of the form `-fflag' specify machine-independent flags. Most flags have both positive and negative forms; the negative form of `-ffoo' would be `-fno-foo'. In the table below, only one of the forms is listed--the one which is not the default. You can figure out the other form by either removing `no-' or adding it.
-ffloat-store
double is supposed to have. For most programs,
the excess precision does only good, but a few programs rely on the
precise definition of IEEE floating point. Use `-ffloat-store' for
such programs.
-fno-default-inline
-fno-defer-pop
-fforce-mem
-fforce-addr
-fomit-frame-pointer
FRAME_POINTER_REQUIRED controls
whether a target machine supports this flag. See section Register Usage.
-fno-inline
inline keyword. Normally this option
is used to keep the compiler from expanding any functions inline.
Note that if you are not optimizing, no functions can be expanded inline.
-finline-functions
static, then the function is normally not output as
assembler code in its own right.
-fkeep-inline-functions
static, nevertheless output a separate run-time
callable version of the function.
-fno-function-cse
-ffast-math
sqrt
function are non-negative numbers and that no floating-point values
are NaNs.
This option should never be turned on by any `-O' option since
it can result in incorrect output for programs which depend on
an exact implementation of IEEE or ANSI rules/specifications for
math functions.
The following options control specific optimizations. The `-O2' option turns on all of these optimizations except `-funroll-loops' and `-funroll-all-loops'. On most machines, the `-O' option turns on the `-fthread-jumps' and `-fdelayed-branch' options, but specific machines may handle it differently.
You can use the following flags in the rare cases when "fine-tuning" of optimizations to be performed is desired.
-fstrength-reduce
-fthread-jumps
-fcse-follow-jumps
if statement with an
else clause, CSE will follow the jump when the condition
tested is false.
-fcse-skip-blocks
if statement with no else clause,
`-fcse-skip-blocks' causes CSE to follow the jump around the
body of the if.
-frerun-cse-after-loop
-fexpensive-optimizations
-fdelayed-branch
-fschedule-insns
-fschedule-insns2
-fcaller-saves
-funroll-loops
-funroll-all-loops
-fno-peephole
Does the Pascal Preprocessor bring new options?
These options control the Pascal preprocessor, which is run on each Pascal source file before actual compilation.
If you use the `-E' option, nothing is done except preprocessing. Some of these options make sense only together with `-E' because they cause the preprocessor output to be unsuitable for actual compilation.
-include file
-imacros file
-idirafter dir
-iprefix prefix
-iwithprefix dir
-iwithprefixbefore dir
-isystem dir
-nostdinc
-undef
-E
-C
-P
-M
make
describing the dependencies of each object file. For each source file,
the preprocessor outputs one make-rule whose target is the object
file name for that source file and whose dependencies are all the
$include header files it uses. This rule may be a single line or
may be continued with `\'-newline if it is long. The list of rules
is printed on standard output instead of the preprocessed Pascal program.
`-M' implies `-E'.
Another way to specify output of a make rule is by setting
the environment variable DEPENDENCIES_OUTPUT (see section Environment Variables Affecting GNU Pascal).
-MM
-MD
md to merge multiple dependency
files into a single dependency file suitable for using with the `make'
command.
-MMD
-MG
-H
-Aquestion(answer)
-Dmacro
-Dmacro=defn
-Umacro
-dM
-dD
-dN
-trigraphs
-Wp,option
You can pass options to the assembler.
-Wa,option
These options come into play when the compiler links object files into an executable output file. They are meaningless if the compiler is not doing a link step.
object-file-name
-c
-S
-E
-llibrary
-lobjc
-nostartfiles
-nostdlib
or -nodefaultlibs is used.
-nodefaultlibs
-nostartfiles
is used.
-nostdlib
-s
-static
-shared
-symbolic
-Xlinker option
-Wl,option
-u symbol
These options specify directories to search for header files, for libraries and for parts of the compiler:
-Idir
-I-
-Ldir
-Bprefix
GPC_EXEC_PREFIX. See section Environment Variables Affecting GNU Pascal.
By default, GNU Pascal compiles code for the same type of machine that you are using. However, it can also be installed as a cross-compiler, to compile for some other type of machine. In fact, several different configurations of GNU Pascal, for different target machines, can be installed side by side. Then you specify which one to use with the `-b' option.
In addition, older and newer versions of GNU Pascal can be installed side by side. One of them (probably the newest) will be the default, but you may sometimes wish to use another.
-b machine
-V version
The `-b' and `-V' options actually work by controlling part of the file name used for the executable files and libraries used for compilation. A given version of GNU Pascal, for a given target machine, is normally kept in the directory `/usr/local/lib/gcc-lib/machine/version'.
Thus, sites can customize the effect of `-b' or `-V' either by changing the names of these directories or adding alternate names (or symbolic links). If in directory `/usr/local/lib/gcc-lib/' the file `80386' is a link to the file `i386v', then `-b 80386' becomes an alias for `-b i386v'.
In one respect, the `-b' or `-V' do not completely change
to a different compiler: the top-level driver program gpc
that you originally invoked continues to run and invoke the other
executables (preprocessor, compiler per se, assembler and linker)
that do the real work. However, since no real work is done in the
driver program, it usually does not matter that the driver program
in use is not the one for the specified target and version.
The only way that the driver program depends on the target machine is in the parsing and handling of special machine-specific options. However, this is controlled by a file which is found, along with the other executables, in the directory for the specified version and target machine. As a result, a single installed driver program adapts to any specified target machine and compiler version.
The driver program executable does control one significant thing, however: the default version and target machine. Therefore, you can install different instances of the driver program, compiled for different targets or versions, under different names.
For example, if the driver for version 2.0 is installed as ogcc
and that for version 2.1 is installed as gpc, then the command
gpc will use version 2.1 by default, while ogcc will use
2.0 by default. However, you can choose either version with either
command with the `-V' option.
Earlier we discussed the standard option `-b' which chooses among different installed compilers for completely different target machines, such as Vax vs. 68000 vs. 80386.
In addition, each of these target machine types can have its own special options, starting with `-m', to choose among various hardware models or configurations--for example, 68010 vs 68020, floating coprocessor or none. A single installed version of the compiler can compile for any model or configuration, according to the options specified.
Some configurations of the compiler also support additional special options, usually for compatibility with other compilers on the same platform.
These options are defined by the macro TARGET_SWITCHES in the
machine description. The default for the options is also defined by
that macro, which enables you to change the defaults.
These are the `-m' options defined for the 68000 series. The default values for these options depends on which style of 68000 was selected when the compiler was configured; the defaults for the most common choices are given below.
-m68000
-mc68000
-m68020
-mc68020
-m68881
-m68030
-m68040
-m68020-40
-mfpa
-msoft-float
-mshort
int to be 16 bits wide, like short int.
-mnobitfield
-mbitfield
-mrtd
rtd
instruction, which pops their arguments while returning. This
saves one instruction in the caller since there is no need to pop
the arguments there.
This calling convention is incompatible with the one normally
used on Unix, so you cannot use it if you need to call libraries
compiled with the Unix compiler.
Also, you must provide function prototypes for all functions that
take variable numbers of arguments (including printf);
otherwise incorrect code will be generated for calls to those
functions.
In addition, seriously incorrect code will result if you call a
function with too many arguments. (Normally, extra arguments are
harmlessly ignored.)
The rtd instruction is supported by the 68010 and 68020
processors, but not by the 68000.
These `-m' options are defined for the Vax:
-munix
aobleq and so on)
that the Unix assembler for the Vax cannot handle across long
ranges.
-mgnu
-mg
These `-m' switches are supported on the SPARC:
-mno-app-regs
-mapp-regs
-mfpu
-mhard-float
-mno-fpu
-msoft-float
-mhard-quad-float
-msoft-quad-float
-mno-epilogue
-mepilogue
-mno-flat
-mflat
-mno-unaligned-doubles
-munaligned-doubles
-mv8
-msparclite
ffs) instructions which
exist in SPARClite but not in SPARC v7.
-mcypress
-msupersparc
In a future version of GPC, these options will very likely be renamed to `-mcpu=cypress' and `-mcpu=supersparc'.
These `-m' switches are supported in addition to the above on SPARC V9 processors:
-mmedlow
-mmedany
-mint64
-mlong32
-mlong64
-mint32
-mstack-bias
-mno-stack-bias
These `-m' options are defined for Convex:
-mc1
__convex__c1__ is defined.
-mc2
__convex_c2__ is defined.
-mc32
__convex_c32__ is defined.
-mc34
__convex_c34__ is defined.
-mc38
__convex_c38__ is defined.
-margcount
-mnoargcount
-mvolatile-cache
-mvolatile-nocache
-mlong32
-mlong64
These `-m' options are defined for the AMD Am29000:
-mdw
DW bit is set, i.e., that byte and
halfword operations are directly supported by the hardware. This is the
default.
-mndw
DW bit is not set.
-mbw
-mnbw
-msmall
call instruction to be used instead
of a const, consth, calli sequence.
-mnormal
call instructions only when
calling functions in the same file and calli instructions
otherwise. This works if each file occupies less than 256 KB but allows
the entire executable to be larger than 256 KB. This is the default.
-mlarge
calli instructions. Specify this option if you expect
a single file to compile into more than 256 KB of code.
-m29050
-m29000
-mkernel-registers
gr64-gr95 instead of to
registers gr96-gr127. This option can be used when compiling
kernel code that wants a set of global registers disjoint from that used
by user-mode code.
Note that when this option is used, register names in `-f' flags
must use the normal, user-mode, names.
-muser-registers
gr96-gr127. This is the
default.
-mstack-check
-mno-stack-check
__msp_check after each stack
adjustment. This is often used for kernel code.
-mstorem-bug
-mno-storem-bug
-mno-reuse-arg-regs
-mreuse-arg-regs
-msoft-float
These `-m' options are defined for Advanced RISC Machines (ARM) architectures:
-m2
-m3
-m6
-mapcs
-mbsd
-mxopen
-mno-symrename
These `-m' options are defined for Motorola 88k architectures:
-m88000
-m88100
-m88110
-mbig-pic
-midentify-revision
ident directive in the assembler output recording the
source file name, compiler name and version, timestamp, and compilation
flags used.
-mno-underscores
-mocs-debug-info
-mno-ocs-debug-info
-mocs-frame-position
-mno-ocs-frame-position
-moptimize-arg-area
-mno-optimize-arg-area
-mshort-data-num
r0,
which allows loading a value using a single instruction (rather than the
usual two). You control which data references are affected by
specifying num with this option. For example, if you specify
`-mshort-data-512', then the data references affected are those
involving displacements of less than 512 bytes.
`-mshort-data-num' is not effective for num greater
than 64k.
-mserialize-volatile
-mno-serialize-volatile
-msvr4
-msvr3
-mversion-03.00
-mno-check-zero-division
-mcheck-zero-division
-muse-div-instruction
-mtrap-large-shift
-mhandle-large-shift
-mwarn-passed-structs
These `-m' options are defined for the IBM RS/6000 and PowerPC:
-mpower
-mno-power
-mpower2
-mno-power2
-mpowerpc
-mno-powerpc
-mpowerpc-gpopt
-mno-powerpc-gpopt
-mpowerpc-gfxopt
-mno-powerpc-gfxopt
-mnew-mnemonics
-mold-mnemonics
-mcpu=cpu_type
-mfull-toc
-mno-fp-in-toc
-mno-sum-in-toc
-mminimal-toc
-msoft-float
-mhard-float
-mmultiple
-mno-multiple
-mstring
-mno-string
-mno-bit-align
-mbit-align
unsigned bitfields of length 1 would be aligned to a 4 byte
boundary and have a size of 4 bytes. By using `-mno-bit-align',
the structure would be aligned to a 1 byte boundary and be one byte in
size.
-mno-strict-align
-mstrict-align
-mrelocatable
-mno-relocatable
-mno-toc
-mtoc
-mno-traceback
-mtraceback
-mlittle
-mlittle-endian
-mbig
-mbig-endian
-mcall-sysv
-mcall-aix
-mprototype
-mno-prototype
These `-m' options are defined for the IBM RT PC:
-min-line-mul
-mcall-lib-mul
lmul$$ for integer multiples.
-mfull-fp-blocks
-mminimum-fp-blocks
-mfp-arg-in-fpregs
varargs.h and stdargs.h will not work with
floating point operands if this option is specified.
-mfp-arg-in-gregs
-mhc-struct-return
-mnohc-struct-return
These `-m' options are defined for the MIPS family of computers:
-mcpu=cpu type
-mips1
-mips2
-mips3
-mfp32
-mfp64
-mgp32
-mgp64
-mint64
-mlong64
-mmips-as
-mgas
-mrnames
-mno-rnames
-mgpopt
-mno-gpopt
-mstats
-mno-stats
-mmemcpy
-mno-memcpy
-mmips-tfile
-mno-mips-tfile
-msoft-float
-mhard-float
-mabicalls
-mno-abicalls
-mlong-calls
-mno-long-calls
-mhalf-pic
-mno-half-pic
-membedded-pic
-mno-embedded-pic
-membedded-data
-mno-embedded-data
-msingle-float
-mdouble-float
-mmad
-mno-mad
-m4650
-EL
-EB
-G num
-nocpp
These options are defined by the macro
TARGET_SWITCHES in the machine description. The default for the
options is also defined by that macro, which enables you to change the
defaults.
These `-m' options are defined for the i386 family of computers:
-m486
-m386
-mieee-fp
-mno-ieee-fp
-msoft-float
-mno-fp-ret-in-387
float and double in an FPU register, even if there
is no FPU. The idea is that the operating system should emulate
an FPU.
The option `-mno-fp-ret-in-387' causes such values to be returned
in ordinary CPU registers instead.
-mno-fancy-math-387
sin, cos and
sqrt instructions for the 387. Specify this option to avoid
generating those instructions. This option is the default on FreeBSD.
As of revision 2.6.1, these instructions are not generated unless you
also use the `-ffast-math' switch.
-malign-double
-mno-align-double
double, long double, and
long long variables on a two word boundary or a one word
boundary. Aligning double variables on a two word boundary will
produce code that runs somewhat faster on a `Pentium' at the
expense of more memory.
Warning: if you use the `-malign-double' switch,
structures containing the above types will be aligned differently than
the published application binary interface specifications for the 386.
-msvr3-shlib
-mno-svr3-shlib
bss or
data. `-msvr3-shlib' places these locals into bss.
These options are meaningful only on System V Release 3.
-mno-wide-multiply
-mwide-multiply
mul and imul that produce
64 bit results in eax:edx from 32 bit operands to do long
long multiplies and 32-bit division by constants.
-mrtd
ret num
instruction, which pops their arguments while returning. This saves one
instruction in the caller since there is no need to pop the arguments
there.
You can specify that an individual function is called with this calling
sequence with the function attribute `stdcall'. You can also
override the `-mrtd' option by using the function attribute
`cdecl'.
Warning: this calling convention is incompatible with the one
normally used on Unix, so you cannot use it if you need to call
libraries compiled with the Unix compiler.
Also, you must provide function prototypes for all functions that
take variable numbers of arguments (including printf);
otherwise incorrect code will be generated for calls to those
functions.
In addition, seriously incorrect code will result if you call a
function with too many arguments. (Normally, extra arguments are
harmlessly ignored.)
-mreg-alloc=regs
a allocate EAX; b allocate EBX;
c allocate ECX; d allocate EDX; S allocate ESI;
D allocate EDI; B allocate EBP.
-mregparm=num
-malign-loops=num
-malign-jumps=num
-malign-functions=num
These `-m' options are defined for the HPPA family of computers:
-mpa-risc-1-0
-mpa-risc-1-1
-mjump-in-delay
-mmillicode-long-calls
-mdisable-fpregs
-mdisable-indexing
-mfast-indirect-calls
-mportable-runtime
-mgas
-mschedule=cpu type
-msoft-float
These `-m' options are defined for the Intel 960 implementations:
-mcpu type
-mnumerics
-msoft-float
-mleaf-procedures
-mno-leaf-procedures
bal instruction as well as call. This will result in more
efficient code for explicit calls when the bal instruction can be
substituted by the assembler or linker, but less efficient code in other
cases, such as calls via function pointers, or using a linker that doesn't
support this optimization.
-mtail-call
-mno-tail-call
-mcomplex-addr
-mno-complex-addr
-mcode-align
-mno-code-align
-mic-compat
-mic2.0-compat
-mic3.0-compat
-masm-compat
-mintel-asm
-mstrict-align
-mno-strict-align
-mold-align
These `-m' options are defined for the DEC Alpha implementations:
-mno-soft-float
-msoft-float
-msoft-float is specified,
functions in `libgcc1.c' will be used to perform floating-point
operations. Unless they are replaced by routines that emulate the
floating-point operations, or compiled in such a way as to call such
emulations routines, these routines will issue floating-point
operations. If you are compiling for an Alpha without floating-point
operations, you must ensure that the library is built so as not to call
them.
Note that Alpha implementations without floating-point operations are
required to have floating-point registers.
-mfp-reg
-mno-fp-regs
-mno-fp-regs implies -msoft-float. If the floating-point
register set is not used, floating point operands are passed in integer
registers as if they were integers and floating-point results are passed
in $0 instead of $f0. This is a non-standard calling sequence, so any
function with a floating-point argument or return value called by code
compiled with -mno-fp-regs must also be compiled with that
option.
A typical use of this option is building a kernel that does not use,
and hence need not save and restore, any floating-point registers.
These `-m' options are defined for the Clipper implementations:
-mc300
-mc400
These `-m' options are defined for the H8/300 implementations:
-mrelax
ld and the H8/300' in Using ld, for a fuller description.
-mh
These additional options are available on System V Release 4 for compatibility with other compilers on those systems:
-Qy
.ident assembler directive in the output.
-Qn
.ident directives to the output file (this is
the default).
-YP,dirs
-Ym,dir
This section describes several environment variables that affect how GNU CC operates. They work by specifying directories or prefixes to use when searching for various kinds of files.
Note that you can also specify places to search using options such as `-B', `-I' and `-L' (see section Options for Directory Search). These take precedence over places specified using environment variables, which in turn take precedence over those specified by the configuration of GNU CC. See section Controlling the Compilation Driver, `gcc'.
TMPDIR
TMPDIR is set, it specifies the directory to use for temporary
files. GNU Pascal uses temporary files to hold the output of one stage of
compilation which is to be used as input to the next stage: for example,
the output of the preprocessor, which is the input to the compiler
proper.
GPC_EXEC_PREFIX
GPC_EXEC_PREFIX is set, it specifies a prefix to use in the
names of the subprograms executed by the compiler. No slash is added
when this prefix is combined with the name of a subprogram, but you can
specify a prefix that ends with a slash if you wish.
If GNU Pascal cannot find the subprogram using the specified prefix, it
tries looking in the usual places for the subprogram.
The default value of GPC_EXEC_PREFIX is
`prefix/lib/gcc-lib/' where prefix is the value
of prefix when you ran the `configure' script.
Other prefixes specified with `-B' take precedence over this prefix.
This prefix is also used for finding files such as `crt0.o' that are
used for linking.
In addition, the prefix is used in an unusual way in finding the
directories to search for header files. For each of the standard
directories whose name normally begins with `/usr/local/lib/gcc-lib'
(more precisely, with the value of GPC_INCLUDE_DIR), GNU Pascal tries
replacing that beginning with the specified prefix to produce an
alternate directory name. Thus, with `-Bfoo/', GNU Pascal will search
`foo/bar' where it would normally search `/usr/local/lib/bar'.
These alternate directories are searched first; the standard directories
come next.
COMPILER_PATH
COMPILER_PATH is a colon-separated list of
directories, much like PATH. GNU Pascal tries the directories thus
specified when searching for subprograms, if it can't find the
subprograms using GPC_EXEC_PREFIX.
LIBRARY_PATH
LIBRARY_PATH is a colon-separated list of
directories, much like PATH. When configured as a native compiler,
GNU Pascal tries the directories thus specified when searching for special
linker files, if it can't find them using GPC_EXEC_PREFIX. Linking
using GNU Pascal also uses these directories when searching for ordinary
libraries for the `-l' option (but directories specified with
`-L' come first).
C_INCLUDE_PATH
CPLUS_INCLUDE_PATH
OBJC_INCLUDE_PATH
PATH. When GNU Pascal searches for header files, it tries the
directories listed in the variable for the language you are using, after
the directories specified with `-I' but before the standard header
file directories.
DEPENDENCIES_OUTPUT
DEPENDENCIES_OUTPUT can be just a file name, in
which case the Make rules are written to that file, guessing the target
name from the source file name. Or the value can have the form
`file target', in which case the rules are written to
file file using target as the target name.
This chapter lists all keywords and operators understood by GNU Pascal.
By default, keywords can be redefined to make it possible
that every correct ISO 7185 program can be compiled.
However, you can use the compiler switches --pascal-standard,
--pascal-extended, --pascal-object, --pascal-borland,
and --pascal-sc to tell GPC that keywords of a given
standard must not to be redefined.
The keywords are taken from the following standards:
Keyword Pascal standard Remarks -------------------------------------------------------------------------- Absolute Borland overload variables Abstract Object not implemented All GNU EP "export foo = all" extension And ISO Standard And_then ISO Extended short-circuit Boolean AND operator Array ISO Standard Asm Borland, GNU GNU-style assembler Begin ISO Standard Bindable ISO Extended external binding of files, etc. Case ISO Standard Class Object not implemented Const ISO Standard Constructor Object, Borland only BP version implemented Destructor Object, Borland only BP version implemented Div ISO Standard Do ISO Standard Downto ISO Standard Else ISO Standard End ISO Standard Export ISO Extended Module Interface export File ISO Standard For ISO Standard Function ISO Standard Goto ISO Standard If ISO Standard Import ISO Extended Module Interface import Implementation ISO Extended, Borland Module (EP) or Unit (BP) Impl. part Inherited Object, Borland only BP version implemented In ISO Standard Inline Borland, GNU only GNU inline functions implem. Interface ISO Extended, Borland Module (EP) or Unit (BP) Int. part Is Object not implemented Label ISO Standard Mod ISO Standard Module ISO Extended, PXSC PXSC version only partially implem. Nil ISO Standard Not ISO Standard Object Borland BP 7.0 style class definition Of ISO Standard Only ISO Extended import specification Operator PXSC operator definition Or ISO Standard Or_else ISO Extended short-circuit Boolean OR operator Otherwise ISO Extended default case label Packed ISO Standard does not yet pack Pow ISO Extended exponentiation op. (integer expon.) Procedure ISO Standard Program ISO Standard Property Object not implemented Protected ISO Extended read-only formal parameters Qualified ISO Extended import specification Record ISO Standard Repeat ISO Standard Restricted ISO Extended type specification Set ISO Standard Shl Borland left bit-shift operator Shr Borland right bit-shift operator Then ISO Standard To ISO Standard Type ISO Standard Unit Borland Borland (or UCSD) style Modules Until ISO Standard Uses Borland Borland (or UCSD) style import Value ISO Extended variable initializer Var ISO Standard View Object not implemented Virtual Borland, Object only Borland version implemented While ISO Standard With ISO Standard Xor Borland Boolean/bitwise exclusive OR op.
GNU Pascal operators, ordered by precedence.
The PXSC operators `+<', `-<', etc. are not implemented into GNU Pascal but may be defined by the user. If you do so and meet the PXSC requirements, please let us know. The other real operators do not meet PXSC requirements.
The Object Pascal operator `IS' is not implemented.
:= < = > IN <> >= <= + - OR +< -< +> -> * / DIV MOD AND SHL SHR XOR *< /< *> /> POW ** IS NOT
The following identifiers are built in into GNU Pascal but may be redefined according to any supported Pascal standard.
Maxint False True Input Output Rewrite Reset Put Get Write Read Writeln Readln Page New Dispose Abs Sqr Sin Cos Exp Ln Sqrt Arctan Trunc Round Pack Unpack Ord Chr Succ Pred Odd Eof Eoln
Directives
Asmname Specify case-sensitive external name for Function C External name for Function shall be lowercase C_language same as C Forward External External Name of Function Has First Letter Uppercase Extern same as External
Extended Pascal required module interfaces
Standardoutput Standardinput
Object Pascal directive (not implemented)
Override
Extended Pascal required words
Maxchar Maxreal Minreal Epsreal
Extended Pascal required Procedures and Functions
Gettimestamp Date Time Halt Extend Seekwrite Seekread Seekupdate Empty Update Position Lastposition Re Im Cmplx Card Arg
Extended Pascal external binding
Bind Unbind Binding
Extended Pascal complex type functions
Polar
Extended Pascal String functions
Readstr Read from a string rather than a file Writestr Write to a string rather than a file Length Index Search in a string Substr also `MyStr [ 1..5 ]' Trim Eq lexical string comparision Lt Gt Ne Le Ge
Extended pascal required string schema type generator
String
Object pascal (not implemented)
Copy Null Root Textwritable Self
Borland Pascal
GetMem Allocate memory with given size in bytes FreeMem Free memory allocated with GetMem Inc Increment Dec Decrement
More exotic fruits and birds (GPC extensions)
Static C-sense storage class specifications __const__ __external__ __inline__ __static__ __volatile__ __byte__ C-style type size modifiers __short__ __long__ __longlong__ __unsigned__ Asm Inline assembly (GNU style) Alignof Break C-style Continue Return Sizeof Max for enumeral and real types Min Conjugate Mark Release Default like `otherwise' in a `case' statement Others Close Definesize
Standard Pascal data types
Integer Real Boolean Char Text
Extended Pascal complex type
Complex
GPC extensions: void type (two spellings)
__void__ Void
GPC extension: C compatibility string type
__cstring__
Extended Pascal: TimeStamp and BindingType
Timestamp Bindingtype
GPC contains a number of extensions to the ISO 7185 Pascal language.
Most of these extensions are written so that they should conform conform to the international standard ISO/IEC 10206 : 1991, Information technology - Programming Languages - Extended Pascal.
GPC is not yet fully compliant to the requirements of the Extended Pascal language.
The following Extended Pascal features are implemented:
extend(File)
+,-,/,* and monadic -,+
POW and **)
sqr,arctan,sqrt,exp,ln,sin,cos)
re, im and arg functions
cmplx or polar
POW and **)
Succ/Pred (val := succ (val, 5);)
gettimestamp, date, time
halt procedure
maxchar/minreal/maxreal/epsreal values.
base#number
StandardInput and StandardOutput
XOR) and CARD)
AND_THEN, OR_ELSE)
+"
trim,substr,index,length)
str[5..7] := 'foo';)
Gpc extensions not in Extended Pascal:
unbind(F) also closes a bound file F)
halt procedure may have a numeric exit status parameter
mark/release
reset/rewrite/extend as a string
return / break / continue statements
sizeof/alignof functions
string[ XX ] works like string(XX) as a string schema
type selector
otherwise: others and default
FOR ch IN [ 'a'..'z','0'..'9' ] DO...)
NEW work with them
GPC implements "lazy" text file I/O, i.e. do a PUT as soon
as you can and do GET as late as you can.
This should avoid most of the problems sometimes considered to be the most stupid feature of Pascal.
When passing a file buffer as parameter the buffer is validated when the parameter is passed. @@ Perhaps it would be nice to hack it to be validated when the VAR parameter is referenced...
When any lazy file is RESET, the file buffer state is set
to undefined. It is validated on the first reference to it.
Now this is also true for terminal devices.
Extended Pascal has a "type selector" feature called schema types.
GPC does not yet implement general schema types, but the
STRING SCHEMA is now implemented.
(An example of a (unimplemented) schemata would be, e.g:
Matrix (N,M: Positive_int) = array [ 1..N, 1..M ] of integer;
Here the M and N are discriminant identifiers.)
A STRING SCHEMA is the only predefined schema type in Extended
Pascal, with one required discriminant identifier "Capacity".
The string schema type, if explicitely defined, could look like:
TYPE string(capacity) = packed array [ 1..capacity ] of char;
Internally GPC implements STRING SCHEMA as follows:
The type representing the SCHEMA TYPE is a RECORD_TYPE node,
with the following fields:
STRING = RECORD
Capacity : integer;
length : integer;
string : packed array [ 1..Capacity ] of char;
END;
The "Capacity" field may be directly referenced by user,
"length" is referenced by a predefined string function
LENGTH(str) and contains the current string length.
"string" contains the chars in the string.
The "string" and "length" fields can not be directly referenced
by a user program.
References to the schema discriminants are allowed, and
the WITH statement is also allowed, so one can say:
var str : string (80);
begin
writeln (str.capacity), (* writes 80 *)
with str do
writeln (capacity); (* writes 80 *)
end;
When a new SCHEMA_TYPE is created, the discriminant identifier
fields need to be initialized. GPC initializes the new schema
type discriminant identifiers of every VAR_DECL node before it
executes any instructions of the procedure, function or
program where the string variable is declared.
If new internal schema types are created (for conversion
of fixed-string or char type parameters to a string schema
formal parameter), the discriminant identifiers are
initialized immediately. The discriminant identifiers
of PARM_DECL nodes are not initialized separately, they
get their values from the actual parameters.
If a parameter is a SCHEMA_NAME (a schema with no discriminant
identifiers), a proto string schema is used as the type
of the parameter.
STRING_SCHEMA type. The type of the actual parameter is used
instead of the proto schema for the formal parameter.
STRING_SCHEMA type, a fixed string type or a char type. If
the actual parameter is a string schema type, that is used
instead of the proto schema. If it is not a schema, a new
variable length string VAR_DECL is created, the actual
parameter is copied to the new variable and the "capacity"
field is set to the length of the actual variable.
Variable length string parameters look like:
PROGRAM Zap (output);
TYPE
stype = string (10);
sptr = ^string;
VAR
str : stype;
str2 : string(100000);
dstr : ^string;
zstr : sptr;
len : integer value 256;
(* "string" accepts any length of strings *)
PROCEDURE foo(z: string);
BEGIN
writeln ('Capacity : ',z.capacity);
writeln ('Length : ',length (z));
writeln ('Contents : ',z);
END;
(* Another way to use dynamic strings *)
PROCEDURE bar(slen : integer);
var
lstring : string (slen);
foostr : type of lstring;
BEGIN
lstring := 'Hello World!';
foo (lstring);
foostr := 'Ent{ miksi juuri t{m{?';
foo(foostr);
END;
BEGIN
str := 'KUKKUU';
str2 := 'A longer string variable';
new (dstr, 1000); { Select the string Capacity with NEW }
dstr^ := 'The max length of this is 1000 chars';
new (zstr, len);
zstr^ := 'This should fit here';
foo(str);
foo(str2);
foo('This is a constant string');
foo('R'); { A char parameter to string routine }
foo("); { An empty string }
foo (dstr^);
foo (zstr^);
bar (10000);
END. (* Zap *)
In the above example, the required procedure NEW was used
to select the capacity of the strings. Procedure "BAR" also has
a string whose size depends of the parameter passed to it
and another string whose type will be the same than the type of
the first string ("type of" construct).
All string and char types are compatible as long as the destination string is long enough to hold the source in assignments. If the source string is shorter than the destination, the destination is automatically blank padded if the destination string is not of string schema type.
S1 and S2 may be of string or char type.
S is of string type.
WRITESTR (s, write-parameter-list)
READSTR (s, read-parameter-list)
TEXT
files. The semantics is closely modeled after
file I/O.
INDEX(s1,s2)
S2 is empty, return 1 else if S1 is empty return 0
else returns the position of s2 in s1 (an integer).
LENGTH (s1)
S1 (an integer from 0..Capacity)
TRIM (s1)
S.
SUBSTR (s1, i)
SUBSTR (s1, i, j)
J is missing it is calculated as: J := LENGTH (S1) - I + 1;
Return a new substring of S1 that contains J characters
starting from I.
EQ (s1,s2)
NE (s1,s2)
LT (s1,s2)
LE (s1,s2)
GT (s1,s2)
GE (s1,s2)
S1 and S2. Returns boolean result.
Strings are not padded with spaces.
s1 = s2
s1 <> s2
s1 < s2
s1 <= s2
s1 > s2
s1 >= s2
S1 and S2. Returns boolean result.
Shorter string is blank padded to length of the longer one.
In GPC you are free to re-define everything that is not a reserved word in ISO 7185 Pascal in your program.
All Extended Pascal additional "reserved words" may be redefined,
so you do not have to modify your code for GPC if you have an
identifier like RESTRICTED or VALUE or some such.
@@ This violates Extended Pascal standard.
You may also redefine words like INTEGER and CHAR if you like.
@@ NOTE: The *only* exception to the redefinition rule currently
is the word INLINE (to make routines inline compiled), because I
added it in front of PROCEDURE or FUNCTION. But I think I will
change the syntax later and make INLINE a directive instead of a
reserved word.
to get info of possible clashes of keywords and other
info of your program constructs that gpc thinks are "non-standard"
use the switch "-pedantic" when compiling. See the GCC info files.
@@ I have not tested the switches like -Wall very much. If you do, @@ give me info of error messages that don't make sense in Pascal.
@@ As a rule, GPC implements most of the switches GCC implements, and a couple of more that can not currently be set.
FORWARD
EXTERNAL
foo()" will actually call "Foo()")
EXTERN
C
foo()" as "foo()"
(no capitalization of the first letter)
C_LANGUAGE
STATIC
PROGRAM foo; PROCEDURE gotoxy(x,y: Integer); C; BEGIN gotoxy(10,10); (* Call external routine "gotoxy" *) END.
GPC supports standard Pascal set operations. In addition it
supports the extended Pascal set operation symmetric
difference (set1 >< set2) operation (a XOR of the set
elements).
It also has a function that counts the elements in the set: `a := card (set1)'
NOTE: the set operations are still under construction, e.g. the set code does not fully work in the 64 bit Alpha machines.
A type (or variable) may be initialized to a value of expression when it is declared, as in:
program zap;
type
int10 = integer value 10;
footype = real;
mytype = char value pred('A');
etype = (a,b,c,d,e,f,g) value d;
var
ii : int10; (* Value of ii set to 10 *)
ch : mytype value pred('z');
aa : integer value ii+10;
foo : footype value sqrt(aa);
e1 : etype; (* value set to d *)
e2 : etype value g; (* value set to g *)
begin
end.
Extended pascal requires the type initializers to be constant expressions. GPC allows any valid expression.
Note, however, that the expressions that affect the size of storage allocated for objects (e.g. the length of arrays) may contain variables only inside functions or procedures.
GPC evaluates the initial values used for the type when an identifier is declared for that type. If a variable is declared with a type-denoter that uses a type-name which already has an initial value the latter initialization has precedence.
@@ GPC does not know how to calculate constant values for math functions in the runtime library at compile time, e.g. `exp(sin(2.4567))', so you should not use these kind of expressions in object size expressions. (Extended Pascal allows this).
Predefined date and time routines:
procedure gettimestamp(VAR t: Timestamp);
function date(t: Timestamp) : packed array [ 1..DATE_LENGTH ] of char;
function time(t: Timestamp) : packed array [ 1..TIME_LENGTH ] of char;
DATE_LENGTH and TIME_LENGTH are implementation dependent
constants. See E.20 and E.22 in chapter IMPLEMENTATION DEPENDENT FEATURES
to find out these values for GPC.
GetTimeStamp(t) fills the record T with values. If they are
valid, the boolean flags are set to TRUE.
TimeStamp is a required predefined type in extended pascal standard.
(It may be extended in an implementation.)
The required part of the type looks like:
TimeStamp = PACKED RECORD DateValid, TimeValid : Boolean; year : integer; month : 1 .. 12; day : 1 .. 31; hour : 0 .. 23; minute : 0 .. 59; second : 0 .. 59; END;
@@ NOTE:
TimeStamp may be later extended in GPC to contain the
following fields at the end of the TimeStamp record:
Dst_used : Boolean; (* If daylight savings are used *)
TimeZone : Integer; (* Positive if WEST, in minutes *)
Weekday : 0..6; (* 0 is Sunday *)
TimerValid : Boolean; (* Is the following timer valid *)
us_Timer : Integer; (* A microsecond timer that is a 32 bit
modulus of the timer returned by the
system. *)
Fields Dst_used, TimeZone and WeekDay will be valid when
DateValid is TRUE. Field us_Timer will be valid when
TimerValid is TRUE.
The following sample programs illustrates most of the
COMPLEX type operations. In addition monadic + and
- are supported and dyadic +,-,*,/ operations.
program complex_test(output);
var
z1,z2 : complex;
len, angle : real;
begin
z1 := cmplx (2,1);
writeln;
writeln ('Complex number Z1 is: (',re(z1):1,',',im(z1):1,')');
writeln;
z2 := conjugate(z1); { GPC extension }
writeln ('Conjugate of Z1 is: (',re(z2):1,',',im(z2):1,')');
writeln;
len := abs (z1);
angle := arg (z1);
writeln ('The polar representation of Z1 is LENGTH=',len:1,
' ANGLE=',angle:1);
writeln;
z2 := polar (len, angle);
writeln ('Converting (LENGTH,ANGLE) back to (X,Y) gives: (',
re(z2):1,',',im(z2):1,')');
writeln;
writeln ('The following operations operate on the complex number Z1');
writeln;
z2 := arctan (z1);
writeln ('arctan: R=',re(z2),', I=',im(z2));
z2 := z1 ** 3.141;
writeln ('**3.141: R=',re(z2),', I=',im(z2));
{ cos, ln, exp, sqrt and sqr exist also }
z2 := sin(z1);
writeln ('sin: R=',re(z2),', I=',im(z2));
z2 := z1 pow 8;
writeln ('POW 8: R=',re(z2),', I=',im(z2));
z2 := z1 pow (-8);
writeln ('POW (-8): R=',re(z2),', I=',im(z2));
end.
@@ Not tested. @@ Write a demo program.
type Dfile = file [ 1 .. 100 ] of integer; var F : Dfile; P, N : 1..100;
Declares a type for a file that contains 100 integers.
The following direct access routines may be applied to a direct access file:
SeekRead (F, N); { Open file in Inspection mode, seek to record N }
SeekWrite (F, N); { Open file in Generation mode, seek to record N }
SeekUpdate (F, N); { Open file in Update mode, seek to record N }
Update (F); { Writes F^, position not changed. F^ kept. }
p := Position (F); { Return current record number }
p := LastPosition (F); { Return the last record number in file }
If the file is open for Inspection or Update, GET may be applied.
If the file is open for Generation or Update, PUT may be applied.
@@ GPC acts like the file would always start at record number 0, and subtracts/adds the lower index from the record number. If you think this is incorrect, let me know.
Extended Pascal defines restricted types as:
restricted-type = 'restricted' type-name .
A value of a restricted type may be passed as a value parameter to a formal parameter possessing its underlying type, or returned as the result of a function. A variable of a restricted type may be passed as a variable parameter to a formal parameter possessing the same type or its underlying type. No other operations, such as accessing a component of a restricted type value or performing arithmetic, are possible.
program zap;
type
unres_rec = record
a : integer;
end;
res = restricted unres_rec;
var
r1 : unres_rec;
r2 : res;
i : restricted integer;
k : integer;
function zap(p : unres_rec) : res;
var
ures : unres_rec;
begin
{ The parameter is treated as unrestricted, even though the actual
parameter may be a restricted object }
ures.a := p.a;
{ Legal to assign a return value }
zap := ures;
end; { zap }
begin
r1.a := 354;
{ Assigning a restricted return value to a restricted object }
{ @@ Verify if this should really be allowed????? }
r2 := zap(r1);
{ Passing a restricted object to unrestericted formal parameter is ok }
r2 := zap(r2);
{ *** The following are illegal *** }
r2.a := 100; { field access }
r1 := r2; { := source is restricted type }
r2 := r1; { := target is restricted type }
r1 := zap(r2); { := a restricted return value to unrestricted object }
i := 16#ffff; { := target is restricted type }
k := i + 2; { Arithmetic with restricted type }
end.
@@ Gpc does not yet support:
=>'
QUALIFIED interfaces
PROTECTED export variables
ONLY
IMPORT does not work semantically correct.
EXPORT does not work semantically correct.
abort())
Gpc should be able to parse full Extended Pascal module syntax. But all the features are not implemented yet.
You may load one PROGRAM and several MODULEs to make up one pascal program. A single file may contain zero or more modules and/or zero or one programs.
Please NOTE: If you have many modules in the same file, the variable and function declarations are visible after the point they have been declared in the implementation even if the interface does not export them. But they do not become visible only by including the interface to another file and separate compiling that (so you do need to export them now). (@@ unfortunately, currently this applies only to variables and functions; all other things are visible after the interface has been compiled whether or not you exported them.)
The nicest way to handle the module interface in separate compilation environment is to use the non-standard
#include "module-interface.ph"
feature. You can collect your module interfaces to a single
directory and include them from there by using the
"-I DIR" switches to specify the include file search paths
to the compiler. (See the GNU CPP manual for more info).
There is currently no attempt to avoid name clashes of separate compiled modules when they are linked together. (The exported variables and functions having the same name in different modules will clash!!!)
Sample module code with separate INTERFACE and IMPLEMENTATION
parts follows:
MODULE foobar Interface; (* INTERFACE *)
EXPORT catch22 = (footype,setfoo,getfoo);
TYPE footype = integer;
PROCEDURE setfoo(f: footype);
FUNCTION getfoo: footype;
END. { module foobar interface }
MODULE foobar Implementation; (* IMPLEMENTATION *)
IMPORT StandardInput;
StandardOutput;
VAR foo : footype;
{ Note: the effect is the same as the Forward directive would have:
parameter lists and return types are not "allowed" in the declaration
of exported routines. }
PROCEDURE setfoo;
BEGIN
foo := f;
END;
FUNCTION getfoo;
BEGIN
getfoo := foo;
END;
TO BEGIN DO
BEGIN
foo := 59;
writeln ('Just an example of a module initializer. See comment below');
END;
TO END DO
BEGIN
foo := 0;
writeln ('Goodbye');
END;
END. { foobar implementation }
Alternatively the module interface and implementation may be combined as follows:
MODULE foobar; (* ALTERNATIVE METHOD *)
EXPORT catch22 = (footype,setfoo,getfoo);
TYPE footype = integer;
PROCEDURE setfoo(f: footype);
FUNCTION getfoo: footype;
END; { NOTE: this END is required here, even if the
module-block below would be empty. }
VAR foo : footype;
PROCEDURE setfoo;
BEGIN
foo := f;
END;
FUNCTION getfoo;
BEGIN
getfoo := foo;
END;
END. { module foobar }
Either one of the two methods may be used with:
PROGRAM what(output); import catch22; BEGIN setfoo (999); writeln (getfoo); END.
The INTERFACE has to be in the same file as the program/module that
uses it's exported names. Otherwise GPC does not know anything
about it and fails to compile the file.
Note: this is not supported in Extended Pascal standard.
This is a simpler module support that does not require exports, imports, module headers etc.
These non-standard simple Gpc modules look like (does not have an export part, does not have a separate module-block, does not use import/export features.)
MODULE foobar;
TYPE footype = integer;
VAR foo: footype;
PROCEDURE setfoo(f: footype);
BEGIN
foo := f;
END;
FUNCTION getfoo: footype;
BEGIN
getfoo := foo;
END;
END.
PROGRAM what(output);
(* In case the module foobar is loaded from another file *)
PROCEDURE setfoo(f: footype); External;
FUNCTION getfoo: footype; External;
BEGIN
setfoo (999);
writeln (getfoo);
END.
TO BEGIN DO module initialization and TO END DO module
finalization constructs are supported if the GNU compiler supports
constructors and destructors in your target machine. (It always does if you
use the GNU Linker).
If the initialization and finalizations do not work by default, but
you have the GNU Linker, use option -fgnu-linker when compiling the
program.
I re-implemeted the standard I/O handling and now the input and output can also be used from the initialization and finalization parts.
@@ Try these, send me bug reports. These are not tested.
GPC supports the extended pascal bind,unbind and binding
operations when applied to files.
The compiler will currently reject binding of other object types (@@ Perhaps the run time system should do the rejection?)
GPC implements extensions to the required predefined record type BindingType:
BindingType = PACKED_RECORD
Bound : Boolean;
Extensions_Valid : Boolean;
Writable : Boolean;
Readable : Boolean;
Existing : Boolean;
Error : Integer; { Unused currently }
Size : Integer; { # of elements or -1 }
Name : String (BINDING_NAME_LENGTH);
END;
The fields BOUND and NAME are required by the standard. All
other fields are extensions.
The meaning of the extensions to the BindingType record type,
and the value of BINDING_NAME_LENGTH is defined in this document,
section IMPLEMENTATION DEFINED FEATURES (E.14). It is a compiler
constant, the run time system accepts any length.
The Size field is a latest addition to BindingType; I added
that because the direct access files actually require that the file
is not bigger that the definition; and lastposition(file) does
not work before the file is opened. The "Size" field can then
be used to determine the size before open, and if the upper
bound of the direct access file is a variable one should be able
to open files of any size without violating the standard.
The following is an example of the binding:
program z(input,output,f);
var
f : text;
procedure bindfile (varf : text);
var
b : BindingType;
begin
unbind (f);
b := binding (f);
repeat
write ('Enter file name:');
readln (b.name);
bind (f, b);
b := binding (f);
if not b.bound then
writeln ('File not bound--try again');
until b.bound;
end;
begin
bindfile (f);
(* Now the file F is bound to an external file.
*
* You can use the implementation defined fields
* to check if the file is Readable, Writable and
* if it Exists. These are valid if the.Extensions_Valid
* field is TRUE.
*)
end.
GPC suports also function pointers and calls through them. This is a non-standard feature.
program zap(output);
type
proc_ptr = ^ procedure (integer);
var
pvar : proc_ptr;
procedure write_int(i: integer);
begin
writeln ('Integer: ',i:1);
end;
begin
(* PVAR points to function WRITE_IT *)
pvar := &write_int;
(* Dereferencing a function pointer calls the function *)
pvar^(12345);
end.
Gpc supports string catenation with the '+' operator.
All string-types are compatible, so you may catenate any chars,
fixed length strings and variable length strings with each other.
program scat (input, output);
var
ch : char;
str : string(100);
str2 : string(50);
fstr : packed array [ 1 .. 20 ] of char;
begin
ch := '$';
fstr := 'demo'; { padded with blanks }
write ('Give me some chars to play with: ');
readln (str);
str := '^' + 'prefix:' + str + ':suffix:' + fstr + ch;
writeln ('Len' + 'gth = ', length (str));
writeln (str);
end.
@ New feature. @ Currently gpc runtime does not know anything about these. @ These may change/or get removed...
As an extension, GPC allows you to use type qualifiers:
__byte__
__short__
__long__
__longlong__
__unsigned__
The __unsigned__ works for all integer types, also those
that have been previously declared with some other type
qualifier, like __short__. The other qualifiers do not accept
types that have already been modified with a type qualifier.
The syntax to use the qualifiers:
type-denoter > TYPE-QUALIFIER type-name
(The metasymbol `>' means type-denoter has also other meanings)
Most of these should be done with subranges anyway.
However, '__short__ real' can not be done like that, neither can
'__unsigned__ integer' or '__longlong__ integer'.
program zap(output); type byte = __byte__ integer; longint = __long__ integer; float = __short__ real; u_long = __unsigned__ longint; verylong = __longlong__ integer; var i8 : byte; i16 : __short__ integer; foo : u_long; pi : float; big : verylong; begin pi := 3.141592654; i16 := 1000; big := MaxInt * i16; i8 := 127; (* * Hmm, does not work because constant is treated as an integer, * and this is too large. Need a method to specify long constants. * * What is the syntax in other Pascal compilers? Suggestions, please! * foo := 16#deadbeef; *) end.
The following module accesses the command line with
ParamStr and ParamCount functions.
These follow the Un*x semantics, so that
arg[0] == program name,
arg[1] .. arg[ParamCount-1] are the arguments.
MODULE command_line interface;
EXPORT cmdline = (Max_length, Arg_type, ParamStr, ParamCount);
CONST
Max_length = 255; { Max length of each argument.
If some arg is longer, the run time system
traps it. }
TYPE
Arg_type = String(Max_length);
FUNCTION ParamCount: Integer;
FUNCTION ParamStr (arg_num: integer): Arg_type;
END. { command_line interface }
MODULE command_line implementation;
{ These are in the GPC runtime library }
FUNCTION _p_paramcount : Integer; C;
FUNCTION _p_paramstr (num: Integer; VAR str: String): Boolean; C;
FUNCTION ParamCount;
BEGIN
ParamCount := _p_paramcount;
END; { ParamCount }
FUNCTION ParamStr;
VAR
Str : Arg_type;
Success : Boolean;
BEGIN
Success := _p_paramstr (arg_num, Str);
(* Should perhaps do something else on failure.
*
* Now it returns the empty string, which is also a valid
* parameter.
*)
IF Success THEN
ParamStr := Str
else
ParamStr := ";
END; { ParamStr }
END. { command_line implementation }
{ The program below, when compiled with the interface module and
linked with the implementation module, accesses the command
line arguments. }
program zap (output);
import cmdline;
var
counter : integer;
begin
writeln ('Program fetches command line arguments and outputs one per line');
writeln ('Max length of each argument is ',Max_Length:1,' characters');
for counter := 0 to ParamCount-1 do
writeln ('Command line arg ',counter:1,' is "',paramstr(counter),'"');
end.
GNU Pascal implements these Borland extensions to the ISO Pascal language:
Program headline may be omitted in TP/BP.
If the headline is given, the parameters Input and Output are
optional. I modified GPC such that it warns about a missing program
header, but warns about missing Input and Output parameters
only if pedantic.
Procedure Foo ( protected a, b, c: Integer ); (* 3 args *) Procedure Foo ( a, b, c, protected: Integer ); (* 4 args *) Procedure Foo ( a, b, protected, c: Integer ); (* 4 args *) Procedure Foo ( protected: Integer ); (* 1 arg *) Procedure Foo ( Var protected: Integer ); (* 1 arg *) Procedure Foo ( protected protected: Integer ); (* 1 arg *)Furthermore, I implemented "Const" as an alternative to "protected" (according to Borland Pascal)
(*$B+*) or {$B+} Boolean complete evaluation
(*$B-*) or {$B-} --short-circuit
(*$c+*) or {$c+} --c-numbers
(*$E+,L+,N+*) --char-escapes, --lazy-io,
--nested-comments
(* These switches are local and can change during one compile *)
{$p+} --pedantic
{$P-} end of --pedantic
(*$I FileName *) #include "filename.pas"
{$m Hello! } write message "Hello!" to stderr
(*$D FOO bar *) #define FOO bar
{$define CMULB} #define CMULB
(*$include <hello.ph> *) #include <hello.ph>
#ifdef FOO
(*$ifdef FOO*) ... (*$endif*) ...
#endif
(* ... and all the other C preprocessor directives ... *)
By the way: I implemented an option --borland-pascal symmetrically
to --extended-pascal and --object-pascal. But I couldn't figure out
what they serve for since I didn't notice any difference in the
compiler's behaviour with and without these options. Nevertheless,
I made --borland-pascal to switch on --nested-comments, so it has
at least one effect :-).
2#100101 and ( 1 shl 5 ) = 2#100000I could not restrain, but also implemented "and", "or", "xor" and "not" as "procedures":
x:= 7; and ( x, 14 ); (* yields 6 *) xor ( x, 3 ); (* yields 5 *)(This is a feature I often missed with Borland Pascal.)
Var x: Integer; c: Char; inc ( i ); (* i:= i + 1; *) dec ( i, 7 ); (* i:= i - 7; *) inc ( c, 3 ); (* c:= chr ( ord ( c ) + 3 ); *)
GetMem ( MyPtr, 1024 ); FreeMem ( MyPtr, 1024 );GPC now supports this and also a "function-style" call to `GetMem':
MyPtr:= GetMem ( 1024 );(see also: New in context of Object Orientated Programming) One somehow strange feature of Borland is *not* supported: You can free parts of a variable with FreeMem, while the rest is still used and can be FreeMem'ed later by another pointer:
Type Vector = array [ 0..65535 ] of Integer; VecPtr = ^Vector; Var p, q: VecPtr; ... GetMem ( p, 1024 * SizeOf ( Integer ) ); q:= &p^ [ 512 ]; ... FreeMem ( p, 512 * SizeOf ( Integer ) ); ... FreeMem ( q, 512 * SizeOf ( Integer ) );
$cafe = 2#1100101011111110
Const
A: Integer = 7;
B: array [ 1..3 ] of Char = ( 'B', 'a', 'r' );
(* TP/BP also would also understand " = 'Bar'; ". *)
Foo: record
x, y: Integer;
end (* Foo *)
= ( x: 3; y: 4 );
Borland and ISO style for the right-hand side are both supported.
Once working on this, I also implemented VAX Pascal variable ini-
tializing with `:=' (as an alternative to `value') and also with
`=' (like in Borland "initialized variables").
Warning: This was one of my last changes and is not yet stable. I
could not, for example, recover from 3 shift/reduce conflicts and 1
reduce/reduce conflict. This causes trouble when the type (for
example a subrange) ends up with an expression such that the parser
takes the `=' as a relational operator.
Procedure ReadVar ( Var x: Void; TypeChoice: Char ); Var xInt: Integer absolute x; xChar: Char absolute x; xStr: String ( 80 ) absolute x; begin (* ReadVar *) ... end (* ReadVar *);
Function MyFunc: Integer; AsmName 'MyPrettyFunc_';With this extension it is possible to access all external functions, for example the XT interface functions, and not only those written in lowercase. My first idea to use `external' for this purpose (to avoid name space pollution) conflicts with another Borland extension not yet implemen- ted: In Borland Pascal, the declaration
Procedure Foo; external 'MyLib';means that the procedure Foo should be imported by name ("Foo") from a dynamic link library "mylib.dll".
@" in TP/BP.
Implemented into GPC as an alternative to "&".
case 1..3 of ..." is allowed now.
Type MyParentPtr = ^MyParentObj; MyPtr = ^MyObj; MyParentObj = object ... end (* MyParentObj *); MyObj = object ( MyParentObj ) a, b, c: Integer; Constructor Init; d, e: Char; (* GNU extension: Data fields *) Destructor Fini; virtual;(* and methods may be mixed *) Procedure Foo ( x: Integer ); Function Bar: Char; virtual; (* "private" is not (yet) implemented *) end (* MyObj *); Var My: MyParentPtr; ... Constructor MyObj.Init; begin (* MyObj.Init *) inherited Init; a:= 0; MyParentObj.Bar; end (* MyObj.Init *); ... My:= New ( MyPtr, Init ); My^.Foo ( 3 ); Dispose ( My, Fini ); New ( My, Init ); with My^ do writeln ( Bar );I first tried to recycle parts of the C++ and/or ObjC frontend, but I gave up after a few hours. Since I was not able to understand how they work, I re-invented and implemented my own Object frontend -- the third one I noticed in the GNU compiler family. Sorry.
(*$X+*)
Type
Vec3 = record
x, y, z: Real;
end (* Vec3 *);
Var
a, b, c: Vec3;
Operator + ( u, v: Vec3 ) w: Vec3;
begin (* Vec3 + Vec3 *)
w.x:= u.x + v.x;
w.y:= u.y + v.y;
w.z:= u.z + v.z;
end (* Vec3 + Vec3 *);
...
c:= a + b;
Extended Pascal would require an equal sign before the return value
variable specification (`w' in the above example) while PXSC for-
bids it. Therefore I allow the equal sign to be present or not,
both in a function declaration as well as in an operator declaration.
Pascal is a well-known programming language and hardly needs to be described here. Notice, however, that some people's idea of Pascal is affected by acquaintance with such products as Turbo Pascal which differ from the Pascal standard and provide a lot of nonstandard extensions (some of which are compatible with the Extended Pascal standard). Moreover, it is worth mentioning that the ISO Pascal standard defines two levels of the language, level 0 and level 1; the only difference between the levels is that level 1 supports the so-called conformant array schemas in parameter declarations.
Extended Pascal is a standardized language which contains so significant extensions to Pascal that it is best regarded as a new language. It is currently not very well known, and computer vendors do not seem to be eager to provide compilers for it. Thus, there is social need for GNU Pascal supporting Extended Pascal.
As mentioned earlier, Turbo Pascal does not conform to any of the Pascal standards. If you carefully chose a subset of unextended Pascal, you may be able to port code if you're lucky/careful.
To be fair, Turbo Pascal has some wonderful features that make it very powerful in the environments in which it runs. However, some of those features are of little use on non Windows/DOS platforms and probably are not good candidates for standardization.
There are several Turbo Pascal features which are semantically similar to features in unextended Pascal or Extended Pascal. Here is a list of mappings between Turbo Pascal features and Extended Pascal features:
otherwise instead of else.
Borland Pascal
case c of 'A' : ; 'B' : ; else ...; end;Extended Pascal
case c of 'A' : ; 'B' : ; otherwise ...; end;
otherwise clause and char c had
the value 'C', you got an error (note, this would be unnoticed in
Borland Pascal).
type CompareFunction = function(Key1, Key2 : string) : integer; function Sort(Compare : CompareFunction); begin ... end;Extended Pascal
function Sort(Compare : function(Key1, Key2 : string) : integer); begin ... end;Moving from Turbo Pascal to Extended Pascal might be difficult if the Turbo Pascal program saves, compares, trades, etc. procedure values. For example, an array of procedure values isn't possible in Extended Pascal. Moving the other way is a little easier as show by the above examples.
string
without a length meaning the same as string[255]. There is no
default in Extended Pascal so you have to change all string types
to string(255). Example:
var s : string;becomes:
var s : string(255);Note also that you have to use parentheses instead of brackets.
type PString = ^String;In Extended Pascal this is a pointer to a schema type! Don't forget to translate this to:
type string255 = string(255); PString = ^string255;If you indeed want to use String as a schema pointer you can define things like:
type MyStr : ^String; begin New(MyStr, 1024); end;to allocate 1024 bytes of string space.
const i:integer = 0;to:
var i : integer value 0;
type MyInteger = integer value 0; var i : MyInteger;All variables of type MyInteger are automatically initialized to 0 when created.
const
MyStringsCount = 5;
type
Ident = string[20];
const
MyStrings : array [1..MyStringsCount] of Ident = (
'EXPORT', 'IMPLEMENTATION', 'IMPORT', 'INTERFACE',
'MODULE');
to:
const
MyStringsCount = 5;
type
Ident = string(20);
var
MyStrings : array [1..MyStringsCount] of Ident value [
1:'EXPORT'; 2:'IMPLEMENTATION'; 3:'IMPORT';
4:'INTERFACE'; 5:'MODULE'];
There seem to be pros and cons to each style.
Some folks don't like having to specify an index since it requires
renumbering if you want to add a new item to the middle. However,
if you index by an enumerated type, you might be able to avoid
major renumbering by hand.
type
PersonRec = record
Age : integer;
case EyeColor : (Red, Green, Blue, Brown) of
Red, Green : (Wears_Glasses : Boolean);
Blue, Brown : (Length_of_lashes : integer);
end;
end;
The variant field needs an explicit type. Code this as:
type
EyeColorType = (Red, Green, Blue, Brown);
PersonRec = record
Age : integer;
case EyeColor : EyeColorType of
Red, Green : (Wears_Glasses : Boolean);
Blue, Brown : (Length_of_lashes : integer);
end;
end;
unit A; interface uses B, C; procedure D; implementation procedure D; begin end; end.to this module:
module A interface; export A = (D); import B; C; procedure D; end. module A implementation; procedure D; begin end; end.You can have one or more export clauses and the name of an export clause doesn't have to be equal to the name of the module. You also see in this example how to translate the Borland Pascal "uses" clause to the Extended Pascal "import" clause.
unit A;
interface
implementation
begin
{ do something }
end.
Extended Pascal
module A interface;
end.
module A implementation;
to begin do begin
{ do something }
end;
end.
Extended Pascal also has a "to end do .... end" so you can
translate Exit handlers also.
var
t : text;
Line : string;
begin
Assign(t, 'MYTEXT.TXT');
Reset(t);
while not eof(t) do begin
readln(t, Line);
writeln(Line);
end;
end;
The Assign function associated the textfile T with the file
MYTEXT.TXT.
In Extended Pascal, files are considered entities external to your
program. External entities, which don't need to be files, need to
be bound to a variable your program. Any variable to which
external entities can be bound needs to be declared bindable. So
the variable declaration of t becomes:
var t : bindable text;Extended Pascal has the bind function that binds a variable with an external entity. Here is an Extended Pascal procedure that emulates the Assign procedure in Turbo Pascal.
procedure Assign(var t : text; protected Name : string); var b : BindingType; begin unbind (t); b := binding (t); b.Name := Name; bind (t, b); b := binding (t); end;Comments: the unbind procedure unbinds a bindable variable from its external entity. If it is not bound, nothing happens. The binding function initializes b. We call binding to set some fields of the BindingType record. Next we set the name field to the name of the file. Calling bind will bind t to the external entity. If we now call binding again, we get the current state of t's binding type. We can now check for example if the bind has succeeded by:
if not b.bound then
{ do error processing }
Note that Prospero's Pascal defaults to creating the file if it
does not exists! You need to use Prospero's local addition of
setting b.existing to true to work-around this.
I've not worked with binary files enough, so no advice yet on how
to access them, but you access them much the same.
As last an example of getting the size of a file.
function FileSize(filename : String) : LongInt;
var
f : bindable file [0..MaxInt] of char;
b : BindingType;
begin
unbind(f);
b := binding (f);
b.Name := filename;
bind(f, b);
b := binding(f);
SeekRead(f, 0);
if empty(f)
then file_size := 0
else file_size := LastPosition(f) + 1;
unbind(f);
end(*file_size*);
Prospero's Extended Pascal has a bug in this case. Replace the
MaxInt in the type definition of f by a sufficiently large
integer. GNU Pascal works correct in this case.
This chapter is intended to be a QuickStart guide for programmers who are familiar with Borland Pascal, version 7 for DOS protected mode. Other versions don't differ too much but this one is the very last DOS version Borland has published.
Unlike other FreeWare compilers, GNU Pascal is *not* intended to be 100% Borland compatible. GNU Pascal is part of the GNU project, so portability is one of its primary goals. For this reason, non-portable features of Borland Pascal will probably not be included into GNU Pascal. Some other differences are so minimal that we have more important things to do than to implement them.
However if you want to contribute to GNU Pascal by eliminating holes in GPC's Borland compatibility, be welcome in the GNU Pascal development team! See See section How you can contribute to GNU Pascal for details.
It is one of the most annoying points about GPC that there is no Integrated Development Environment like BP.EXE at the moment. We are working on it, but this will take some time, especially because GNU Pascal is a portable compiler intended to run under a large variety of operating systems in the same manner. Please be patient--or offer your help! (For the moment, you can try to use Borland's IDE for GNU Pascal--see below.)
The GNU Pascal Compiler, GPC, is called about like the command-line version of the Borland Pascal Compiler, BPC. Edit your source file(s) with your favorite ASCII editor (e.g. the Borland IDE), then call GNU Pascal with a command line like
C:\GNU-PAS> gpc hello.pas
on your DOS or OS/2 box or
myhost/home/joe/gnu-pascal> gpc hello.pas -o hello
on your UNIX (e.g. Linux or FreeBSD) box. Don't omit the suffix `.pas': GPC is a common interface for a Pascal compiler, a C, ObjC and C++ compiler, an assembler, a linker, and perhaps a Modula and FORTRAN compiler. From the extension of your source file GPC figures out which processor to run.
The -o is a command line option which tells GPC how the
executable has to be named. This is not necessary for DOS and
OS/2, so we omit it in this file from now on.
Note that GPC is case-sensitive concerning file names, so it will not work if you type
C:\GNU-PAS> GPC HELLO.PAS
GPC is a very quiet compiler and doesn't print anything on the screen unless you request it or there is an error. If you want to see what is going on, invoke GPC with additional options:
-Q "don't be quiet" (or: Quassel-Modus in German)
means that GPC prints out the names of procedures and functions it processes, and
--verbose
means that GPC informs you about the stages of compilation, i.e. preprocessing, compiling, assembling, and linking.
One example (this time for OS/2):
[C:\GNU-Pascal] gpc --verbose -Q hello.pas
Throughout this chapter, we will tell you about a lot of command-line switches. They are all invoked this way.
After compilation, there will be an executable hello file in
the current directory. (hello.exe with DOS and OS/2.) Just
run it and enjoy. If there are errors, GNU Pascal will not stop
compilation after the first one--as Borland Pascal does--but
try to catch them all in one compilation. If you get more error
messages than your screen can hold, you can catch them in a file
(e.g. gpc.out) in the following way:
gpc hello.pas 2>gpc.out
This works with DOS, OS/2 and any bash-like shell under UNIX.
However, you can use Borland's IDE for GNU Pascal on the DOS platform: Install the GNU Pascal Compiler in the Tools menu (via Options/Tools).
Name: GNU Pascal Path: gpc Arguments: $SAVE ALL --verbose -Q $NAME($EDNAME).pas HotKey: Shift+F9
Note once more that GPC is case-sensitive, so it is important to
specify .pas instead of the .PAS Borland Pascal would
append otherwise!
You can include more command-line arguments to GNU Pascal (e.g. `--automake'; see below) as you will learn more about them below.
Because Borland Pascal will try to recompile your program if you
use its run menu function, you will need another "tool"
to run your program:
Name: run program Path: command.com Arguments: /c $NAME($EDNAME) HotKey: Shift+F10
According to ISO 7185 and ISO 10206 standard, GNU Pascal recognizes
by default comments opened with (* and closed with }.
With Borland Pascal, both types of comments can be nested, so
you will probably have sources where passages containing
comments are "commented out".
To use this with GPC, you have to "switch on" nested comments either by a command-line option, or by a compiler directive:
--nested-comments {$N+} (*$N+*)
The $N directive also exists in BP but has another meaning. The same holds for most of GPC's other compiler directives (also corresponding to command-line options in most cases):
--short-circuit $B+ $B- like in Borland Pascal:
$B- means short-circuit Boolean
operators; $B+ complete evaluation
--c-numbers $C+ $C- enable/disable C-style octal 0177
and hexadecial 0xFF numbers
--char-escapes $E+ $E- enable/disable C-style character
escape sequences in strings
--nested-comments $N+ $N- see above
--pedantic $P+ $P- give/don't give warnings about
violations of ISO 7185
Standard Pascal
$W+ $W- enable/disable warnings
$X+ $X- enable/disable extended syntax
(function return value ignore,
operator definitions)
{$I FileName } include filename.pas or
filename.p (make it lowercase)
{$include "filename.pas"} include (case-sensitive)
{$include <filename.pas>} the same, but don't search in
current directory
{$M Hello!} write message "Hello!" to error
device during compilation
{$D GNU} define GNU (for conditional
{$define GNU} compilation)
-D GNU the same in command line
{$D loop while true do} define "loop" to be "while
true do" as a macro like in C.
It is case-sensitive.
{$ifdef GNU} conditional compilation
... (like in Borland Pascal).
{$else} GPC predefines the symbol
... __GPC__ (with two leading
{$endif} and trailing underscores).
You also can use C-style preprocessor directives, e.g. #include.
As in Borland Pascal, {$...} and (*$...*) are equivalent.
You can use Units in the same way as in Borland Pascal. However, there are some differences, problems and new features. (Please report the bug if something doesn't work.)
Concerning the syntax of a Unit, you can, if you want, use Extended Pascal syntax to specify a Unit initializer, i.e. instead of writing
begin
...
end.
at the end of the Unit, you can get the same result with
to begin do
begin
...
end (* to begin *);
and there also exists
to end do
begin
...
end (* to end *);
which specifies a finalization routine. Use this instead of Borland Pascal's exit procedures. You also can specify an order in which initializers are run--see See section GNU Pascal extensions and See section About Pascal and Extended Pascal languages for more about this. There you can also find information about Extended Pascal Modules, an alternative to Units.
At the moment, there are no qualified identifiers, so take care about name clashes between different Units.
When GPC compiles a Unit, it produces two files: an .o object
file (compatible with other GNU compilers such as GNU C) plus a
precompiled Interface which resides in a .gpi file.
(See See section GPI files -- GNU Pascal Interfaces for GPI file internals.)
GPC does not automatically recognize that something is a Unit and cannot be linked; you have to tell this by a command line switch:
-c only compile, don't link.
For example, to compile two units, use:
gpc -c myunit1.pas myunit2.pas
Of course, one of the purposes of writing Units is to compile
them separately. However, GNU Pascal allows you to have one or
more Units in the same source file (producing only one .o file
but separate .gpi files). You even can have a Program and Units
in one and the same source file; in this case, no .o file at all
is produced.
You can use the above as a workaround (*$include the Unit *) in case something goes wrong with the .gpi mechanism. (It is a new feature in GPC 2.7.2 and may be unstable.)
When you have all Units compiled and want to compile the
Program, specify the .o files in the command line:
gpc hallo.pas myunit1.o myunit2.o
You also can specify the program and the units in one command line:
gpc hallo.pas myunit1.pas myunit2.pas
As an alternative to manually compiling and specifying object files, you can use GPC's AutoMake feature. (WARNING: This is a new feature in GPC 2.7.2 and may be unstable!) With an additional command-line argument
gpc --automake hallo.pas
GPC tries to behave like Borland Pascal's make facility and
automatically recompiles Units the source of which has been
changed. It also works if an included file has been changed.
To pass arguments to the compilation of Units, specify them in a
string surrounded by quotation marks after --automake=. For
example, if you want to give the --verbose argument not only at
top level but also for (re)compilation of Units, use:
gpc --verbose --automake="--verbose" hallo.pas
For more information about the AutoMake mechanism, see See section GNU Pascal's AutoMake facility.
GNU Pascal is a 32 bit compiler with excellent optimization algorithms (which are identically the same as those of GNU C). There are three official optimization levels, specified by the command line options `-O', `-O2', and `-O3'. Actually, this goes up to `-O6', but levels above `-O3' are experimental (as far as I know).
One example:
Program Test;
Var
A, B: Integer;
begin
A:= 3;
B:= 4;
writeln ( A + B );
end.
When GNU Pascal compiles this program with optimization, it
recognizes that the argument of writeln is the constant 7--and
optimizes away the variables A and B.
For more about optimization, see the GNU C documentation.
The command line option `-g' specifies generation of debugging
information for GDB, the GNU debugger. GDB is not as
comfortable as the Turbo Debugger, but it has the same abilities
but one: The program being debugged is slowed down. For more
information about GDB, call it with `gdb' and type in the help
command.
GDB has one very nice feature which might even make up for the
slowing-down problematic: When a GNU-compiled program crashes,
it puts out a core file. When you say "target core core" to
the GNU debugger, it reads the core file and can tell you the
address of the crash, the contents of variables and of the
stack, and so on.
Sometimes it is nice to have a look at the assembler output of
the compiler. When you specify the -S command line option, GPC
produces an .s file instead of an .o file which contains
assembler source for your program. More about this in the next
section.
GNU Pascal has an inline assembler, but it is quite different from Borland's one. I have not yet found reasonable documentation about the use of this assembler, but I found out the following:
The syntax is
asm ( 'movl $12345678, %eax' ); asm ( 'movl %eax, %edx' );
to move the (hex) value `$12345678' to the EAX register and then to the EDX register. The String argument of the asm "procedure" is passed as a string to the assembler stage of the compilation. Note that the order of operands is reversed with respect to the order you know from other Intel assemblers and that the size of the arguments is appended to the mnemonic as a suffix b (byte), w (word = 2 bytes), or l (long = 4 bytes).
You can learn about the GNU assembler syntax when compiling your program with `-S' (see above) and looking into the resulting assembler source.
To access Pascal symbols from the assembler, do something like
asm ( 'movl %%eax, %0' : : 'rm' ( MyVariable ) );
Here, the % signs in front of the register names are doubled because % gets some special meaning. The 'rm' means that the operand may be in a register or in memory.
(If somebody knows more about the GNU assembler syntax, please, please, please explain it to me or point me to some reasonable documentation about it! <peter.gerwinski@uni-essen.de>)
Objects in the Borland Pascal 7.0 notation are implemented into GNU Pascal with the following differences:
MyObj = object
x: Integer;
Procedure Foo; virtual;
y: Real;
Function Bar: Char;
end (* MyObj *);
Strings are "Schema types" in GNU Pascal which is something more
complicated than Borland-style strings. For variables, you
cannot specify just String as a type (always specify the
maximum length); for parameters you can. There is no 255 length
limit. According to Extended Pascal, the maximum string length
must be in (parantheses); GNU Pascal accepts [brackets],
however.
For more about Strings and Schema types see See section GNU Pascal extensions and See section About Pascal and Extended Pascal languages.
String-handling functions (see See section GNU Pascal extensions) are different in both dialects but can approximately be mapped on each other:
Borland Pascal GNU Pascal
length length
Pos Index
Str WriteStr
Val ReadStr
Copy SubStr, MyStr [ 2..7 ]
MyStr [ 0 ]:= #7; Trim
- EQ, NE, LT, LE, GT, GE
Insert -
Delete -
It should not be difficult to write a compatibility Unit--if you do so, please send it to us!
GNU Pascal supports Borland Pascal's "typed constants" but also Extended Pascal's initialized variables:
Var
x: Integer value 7;
When a typed constant is misused as an initialized variable, a warning is given.
Initialization of structured variables (typed constants) is not yet stable.
When you want a local variable to preserve its value, define it as `__static__' instead of using a typed constant:
Procedure Foo;
Var
x: __static__ Real;
begin (* Foo *)
(* x keeps its value between two calls to this Procedure *)
end (* Foo *);
Remark: If you don't like underscores, you can use the (*$define *) mechanism to get rid of them:
(*$define static __static__ *)
The (non-standard) bitwise operators `shl', `shr', `and', `or', `xor' work in GNU Pascal like in Borland Pascal. As an extension, you can use them as "procedures", for examples
and ( x, $0000FFFF );
as an alternative to
x:= x and $0000FFFF;
Instead of the Borland-specific notation `$ABCD' for hexadecimal numbers you also can use Extended Pascal notation:
2#11111111 for a binary, 8#177 for an octal, 16#FF for a hexadecimal number,
and so on up to a basis of 36.
Inc and dec are implemented like in Borland Pascal; pred and succ are generalized according to Extended Pascal:
a:= succ ( a, 5 );
Absolute variables work only in the context of overloading with other variables, not in the context of specifying an absolute address. The Mem and Port arrays don't exist in GNU Pascal.
Borland Pascal's procedures FillChar and move are not
built-in into GNU Pascal. However, you can write them by
yourself using untyped Var parameters (see Sec. Data types).
GNU Pascal allows the user to define operators according to the Pascal-SC syntax:
(*$X+*)
Type
Point = record
x, y: Real;
end (* Point *);
Operator + ( a, b: Point ) c: Point;
begin (* Point + Point *)
c.x:= a.x + b.x;
c.y:= a.y + b.y;
end (* Point + Point *);
It is necessary to enable "extended syntax" `(*$X+*)' when defining operators.
The Pascal-SC operators `+>', `+<', etc. for exact numerical calculations are not implemented, but you can define them. If you write a module which really implements these operators, please send it to us, so we can include it into the next distribution.
(And if you know more about modules in Pascal-SC than just their existence, please contact us either! We could probably easily implement them if we knew how they look like. Something quite close to Pascal-SC modules already *is* implemented as "GNU specific modules".)
Borland Pascal GNU Pascal
__byte__ Integer
Integer __short__ Integer
LongInt Integer = __long__ Integer
Comp __longlong__ Integer
Byte __unsigned__ __byte__ Integer
Word __unsigned__ __short__ Integer
- __unsigned__ __long__ Integer
- __unsigned__ __longlong__ Integer
Real types: There is no built-in `Single', `Double',
`Extended' in GNU Pascal; Real has 8 bytes on an Intel-x86
machine. Use `__short__ Real' to define `Single',
`__long__ Real' to define `Extended'.
Borland Pascal GNU Pascal Single __short__ Real Real - Double Real Extended __long__ Real Comp __longlong__ Integer
Type
FuncPtr = ^Function ( Real ): Real;
Furthermore, GNU Pascal supports Standard Pascal's procedural
parameters--see below.
Assign procedure for files, but you can
write it by yourself using the "Bind" mechanism of Extended
Pascal:
Procedure Assign ( Var T: Text; Name: String );
Var
B: BindingType;
begin (* Assign *)
unbind ( T );
B:= binding ( T );
B.Name:= Name;
bind ( T, B );
B:= binding ( T );
end (* Assign *);
pow and ** which do not
exist in Borland Pascal. You can use x pow y for integer
and x ** y for real or complex exponents; the basis may be
integer, real or complex in both cases.
@, but also
& as an address operator.
set1 >< set2. See See section GNU Pascal extensions for more about this.
p:= GetMem ( 1024 );The second parameter to FreeMem is ignored by GNU Pascal and may be omitted. Memory blocks are always freed with the same size they were allocated with. Remark: Extended Pascal Schema types will provide a cleaner approach to most of the applications of `GetMem' and `FreeMem' in the future.
Procedure Foo ( Var x: Void );in GNU Pascal instead of
Procedure Foo ( Var x );in Borland Pascal.
Procedure Foo ( a: Integer; ... );but does not (yet) provide a portable mechanism to access the additional arguments.
Procedure DrawGraph ( f: Function ( Real ): Real );
Program Foo ( Input, Output );
In GNU Pascal, headline parameters are optional. If the
headline is omitted, a warning is given.
otherwise instead of else (according to Extended Pascal):
case x of
1: writeln ( 'one' );
2: writeln ( 'two' );
otherwise: writeln ( 'many' );
end (* case *);
If there are two ore more statements following otherwise,
they must be grouped with begin and end.
card ( myset ) function for sets
which counts their elements.
Function Max ( x, y: Integer ): Integer; Inline ( $58 / $59 / $3B / $C1 / $7F / $01 / $91 );GNU Pascal:
Inline Function Max ( x, y: Integer ): Integer;
begin (* Max *)
if x > y then
Max:= x
else
Max:= y;
end (* Max *);
(Actually, a more general Max is already built-in.)
This feature is not so important as it might seem because in
optimization level 3 (see above), GNU Pascal automatically
"inlines" short Procedures and Functions.
If you encounter a bug with GPC, please check whether it is one of
the known bugs. If not, report it to the GNU Pascal mailing list
gpc@hut.fi. (But always report it if you solve the problem! ;-)
The GPC compiler does not yet implement the whole ISO 7185 Pascal standard, so please take this into account when you consider using this for any purpose.
See the file `version.c' to find out the version number of this GPC
(or run gpc -v)
Problems in this GPC version:
(void *)
pointer, so you have to cast it in order to output
the object the pointer points to.
Also, I have not tried any other debugger than gdb.
If you do, please let me know what happens.
I think that GDB does not yet support the kind of `.stabs'
that should be used to do this correctly:
.stabs ":tanumber=bnumber", whateverwhere anumber is the unknown pointer type referenced earlier, and the bnumber is the type which anumber actually is. This construct is not required in C.
Procedure FooBAR(i:integer);c;This makes the external name to be `_foobar' (replace
_ with you machine prefix.)
Procedure FooBAR(i:Integer); External;Uses external name
_Foobar.
It is done like this to reduce name clashes
with `libc.a' and other possible libraries.
_p_....
Below you can find a list of jobs which should be done for GNU-Pascal. In cases where somebody is already working on it, the name of that person is written behind the job's description together with the status of the project; e-mail addresses are given below.
If there is already a name behind a job, this does not mean that you shouldn't do that but just that you should get in contact with that person if you would like to contribute to that field.
Welcome to the GNU Pascal development team!
Overall coordination Juki works ;-) Coordination with GCC developers Juki ? Merge into GCC main distribution Juki ? ISO 7185 Standard Pascal Juki works ISO 10206 Extended Pascal Juki 90% Object Pascal ? Borland Pascal 7.0 Peter 80% Delphi ? Pascal-SC Peter please help! Compiler options to force one standard Peter planned EMX version (DOS and OS/2) Peter works Linux binaries Peter works DJ version (DOS) JanJaap works Win32 version JanJaap 70% Cross compilers Linux -> others JanJaap works Installation instructions Larry ? Documentation Larry ? Type checking Juki ? Automatic make Peter works Objects: C++ code compatibility ? PXSC module syntax Peter planned Procedure overloading Peter planned Precompiled module interfaces Peter works Run time system Juki works I/O error handling ? Turbo compatible DOS, CRT, Graph, ... ? ask Peter Turbo Vision compatible library ? POSIX library (replacement for DOS) Berend to be ported Replacement for (parts of) CRT Peter beta (BO5) Replacement for Graph Peter planned (BO5) Replacement for Turbo Vision Peter planned (BO5) Port of the RHIDE IDE JanJaap ? Improvement of the XWPE IDE ?
Berend Berend de Boer, Nederlands
<100120.3121@compuserve.com>
JanJaap Jan Jaap van der Heijden, Nederlands
<j.j.vanderheijden@student.utvente.nl>
Juki Jukka Virtanen, Finland
<jtv@hut.fi>
Larry Larry Carter, USA
<lcarter@powerslave.jf.intel.com>
Peter Peter Gerwinski, Germany
<peter.gerwinski@uni-essen.de>
by Florian Klaempfl <fnklaem@cip.ft.uni-erlangen.de>
and Peter Gerwinski <peter.gerwinski@uni-essen.de>
7. July 1996
FPK Pascal GNU Pascal
---------- ----------
aim: free Borland compatible free portable
32-bit Pascal compiler 32-bit Pascal compiler
version: 0.6.4 2.6.3
operating DOS (DJ), OS/2 DOS, OS/2 (EMX)
systems: DOS (DJ)
arbitrary UNIX systems
written in: Pascal, TP Syntax C
(compiles itself)
source: 900 kB 2.8 MB
plus source of GCC (8 MB)
language Borland Pascal 7.0, ISO 7185, ISO 10206,
standard: (parts of) Delphi II (most of) Borland Pascal 7.0
extensions: function overloading operators
home server: http://www.brain.uni-freiburg.de ftp://kampi.hut.fi/jtv/gnu-pascal
license: FreeWare (GPL) FreeWare (GPL)
author: Florian Klaempfl, Germany Jukka Virtanen, Finland
fnklaem@cip.ft.uni-erlangen.de jtv@hut.fi
c-decl.c.
This mainly does re-ordering of the data structures. The glue
lives in gpc-parser.y or in gpc-util.c.
gpc-parse.y,
actualparameterlist() and default_conversion().
tree.def sometime in the future;
currently I am mis-using Tiemann's FRIEND_DECL TREECODE
which looks exactly like my KNOWNID_DECL would look like.
So maybe there is no need to add it at all for Pascal.
gpc-parse.y builds a variant record, it
constructs an unnamed RECORD_TYPE containing the possible variant
selector field and an unnamed UNION_TYPE node. When find_field()
sees unnamed RECORD_TYPE or UNION_TYPE nodes implicitely
propagates to the inner layer of the definition. It then returns
the TREE_LIST chain of this propagation and this is modified to a
series of build(COMPONENT_REF,...) for all propagated RECORD_TYPE
nodes, which the rest of gcc will handle. This does NOT YET check
variant access errors... When thinking about it, it does not
check very many other things either, so maybe no one will notice
this :-)
expr.c.
GPC-1.2 (GCC-2.7.2)
Last modified: Sun Dec 10 00:58:14 1995 Run by: Juki <jtv@hut.fi>
Number of validation suite tests run: 199 Only LEVEL-0 tests run (no conformant arrays).
All programs have been named as pDDD.pas (DDD = three digits)
Otherwise my naming convention does not mean anything.
All tests run with and without -g and with/without -O
and with/without -O6 Only the tests that fail are mentioned,
otherwise they all pass.
TEST WHAT HAPPENS ---- ------------ i486 Mach 3 (CMU UX): All conformance tests pass. rs-6000 Aix 3.2.5: All conformance tests pass. mips Ultrix 4.3: All conformance tests pass. *** Tested with gpc 2.5.7 only alpha: OSF 1/V3.2c: All conformace tests pass. Important: DO NOT USE -O switch with the alpha GPC until the problems are fixed!!! *** With -O the following FAIL *** This is ridiculous!!! They worked before... p004 FAIL p029 FAIL p069 FAIL p072 FAIL p075 FAIL p076 FAIL p098 FAIL p108 FAIL p110 FAIL p111 FAIL p113 FAIL p128 FAIL p136 FAIL p142 runtime error p157 FAIL p164 FAIL p167 FAIL p171 FAIL *** But with -O6 the following are compiled incorrectly. *** (i.e. they compile but produce incorrect results). *** Don't use -O6 on alpha until the bugs are fixed. *** These have never worked. *** I have not checked the reason for these: p029 FAIL p095 FAIL p110 FAIL p111 FAIL p117 Loops p157 FAIL sparc Solaris 2.3: *** Tested with gpc 2.6.3 only 003 Signal 11 received by the compiler when -O (optimized) HP-PA: HP-UX 9.03 / --with-gnu-as All other tests pass, except 003: 003 Compiler: Unrecognized insn. Compiler abort(). (PASS with -O6) p003.pas:262: internal error--unrecognizable insn: (jump_insn 730 728 732 (set (pc) (if_then_else (gt (const_int 0) (reg:SI 259)) (label_ref 766) (pc))) -1 (nil) (nil)) p003.pas:262: internal gcc abort p003.pas did not compile This looks more like a generic GNU compiler bug than a bug in GPC code... 003 is the PVS test 6.1.1-3.
Juki <jtv@hut.fi>
Last modified: Wed Sep 22 11:47:27 1993
Set of T type nodes are represented as bit vectors,
one bit for each element. The SET_TYPE objects contain
only the bits necessary to represent the set type
PLUS the padding to align the objects to the
nearest word boundary. Thus, there may be unused
bits in front and after the end of otherwise
contiquous bit vector that represents all the elements
of the set.
[ -maxint, maxint ]
to work. Maybe someone implements this later,
e.g. with a list of set fragments or a list of set
elements.
setop.c
in some language independend way. (Global variables :-)
setop.c).
CARD_EXPR: returns the number of set elements currently in the set
Extended Pascal.
UNION SetC := SetA + SetB; union of the sets
BIT_OR_EXPR
DIFF SetC := SetA - SetB; If in A, but not in B.
BIT_ANDTC_EXPR (and tc_optab has vanished from gcc-2, so this
will be done "SetA and (not (SetB))")
INTERSECTION SetC := SetA * SetB; If in A and in B
BIT_AND_EXPR
SYMDIFF SetC := SetA >< SetB; set symmetric difference
BIT_XOR_EXPR (C if only in A or only in B (Boolean XOR)
Extended Pascal.
SEARCH_EXPR: in a set iteration, yields each member of the set
in some implementation dependend order.
Extended Pascal (this is not yet implemented in gpc).
Rest of the operands result in boolean values.
=, <> Equality comparisons
<= LE_EXPR
SetA <= SetB denotes the inclusion of SetA in SetB
>= Implemented with LE_EXPR, like above
SetA >= SetB denotes the inclusion of SetB in SetA
This file documents the mechanism how information is transferred from the exporting Modules and Units to the Program, Module or Unit which imports (uses) the information.
The GPI mechanism is not (yet :-) as stable as it should be. If you encounter problems with your Modules or Units, please do the following:
A GPI file contains a precompiled GNU Pascal Interface. "Precompiled" means in this context that the Interface already has been parsed (i.e the front-end has done its work), but that no assembler output has been produced yet.
The GPI file format is an implementation-dependent (but not too implementation-dependent ;-) file format for storing GNU Pascal Interfaces to be exported--Extended Pascal and PXSC module interfaces as well as interface parts of Borland Pascal Units compiled with GNU Pascal.
To see what information is stored in or loaded from a GPI file, run
GPC with an additional command-line option --debug-gpi. Then, GPC
will write a human-readable version of what is being stored/loaded
to stderr.
While parsing an Interface, GPC stores the names of exported objects
in tree lists--in gpc-parse.y, the bison (yacc) source of GPC's parser,
search for handle_autoexport. At the end of the Interface, everything
is stored in one or more GPI files. This is called in gpc-parse.y--search
for create_gpi_files ().
Everything else is done in gpc-module.c. Here you can find the source
of create_gpi_files () which documents the file format: First, a header
of 33 bytes containing the string GNU Pascal Module/Unit Interface\n
is stored, then the name of the primary source file of the module as a
string, then the name of the exported interface as a tree node (see
below), after that all exported names in the order as they were stored
while parsing.
The names and the objects (i.e. constants, data types, variables and
functions) they refer to are internally represented as so-called
tree nodes as defined in the files tree.h and tree.def from the GCC
source (i.e. the source of the GNU C compiler). The names are stored
as IDENTIFIER_NODEs, their meanings as IDENTIFIER_GLOBAL_VALUEs
of these nodes. The main problem when storing tree nodes is that they
form a complicated tree in memory with a lot of circular references
making it hard to decide which information must be stored and which
mustn't.
The functions load_tree and store_tree are intended to load/store a tree node in a GPI file.
Each tree node has a TREE_CODE indicating what kind of information
it contains. Each different tree node must be stored in a different
way. See the source of load_tree and store_tree for details.
Most tree nodes contain pointers to other tree nodes; therefore
load_tree and store_tree are recursive functions.
The --debug-gpi debugging informations contains the recursion
level in parantheses, e.g. loaded (2): means that the loaded
information was requested by a pointer contained in a tree node
requested by a pointer contained in a tree node representing an
exported symbol.
Since this recursion can be circular (think of a record containing
a pointer to a record of the same type), we must resolve references
to tree nodes which already have been loaded. For this reason, and
for saving disk space, I have introduced a gpi_contents list
containing pointers to all nodes so far loaded from / stored in the
GPI file under consideration. When storing a node which already is
in the gpi_contents list, a (normally invalid) TREE_CODE of 255
`(0xFF)' followed by the (int) index of the node in the
gpi_contents list is stored instead. Like this, the reference
uses 1 byte plus the size of an int (normally 4) in the GPI file.
In the debugging information, this method of storing/loading is
indicated as via gpi_contents.
There are some special tree_nodes (e.g. integer_type_node or
NULL_TREE) which are used very often. I have assigned (normally
invalid) unique TREE_CODES for them, so they can be stored in a
single byte.
That's it. Now you should be able to "read" GPI files using GPC's
--debug-gpi option. If you encounter a case where the loaded
information differs too much from the stored information, you
have found a bug--congratulations! What "too much" means, depends
on the object being stored in / loaded from the GPI file. Remind
that the order things are loaded from a GPI file is the reversed
order things are stored when considering different recursion levels,
but the same order when considering ths same recursion level.
This file documents a feature of GPC which makes it superfluos to use `make' (and to write a Makefile) in most cases.
(For those who know Borland Pascal: `bpc -m foo' ("make") is now `gpc --automake foo.pas.')
When you invoke GPC with the command line option --automake, it
checks whether the Modules/Units your program uses must be
recompiled. If so, it recursively calls GPC -c to compile them.
Furthermore, the names of user-written object files are
automatically passed to the linker. This means that you can
compile (and link) your program with a line like
gpc --automake foo.pas
even if foo is a large project with a lot of Modules/Units and
include files. (Yes, when you have modified an include file, GPC
recognizes which Modules/Units must be recompiled!)
If you want to pass command line options to such second-level compiles, specify them with the --automake option:
gpc --automake="-g -O6 -D TERMCAP" foo.pas
Don't forget the quotes if the string contains blanks. When you omit this specification, top level command line options are not automatically passed through.
When a Program/Module/Unit imports (uses) an Interface, GPC searches for the GPI file (see GPI.DOC) derived from the name of the Interface.
Case 1: A GPI file was found.
Each GPI file contains the name of the primary source file
(normally a .pas or .p file) of the Module/Unit, and the
names of all interfaces imported. GPC reads this information
and invokes itself with a command like
gpc foo.pas -M -o foo.d
This means: preprocess the file, and write down the name of
the object file and those of all its source files in foo.d.
GPC reads foo.d and looks if the object file exists and if
the source was modified since the creation of the object file
and the gpi file. If so, GPC calls itself again to compile
the primary source file. When everything is done, the .d
file is removed. If there was no need to recompile, all
interfaces imported by the Module/Unit are processed in the
same way as this one.
Case 2: No GPI file was found.
In this case, GPC derives the name of the source file from
that of the Interface by trying first interface.p, then
interface.pas. This will almost always work with Borland
Pascal Units, almost never with Extended Pascal Modules. With
Extended Pascal, compile the Module once manually in order to
produce a GPI file.
All this is done by the function gpi_open () which uses some
auxiliary functions such as module_must_be_recompiled () and
compile_module ().
Each time an object file is compiled or recognized as being up-to-date, its name is stored in a temporary file with the same base name as all the other temporary files used by GPC but the extension .gpc. When the top-level gpc is invoked (which calls gpc1 later on), it passes the name of this temporary file as an additional command line parameter to gpc1. After compilation has been completed, the top-level gpc reads the temporary file and adds the new object files to the arguments passed to the linker.
The additional command (--amtmpfile; not to be specified
by the user!) is passed to child GPC processes, so all compiles
use the same temporary file.
The source for this is merely in gpc-module.c, but there are
also some hacks in gcc.c, additional command line options in
gpc-options.h and gpc-decl.c, and gpc-defs.h is
adapted to support new functions and global variables.
This section describes known problems that affect users of GNU CC. Most of these are not GNU CC bugs per se--if they were, we would fix them. But the result for a user may be like the result of a bug.
Some of these problems are due to bugs in other software, some are missing features that are too much work to add, and some are places where people's opinions differ as to what is best.
fixincludes script interacts badly with automounters; if the
directory of system header files is automounted, it tends to be
unmounted while fixincludes is running. This would seem to be a
bug in the automounter. We don't know any good way to work around it.
fixproto script will sometimes add prototypes for the
sigsetjmp and siglongjmp functions that reference the
jmp_buf type before that type is defined. To work around this,
edit the offending file and place the typedef in front of the
prototypes.
This is a list of problems (and some apparent problems which don't really mean anything is wrong) that show up during installation of GNU CC.
CC can interfere with the functioning of make.
fixincludes if the
System V file system doesn't support symbolic links. These problems
result in a failure to fix the declaration of size_t in
`sys/types.h'. If you find that size_t is a signed type and
that type mismatches occur, this could be the cause.
The solution is not to use such a directory for building GNU CC.
gpc driver program looked for
as and ld in various places; for example, in files
beginning with `/usr/local/lib/gpc-'. GNU CC version 2 looks for
them in the directory
`/usr/local/lib/gpc-lib/target/version'.
Thus, to use a version of as or ld that is not the system
default, for example gas or GNU ld, you must put them in
that directory (or make links to them from that directory).
make. These failures, which
are often due to files that were not found, are expected, and can safely
be ignored.
make recompiles parts of the compiler when installing
the compiler. In one case, this was traced down to a bug in
make. Either ignore the problem or switch to GNU Make.
enquire, which is part of building
GNU CC. The fix is to get rid of the file real-ld which purify
installs--so that GNU CC won't try to use it.
__GNU_LIBRARY__ conditional
around line 31 to `#if 1'.
enquire hangs due to a hardware problem in the motherboard--it
reports floating point exceptions to the kernel incorrectly. You can
install GNU CC except for `float.h' by patching out the command to
run enquire. You may also be able to fix the problem for real by
getting a replacement motherboard. This problem was observed in
Revision E of the Micronics motherboard, and is fixed in Revision F.
It has also been observed in the MYLEX MXA-33 motherboard.
If you encounter this problem, you may also want to consider removing
the FPU from the socket during the compilation. Alternatively, if you
are running SCO Unix, you can reboot and force the FPU to be ignored.
To do this, type `hd(40)unix auto ignorefpu'.
ln /etc/emulator.rel1 /etc/emulatorand then reboot the system. (The default emulator file remains present under the name `emulator.dflt'.) Try using `/etc/emulator.att', if you have such a problem on the SCO system. Another system which has this problem is Esix. We don't know whether it has an alternate emulator that works. On NetBSD 0.8, a similar problem manifests itself as these error messages:
enquire.c: In function `fprop': enquire.c:2328: floating overflow
genflags or genoutput while building GNU CC. This is said to
be due to a bug in sh. You can probably get around it by running
genflags or genoutput manually and then retrying the
make.
pkginfo command. To add an optional package, use the
pkgadd command. For further details, see the Solaris
documentation.
For Solaris 2.0 and 2.1, GNU CC needs six packages: `SUNWarc',
`SUNWbtool', `SUNWesu', `SUNWhea', `SUNWlibm', and
`SUNWtoo'.
For Solaris 2.2, GNU CC needs an additional seventh package: `SUNWsprot'.
PATH.
add.d.
fixincludes. This causes
problems in building GNU CC. Once GNU CC is installed, the problems go
away.
To work around this problem, when making the stage 1 compiler, specify
this option to Make:
GCC_FOR_TARGET="./xgpc -B./ -I./include"When making stage 2 and stage 3, specify this option:
CFLAGS="-g -I./include"
alloca against shared
libraries on RISC-OS 5.0, and DEC's OSF/1 systems. This is a bug
in the linker, that is supposed to be fixed in future revisions.
To protect against this, GNU CC passes `-non_shared' to the
linker unless you pass an explicit `-shared' or
`-call_shared' switch.
ld fatal: failed to write symbol name something in strings table for file whateverThis probably indicates that the disk is full or your ULIMIT won't allow the file to be as large as it needs to be. This problem can also result because the kernel parameter
MAXUMEM
is too small. If so, you must regenerate the kernel and make the value
much larger. The default value is reported to be 1024; a value of 32768
is said to work. Smaller values may also work.
/usr/local/lib/bison.simple: In function `yyparse': /usr/local/lib/bison.simple:625: virtual memory exhaustedthat too indicates a problem with disk space, ULIMIT, or
MAXUMEM.
MAXUMEM = 4096
_floatdisf cc1: warning: `-g' option not supported on this version of GCC cc1: warning: `-g1' option not supported on this version of GCC ./xgpc: Internal compiler error: program as got fatal signal 11A patched version of the assembler is available by anonymous ftp from
altdorf.ai.mit.edu as the file
`archive/cph/hpux-8.0-assembler'. If you have HP software support,
the patch can also be obtained directly from HP, as described in the
following note:
This patch is also known as PHCO_4484.This is the patched assembler, to patch SR#1653-010439, where the assembler aborts on floating point constants.
The bug is not really in the assembler, but in the shared library version of the function "cvtnum(3c)". The bug on "cvtnum(3c)" is SR#4701-078451. Anyway, the attached assembler uses the archive library version of "cvtnum(3c)" and thus does not exhibit the bug.
fixproto shell script triggers a bug in the system shell.
If you encounter this problem, upgrade your operating system or
use BASH (the GNU shell) to run fixproto.
muldi3 in file `libgpc2.c'.
You may be able to succeed by getting GNU CC version 1, installing it,
and using it to compile GNU CC version 2. The bug in the Pyramid C
compiler does not seem to affect GNU CC version 1.
va_arg when you build GNU CC.
If this happens, then you need to link most programs with the library
`iclib.a'. You must also modify `stdio.h' as follows: before
the lines
#if defined(__i860__) && !defined(_VA_LIST) #include <va_list.h>insert the line
#if __PGC__and after the lines
extern int vprintf(const char *, va_list ); extern int vsprintf(char *, const char *, va_list ); #endifinsert the line
#endif /* __PGC__ */These problems don't exist in operating system version 1.1.
./fixproto: sh internal 1K buffer overflowTo fix this, change the first line of the fixproto script to look like:
#!/bin/ksh
You may run into problems with cross compilation on certain machines, for several reasons.
REAL_VALUE_TYPE. But doing so is a substantial amount of
work for each target machine.
See section Cross Compilation and Floating Point.
This section lists various difficulties encountered in using GNU C or GNU C++ together with other compilers or with the assemblers, linkers, libraries and debuggers on certain systems.
fixincludes. The corrected header files go in a new
directory; GNU CC searches this directory before `/usr/include'.
If you use `-I/usr/include', this tells GNU CC to search
`/usr/include' earlier on, before the corrected headers. The
result is that you get the uncorrected header files.
Instead, you should use these options (when compiling C programs):
-I/usr/local/lib/gpc-lib/target/version/include -I/usr/includeFor C++ programs, GNU CC also uses a special directory that defines C++ interfaces to standard C subroutines. This directory is meant to be searched before other standard include directories, so that it takes precedence. If you are compiling C++ programs and specifying include directories explicitly, use this option first, then the two options above:
-I/usr/local/lib/g++-include
double on an 8-byte
boundary, and it expects every double to be so aligned. The Sun
compiler usually gives double values 8-byte alignment, with one
exception: function arguments of type double may not be aligned.
As a result, if a function compiled with Sun CC takes the address of an
argument of type double and passes this pointer of type
double * to a function compiled with GNU CC, dereferencing the
pointer may cause a fatal signal.
One way to solve this problem is to compile your entire program with GNU
CC. Another solution is to modify the function that is compiled with
Sun CC to copy the argument into a local variable; local variables
are always properly aligned. A third solution is to modify the function
that uses the pointer to dereference it via the following function
access_double instead of directly with `*':
inline double
access_double (double *unaligned_ptr)
{
union d2i { double d; int i[2]; };
union d2i *p = (union d2i *) unaligned_ptr;
union d2i u;
u.i[0] = p->i[0];
u.i[1] = p->i[1];
return u.d;
}
Storing into the pointer can be done likewise with the same union.
malloc function in the `libmalloc.a' library
may allocate memory that is only 4 byte aligned. Since GNU CC on the
Sparc assumes that doubles are 8 byte aligned, this may result in a
fatal signal if doubles are stored in memory allocated by the
`libmalloc.a' library.
The solution is to not use the `libmalloc.a' library. Use instead
malloc and related functions from `libc.a'; they do not have
this problem.
_dlclose, _dlsym or _dlopen
when linking, compile and link against the file
`mit/util/misc/dlsym.c' from the MIT version of X windows.
cc does not
compile GNU CC correctly. We do not yet know why. However, GNU CC
compiled on earlier HP-UX versions works properly on HP-UX 9.01 and can
compile itself properly on 9.01.
alloca or variable-size arrays. This is because GNU CC doesn't
generate HP-UX unwind descriptors for such functions. It may even be
impossible to generate them.
(warning) Use of GR3 when frame >= 8192 may cause conflict.These warnings are harmless and can be safely ignored.
as -u < /dev/nullIf the command exits normally, the assembler fix already is installed. If the assembler complains that "-u" is an unknown flag, you need to order the fix.
extern int foo; ... foo ... static int foo;will cause the linker to report an undefined symbol
foo.
Although this behavior differs from most other systems, it is not a
bug because redefining an extern variable as static
is undefined in ANSI C.
size_t. You should change `sys/types.h' by adding these
lines around the definition of size_t:
#ifndef _SIZE_T #define _SIZE_T actual typedef here #endif
-fcall-saved-r2 -fcall-saved-r3 -fcall-saved-r4 -fcall-saved-r5
-L/usr/local/lib/gpc-lib/we32k-att-sysv/2.7.1 -lgpc -lc_sThe first specifies where to find the library `libgpc.a' specified with the `-lgpc' option. GNU CC does linking by invoking
ld, just as cc does, and
there is no reason why it should matter which compilation program
you use to invoke ld. If someone tracks this problem down,
it can probably be fixed easily.
ecvt, fcvt and gcvt. Given valid
floating point numbers, they sometimes print `NaN'.
Certain programs have problems compiling.
#ifdef __STDC__ #define NeedFunctionPrototypes 0 #endif
-traditional -Dvolatile=__volatile__ -I/usr/include/sun -I/usr/ucbinclude -fpcc-struct-returnmost of which are unnecessary with GCC 2.4.5 and newer versions. You can make a properly working Perl by setting
ccflags to
`-fwritable-strings' (implied by the `-traditional' in the
original options) and cppflags to empty in `config.sh', then
typing `./doSH; make depend; make'.
MALLOC=/usr/local/lib/libgmalloc.aAlternatively, if you have compiled `gmalloc.c' from Emacs 19, copy the object file to `gmalloc.o' and use this option when you relink GNU CC:
MALLOC=gmalloc.o
There are several noteworthy incompatibilities between GNU C and most existing (non-ANSI) versions of C. The `-traditional' option eliminates many of these incompatibilities, but not all, by telling GNU C to behave like the other C compilers.
mktemp with a string
constant argument. The function mktemp always alters the
string its argument points to.
Another consequence is that sscanf does not work on some systems
when passed a string constant as its format control string or input.
This is because sscanf incorrectly tries to write into the string
constant. Likewise fscanf and scanf.
The best solution to these problems is to change the program to use
char-array variables with initialization strings for these
purposes instead of string constants. But if this is not possible,
you can use the `-fwritable-strings' flag, which directs GNU CC
to handle string constants the same way most C compilers do.
`-traditional' also has this effect, among others.
-2147483648 is positive.
This is because 2147483648 cannot fit in the type int, so
(following the ANSI C rules) its data type is unsigned long int.
Negating this value yields 2147483648 again.
#define foo(a) "a"will produce output
"a" regardless of what the argument a is.
The `-traditional' option directs GNU CC to handle such cases
(among others) in the old-fashioned (non-ANSI) fashion.
setjmp and longjmp, the only automatic
variables guaranteed to remain valid are those declared
volatile. This is a consequence of automatic register
allocation. Consider this function:
jmp_buf j;
foo ()
{
int a, b;
a = fun1 ();
if (setjmp (j))
return a;
a = fun2 ();
/* longjmp (j) may occur in fun3. */
return a + fun3 ();
}
Here a may or may not be restored to its first value when the
longjmp occurs. If a is allocated in a register, then
its first value is restored; otherwise, it keeps the last value stored
in it.
If you use the `-W' option with the `-O' option, you will
get a warning when GNU CC thinks such a problem might be possible.
The `-traditional' option directs GNU C to put variables in
the stack by default, rather than in registers, in functions that
call setjmp. This results in the behavior found in
traditional C compilers.
foobar (
#define luser
hack)
ANSI C does not permit such a construct. It would make sense to support
it when `-traditional' is used, but it is too much work to
implement.
extern declaration affects all the
rest of the file even if it happens within a block.
The `-traditional' option directs GNU C to treat all extern
declarations as global, like traditional compilers.
long, etc., with a typedef name,
as shown here:
typedef int foo; typedef long foo bar;In ANSI C, this is not allowed:
long and other type modifiers
require an explicit int. Because this criterion is expressed
by Bison grammar rules rather than C code, the `-traditional'
flag cannot alter it.
#if 0 You can't expect this to work. #endifThe best solution to such a problem is to put the text into an actual C comment delimited by `/*...*/'. However, `-traditional' suppresses these error messages.
time, so it did not matter what type your program declared it to
return. But in systems with ANSI C headers, time is declared to
return time_t, and if that is not the same as long, then
`long time ();' is erroneous.
The solution is to change your program to use time_t as the return
type of time.
float, PCC converts it to
a double. GNU CC actually returns a float. If you are concerned
with PCC compatibility, you should declare your functions to return
double; you might as well say what you mean.
STRUCT_VALUE and
STRUCT_INCOMING_VALUE tell GNU CC where to pass this address.
By contrast, PCC on most target machines returns structures and unions
of any size by copying the data into an area of static storage, and then
returning the address of that storage as if it were a pointer value.
The caller must copy the data from that memory area to the place where
the value is wanted. GNU CC does not use this method because it is
slower and nonreentrant.
On some newer machines, PCC uses a reentrant convention for all
structure and union returning. GNU CC on most of these machines uses a
compatible convention when returning structures and unions in memory,
but still returns small structures and unions in registers.
You can tell GNU CC to use a compatible convention for all structure and
union returning with the option `-fpcc-struct-return'.
GNU CC needs to install corrected versions of some system header files. This is because most target systems have some header files that won't work with GNU CC unless they are changed. Some have bugs, some are incompatible with ANSI C, and some depend on special features of other compilers.
Installing GNU CC automatically creates and installs the fixed header
files, by running a program called fixincludes (or for certain
targets an alternative such as fixinc.svr4). Normally, you
don't need to pay attention to this. But there are cases where it
doesn't do the right thing automatically.
fixincludes script to fail.
This means you will encounter problems due to bugs in the system header
files. It may be no comfort that they aren't GNU CC's fault, but it
does mean that there's nothing for us to do about them.
GNU CC by itself attempts to be what the ISO/ANSI C standard calls a conforming freestanding implementation. This means all ANSI C language features are available, as well as the contents of `float.h', `limits.h', `stdarg.h', and `stddef.h'. The rest of the C library is supplied by the vendor of the operating system. If that C library doesn't conform to the C standards, then your programs might get warnings (especially when using `-Wall') that you don't expect.
For example, the sprintf function on SunOS 4.1.3 returns
char * while the C standard says that sprintf returns an
int. The fixincludes program could make the prototype for
this function match the Standard, but that would be wrong, since the
function will still return char *.
If you need a Standard compliant library, then you need to find one, as
GNU CC does not provide one. The GNU C library (called glibc)
has been ported to a number of operating systems, and provides ANSI/ISO,
POSIX, BSD and SystemV compatibility. You could also ask your operating
system vendor if newer libraries are available.
These problems are perhaps regrettable, but we don't know any practical way around them.
int foo (struct mumble *);
struct mumble { ... };
int foo (struct mumble *x)
{ ... }
This code really is erroneous, because the scope of struct
mumble in the prototype is limited to the argument list containing it.
It does not refer to the struct mumble defined with file scope
immediately below--they are two unrelated types with similar names in
different scopes.
But in the definition of foo, the file-scope type is used
because that is available to be inherited. Thus, the definition and
the prototype do not match, and you get an error.
This behavior may seem silly, but it's what the ANSI standard specifies.
It is easy enough for you to make your code work by moving the
definition of struct mumble above the prototype. It's not worth
being incompatible with ANSI C just to avoid an error for the example
shown above.
include; then do
`make install' again.
double in memory.
Compiled code moves values between memory and floating point registers
at its convenience, and moving them into memory truncates them.
You can partially avoid this problem by using the `-ffloat-store'
option (see section Options That Control Optimization).
C++ is a complex language and an evolving one, and its standard definition (the ANSI C++ draft standard) is also evolving. As a result, your C++ compiler may occasionally surprise you, even when its behavior is correct. This section discusses some areas that frequently give rise to questions of this sort.
When a class has static data members, it is not enough to declare the static member; you must also define it. For example:
class Foo
{
...
void method();
static int bar;
};
This declaration only establishes that the class Foo has an
int named Foo::bar, and a member function named
Foo::method. But you still need to define both
method and bar elsewhere. According to the draft ANSI
standard, you must supply an initializer in one (and only one) source
file, such as:
int Foo::bar = 0;
Other C++ compilers may not correctly implement the standard behavior.
As a result, when you switch to g++ from one of these compilers,
you may discover that a program that appeared to work correctly in fact
does not conform to the standard: g++ reports as undefined
symbols any static data members that lack definitions.
It is dangerous to use pointers or references to portions of a
temporary object. The compiler may very well delete the object before
you expect it to, leaving a pointer to garbage. The most common place
where this problem crops up is in classes like the libg++
String class, that define a conversion function to type
char * or const char *. However, any class that returns
a pointer to some internal structure is potentially subject to this
problem.
For example, a program may use a function strfunc that returns
String objects, and another function charfunc that
operates on pointers to char:
String strfunc (); void charfunc (const char *);
In this situation, it may seem natural to write `charfunc
(strfunc ());' based on the knowledge that class String has an
explicit conversion to char pointers. However, what really
happens is akin to `charfunc (strfunc ().convert ());',
where the convert method is a function to do the same data
conversion normally performed by a cast. Since the last use of the
temporary String object is the call to the conversion function,
the compiler may delete that object before actually calling
charfunc. The compiler has no way of knowing that deleting the
String object will invalidate the pointer. The pointer then
points to garbage, so that by the time charfunc is called, it
gets an invalid argument.
Code like this may run successfully under some other compilers, especially those that delete temporaries relatively late. However, the GNU C++ behavior is also standard-conforming, so if your program depends on late destruction of temporaries it is not portable.
If you think this is surprising, you should be aware that the ANSI C++ committee continues to debate the lifetime-of-temporaries problem.
For now, at least, the safe way to write such code is to give the temporary a name, which forces it to remain until the end of the scope of the name. For example:
String& tmp = strfunc (); charfunc (tmp);
protoize
The conversion programs protoize and unprotoize can
sometimes change a source file in a way that won't work unless you
rearrange it.
protoize can insert references to a type name or type tag before
the definition, or in a file where they are not defined.
If this happens, compiler error messages should show you where the new
references are, so fixing the file by hand is straightforward.
protoize cannot figure out.
For example, it can't determine argument types for declaring a
pointer-to-function variable; this you must do by hand. protoize
inserts a comment containing `???' each time it finds such a
variable; so you can find all such variables by searching for this
string. ANSI C does not require declaring the argument types of
pointer-to-function types.
unprotoize can easily introduce bugs. If the program
relied on prototypes to bring about conversion of arguments, these
conversions will not take place in the program without prototypes.
One case in which you can be sure unprotoize is safe is when
you are removing prototypes that were made with protoize; if
the program worked before without any prototypes, it will work again
without them.
You can find all the places where this problem might occur by compiling
the program with the `-Wconversion' option. It prints a warning
whenever an argument is converted.
protoize cannot get the argument types for a function whose
definition was not actually compiled due to preprocessing conditionals.
When this happens, protoize changes nothing in regard to such
a function. protoize tries to detect such instances and warn
about them.
You can generally work around this problem by using protoize step
by step, each time specifying a different set of `-D' options for
compilation, until all of the functions have been converted. There is
no automatic way to verify that you have got them all, however.
unprotoize can become confused when trying to convert a function
definition or declaration which contains a declaration for a
pointer-to-function formal argument which has the same name as the
function being defined or declared. We recommand you avoid such choices
of formal parameter names.
This section lists changes that people frequently request, but which we do not make because we think GNU CC is better without them.
void whenever the value isn't
useful.
int is signed or not. This in effect creates two
alternative dialects of C.
The GNU C compiler supports both dialects; you can specify the signed
dialect with `-fsigned-bitfields' and the unsigned dialect with
`-funsigned-bitfields'. However, this leaves open the question of
which dialect to use by default.
Currently, the preferred dialect makes plain bitfields signed, because
this is simplest. Since int is the same as signed int in
every other context, it is cleanest for them to be the same in bitfields
as well.
Some computer manufacturers have published Application Binary Interface
standards which specify that plain bitfields should be unsigned. It is
a mistake, however, to say anything about this issue in an ABI. This is
because the handling of plain bitfields distinguishes two dialects of C.
Both dialects are meaningful on every type of machine. Whether a
particular object file was compiled using signed bitfields or unsigned
is of no concern to other object files, even if they access the same
bitfields in the same data structures.
A given program is written in one or the other of these two dialects.
The program stands a chance to work on most any machine if it is
compiled with the proper dialect. It is unlikely to work at all if
compiled with the wrong dialect.
Many users appreciate the GNU C compiler because it provides an
environment that is uniform across machines. These users would be
inconvenienced if the compiler treated plain bitfields differently on
certain machines.
Occasionally users write programs intended only for a particular machine
type. On these occasions, the users would benefit if the GNU C compiler
were to support by default the same dialect as the other compilers on
that machine. But such applications are rare. And users writing a
program to run on more than one type of machine cannot possibly benefit
from this kind of compatibility.
This is why GNU CC does and will treat plain bitfields in the same
fashion on all types of machines (by default).
There are some arguments for making bitfields unsigned by default on all
machines. If, for example, this becomes a universal de facto standard,
it would make sense for GNU CC to go along with it. This is something
to be considered in the future.
(Of course, users strongly concerned about portability should indicate
explicitly in each bitfield whether it is signed or not. In this way,
they write programs which have the same meaning in both C dialects.)
__STDC__ when `-ansi' is not used.
Currently, GNU CC defines __STDC__ as long as you don't use
`-traditional'. This provides good results in practice.
Programmers normally use conditionals on __STDC__ to ask whether
it is safe to use certain features of ANSI C, such as function
prototypes or ANSI token concatenation. Since plain `gpc' supports
all the features of ANSI C, the correct answer to these questions is
"yes".
Some users try to use __STDC__ to check for the availability of
certain library facilities. This is actually incorrect usage in an ANSI
C program, because the ANSI C standard says that a conforming
freestanding implementation should define __STDC__ even though it
does not have the library facilities. `gpc -ansi -pedantic' is a
conforming freestanding implementation, and it is therefore required to
define __STDC__, even though it does not come with an ANSI C
library.
Sometimes people say that defining __STDC__ in a compiler that
does not completely conform to the ANSI C standard somehow violates the
standard. This is illogical. The standard is a standard for compilers
that claim to support ANSI C, such as `gpc -ansi'---not for other
compilers such as plain `gpc'. Whatever the ANSI C standard says
is relevant to the design of plain `gpc' without `-ansi' only
for pragmatic reasons, not as a requirement.
__STDC__ in C++.
Programs written to compile with C++-to-C translators get the
value of __STDC__ that goes with the C compiler that is
subsequently used. These programs must test __STDC__
to determine what kind of C preprocessor that compiler uses:
whether they should concatenate tokens in the ANSI C fashion
or in the traditional fashion.
These programs work properly with GNU C++ if __STDC__ is defined.
They would not work otherwise.
In addition, many header files are written to provide prototypes in ANSI
C but not in traditional C. Many of these header files can work without
change in C++ provided __STDC__ is defined. If __STDC__
is not defined, they will all fail, and will all need to be changed to
test explicitly for C++ as well.
void func (int, int); int i = 2; func (i++, i++);There is no guarantee (in either the C or the C++ standard language definitions) that the increments will be evaluated in any particular order. Either increment might happen first.
func might get the
arguments `2, 3', or it might get `3, 2', or even `2, 2'.
The GNU compiler can produce two kinds of diagnostics: errors and warnings. Each kind has a different purpose:
Warnings may indicate danger points where you should check to make sure that your program really does what you intend; or the use of obsolete features; or the use of nonstandard features of GNU C or C++. Many warnings are issued only if you ask for them, with one of the `-W' options (for instance, `-Wall' requests a variety of useful warnings).
GNU CC always tries to compile your program if possible; it never gratuitously rejects a program whose meaning is clear merely because (for instance) it fails to conform to a standard. In some cases, however, the C and C++ standards specify that certain extensions are forbidden, and a diagnostic must be issued by a conforming compiler. The `-pedantic' option tells GNU CC to issue warnings in such cases; `-pedantic-errors' says to make them errors instead. This does not mean that all non-ANSI constructs get warnings or errors.
See section Options to Request or Suppress Warnings, for more detail on these and related command-line options.
Your bug reports play an essential role in making GNU CC reliable.
When you encounter a problem, the first thing to do is to see if it is already known. See section Known Causes of Trouble with GNU CC. If it isn't known, then you should report the problem.
Reporting a bug may help you by bringing a solution to your problem, or it may not. (If it does not, look in the service directory; see section How To Get Help with GNU CC.) In any case, the principal function of a bug report is to help the entire community by making the next version of GNU CC work better. Bug reports are your contribution to the maintenance of GNU CC.
Since the maintainers are very overloaded, we cannot respond to every bug report. However, if the bug has not been fixed, we are likely to send you a patch and ask you to tell us whether it works.
In order for a bug report to serve its purpose, you must include the information that makes for fixing the bug.
If you are not sure whether you have found a bug, here are some guidelines:
asm statement), that is a compiler bug, unless the
compiler reports errors (not just warnings) which would ordinarily
prevent the assembler from being run.
return
is omitted; it is not a bug when GNU CC produces different results.
Problems often result from expressions with two increment operators,
as in f (*p++, *p++). Your previous compiler might have
interpreted that expression the way you intended; GNU CC might
interpret it another way. Neither compiler is wrong. The bug is
in your code.
After you have localized the error to a single source line, it should
be easy to check for these things. If your program is correct and
well defined, you have found a compiler bug.
Send bug reports for GNU C to `bug-gpc@prep.ai.mit.edu'.
Send bug reports for GNU C++ to `bug-g++@prep.ai.mit.edu'. If your bug involves the C++ class library libg++, send mail to `bug-lib-g++@prep.ai.mit.edu'. If you're not sure, you can send the bug report to both lists.
Do not send bug reports to `help-gpc@prep.ai.mit.edu' or to the newsgroup `gnu.gpc.help'. Most users of GNU CC do not want to receive bug reports. Those that do, have asked to be on `bug-gpc' and/or `bug-g++'.
The mailing lists `bug-gpc' and `bug-g++' both have newsgroups which serve as repeaters: `gnu.gpc.bug' and `gnu.g++.bug'. Each mailing list and its newsgroup carry exactly the same messages.
Often people think of posting bug reports to the newsgroup instead of mailing them. This appears to work, but it has one problem which can be crucial: a newsgroup posting does not contain a mail path back to the sender. Thus, if maintainers need more information, they may be unable to reach you. For this reason, you should always send bug reports by mail to the proper mailing list.
As a last resort, send bug reports on paper to:
GNU Compiler Bugs Free Software Foundation 59 Temple Place - Suite 330 Boston, MA 02111-1307, USA
The fundamental principle of reporting bugs usefully is this: report all the facts. If you are not sure whether to state a fact or leave it out, state it!
Often people omit facts because they think they know what causes the problem and they conclude that some details don't matter. Thus, you might assume that the name of the variable you use in an example does not matter. Well, probably it doesn't, but one cannot be sure. Perhaps the bug is a stray memory reference which happens to fetch from the location where that name is stored in memory; perhaps, if the name were different, the contents of that location would fool the compiler into doing the right thing despite the bug. Play it safe and give a specific, complete example. That is the easiest thing for you to do, and the most helpful.
Keep in mind that the purpose of a bug report is to enable someone to fix the bug if it is not known. It isn't very important what happens if the bug is already known. Therefore, always write your bug reports on the assumption that the bug is not known.
Sometimes people give a few sketchy facts and ask, "Does this ring a bell?" This cannot help us fix a bug, so it is basically useless. We respond by asking for enough details to enable us to investigate. You might as well expedite matters by sending them to begin with.
Try to make your bug report self-contained. If we have to ask you for more information, it is best if you include all the previous information in your response, as well as the information that was missing.
Please report each bug in a separate message. This makes it easier for us to track which bugs have been fixed and to forward your bugs reports to the appropriate maintainer.
Do not compress and encode any part of your bug report using programs such as `uuencode'. If you do so it will slow down the processing of your bug. If you must submit multiple large files, use `shar', which allows us to read your message without having to run any decompression programs.
To enable someone to investigate the bug, you should include all these things:
configure command when you installed
the compiler.
pr to print the RTL expression that it points
to. (If GDB doesn't run on your machine, use your debugger to call
the function debug_rtx with the RTX as an argument.) In
general, whenever a variable is a pointer, its value is no use
without the data it points to.
Here are some things that are not necessary:
If you would like to write bug fixes or improvements for the GNU C
compiler, that is very helpful. Send suggested fixes to the bug report
mailing list, bug-gpc@prep.ai.mit.edu.
Please follow these guidelines so we can study your patches efficiently. If you don't follow these guidelines, your information might still be useful, but using it will take extra work. Maintaining GNU C is a lot of work in the best of circumstances, and we can't keep up unless you do your best to help.
If you need help installing, using or changing GNU CC, there are two ways to find it:
bug-gpc@prep.ai.mit.edu, and if that brings no response, try
help-gpc@prep.ai.mit.edu.
Here is how to use GNU CC on VMS.
Due to the differences between the filesystems of Unix and VMS, GNU CC attempts to translate file names in `#include' into names that VMS will understand. The basic strategy is to prepend a prefix to the specification of the include file, convert the whole filename to a VMS filename, and then try to open the file. GNU CC tries various prefixes one by one until one of them succeeds:
Include directives of the form:
#include foobar
are a common source of incompatibility between VAX-C and GNU CC. VAX-C
treats this much like a standard #include <foobar.h> directive.
That is incompatible with the ANSI C behavior implemented by GNU CC: to
expand the name foobar as a macro. Macro expansion should
eventually yield one of the two standard formats for #include:
#include "file" #include <file>
If you have this problem, the best solution is to modify the source to
convert the #include directives to one of the two standard forms.
That will work with either compiler. If you want a quick and dirty fix,
define the file names as macros with the proper expansion, like this:
#define stdio <stdio.h>
This will work, as long as the name doesn't conflict with anything else in the program.
Another source of incompatibility is that VAX-C assumes that:
#include "foobar"
is actually asking for the file `foobar.h'. GNU CC does not make this assumption, and instead takes what you ask for literally; it tries to read the file `foobar'. The best way to avoid this problem is to always specify the desired file extension in your include directives.
GNU CC for VMS is distributed with a set of include files that is
sufficient to compile most general purpose programs. Even though the
GNU CC distribution does not contain header files to define constants
and structures for some VMS system-specific functions, there is no
reason why you cannot use GNU CC with any of these functions. You first
may have to generate or create header files, either by using the public
domain utility UNSDL (which can be found on a DECUS tape), or by
extracting the relevant modules from one of the system macro libraries,
and using an editor to construct a C header file.
A #include file name cannot contain a DECNET node name. The
preprocessor reports an I/O error if you attempt to use a node name,
whether explicitly, or implicitly via a logical name.
GNU CC does not provide the globalref, globaldef and
globalvalue keywords of VAX-C. You can get the same effect with
an obscure feature of GAS, the GNU assembler. (This requires GAS
version 1.39 or later.) The following macros allow you to use this
feature in a fairly natural way:
#ifdef __GNUC__
#define GLOBALREF(TYPE,NAME) \
TYPE NAME \
asm ("_$$PsectAttributes_GLOBALSYMBOL$$" #NAME)
#define GLOBALDEF(TYPE,NAME,VALUE) \
TYPE NAME \
asm ("_$$PsectAttributes_GLOBALSYMBOL$$" #NAME) \
= VALUE
#define GLOBALVALUEREF(TYPE,NAME) \
const TYPE NAME[1] \
asm ("_$$PsectAttributes_GLOBALVALUE$$" #NAME)
#define GLOBALVALUEDEF(TYPE,NAME,VALUE) \
const TYPE NAME[1] \
asm ("_$$PsectAttributes_GLOBALVALUE$$" #NAME) \
= {VALUE}
#else
#define GLOBALREF(TYPE,NAME) \
globalref TYPE NAME
#define GLOBALDEF(TYPE,NAME,VALUE) \
globaldef TYPE NAME = VALUE
#define GLOBALVALUEDEF(TYPE,NAME,VALUE) \
globalvalue TYPE NAME = VALUE
#define GLOBALVALUEREF(TYPE,NAME) \
globalvalue TYPE NAME
#endif
(The _$$PsectAttributes_GLOBALSYMBOL prefix at the start of the
name is removed by the assembler, after it has modified the attributes
of the symbol). These macros are provided in the VMS binaries
distribution in a header file `GNU_HACKS.H'. An example of the
usage is:
GLOBALREF (int, ijk); GLOBALDEF (int, jkl, 0);
The macros GLOBALREF and GLOBALDEF cannot be used
straightforwardly for arrays, since there is no way to insert the array
dimension into the declaration at the right place. However, you can
declare an array with these macros if you first define a typedef for the
array type, like this:
typedef int intvector[10]; GLOBALREF (intvector, foo);
Array and structure initializers will also break the macros; you can
define the initializer to be a macro of its own, or you can expand the
GLOBALDEF macro by hand. You may find a case where you wish to
use the GLOBALDEF macro with a large array, but you are not
interested in explicitly initializing each element of the array. In
such cases you can use an initializer like: {0,}, which will
initialize the entire array to 0.
A shortcoming of this implementation is that a variable declared with
GLOBALVALUEREF or GLOBALVALUEDEF is always an array. For
example, the declaration:
GLOBALVALUEREF(int, ijk);
declares the variable ijk as an array of type int [1].
This is done because a globalvalue is actually a constant; its "value"
is what the linker would normally consider an address. That is not how
an integer value works in C, but it is how an array works. So treating
the symbol as an array name gives consistent results--with the
exception that the value seems to have the wrong type. Don't
try to access an element of the array. It doesn't have any elements.
The array "address" may not be the address of actual storage.
The fact that the symbol is an array may lead to warnings where the variable is used. Insert type casts to avoid the warnings. Here is an example; it takes advantage of the ANSI C feature allowing macros that expand to use the same name as the macro itself.
GLOBALVALUEREF (int, ss$_normal); GLOBALVALUEDEF (int, xyzzy,123); #ifdef __GNUC__ #define ss$_normal ((int) ss$_normal) #define xyzzy ((int) xyzzy) #endif
Don't use globaldef or globalref with a variable whose
type is an enumeration type; this is not implemented. Instead, make the
variable an integer, and use a globalvaluedef for each of the
enumeration values. An example of this would be:
#ifdef __GNUC__
GLOBALDEF (int, color, 0);
GLOBALVALUEDEF (int, RED, 0);
GLOBALVALUEDEF (int, BLUE, 1);
GLOBALVALUEDEF (int, GREEN, 3);
#else
enum globaldef color {RED, BLUE, GREEN = 3};
#endif
GNU CC automatically arranges for main to return 1 by default if
you fail to specify an explicit return value. This will be interpreted
by VMS as a status code indicating a normal successful completion.
Version 1 of GNU CC did not provide this default.
GNU CC on VMS works only with the GNU assembler, GAS. You need version 1.37 or later of GAS in order to produce value debugging information for the VMS debugger. Use the ordinary VMS linker with the object files produced by GAS.
Under previous versions of GNU CC, the generated code would occasionally give strange results when linked to the sharable `VAXCRTL' library. Now this should work.
A caveat for use of const global variables: the const
modifier must be specified in every external declaration of the variable
in all of the source files that use that variable. Otherwise the linker
will issue warnings about conflicting attributes for the variable. Your
program will still work despite the warnings, but the variable will be
placed in writable storage.
Although the VMS linker does distinguish between upper and lower case letters in global symbols, most VMS compilers convert all such symbols into upper case and most run-time library routines also have upper case names. To be able to reliably call such routines, GNU CC (by means of the assembler GAS) converts global symbols into upper case like other VMS compilers. However, since the usual practice in C is to distinguish case, GNU CC (via GAS) tries to preserve usual C behavior by augmenting each name that is not all lower case. This means truncating the name to at most 23 characters and then adding more characters at the end which encode the case pattern of those 23. Names which contain at least one dollar sign are an exception; they are converted directly into upper case without augmentation.
Name augmentation yields bad results for programs that use precompiled libraries (such as Xlib) which were generated by another compiler. You can use the compiler option `/NOCASE_HACK' to inhibit augmentation; it makes external C functions and variables case-independent as is usual on VMS. Alternatively, you could write all references to the functions and variables in such libraries using lower case; this will work on VMS, but is not portable to other systems. The compiler option `/NAMES' also provides control over global name handling.
Function and variable names are handled somewhat differently with GNU C++. The GNU C++ compiler performs name mangling on function names, which means that it adds information to the function name to describe the data types of the arguments that the function takes. One result of this is that the name of a function can become very long. Since the VMS linker only recognizes the first 31 characters in a name, special action is taken to ensure that each function and variable has a unique name that can be represented in 31 characters.
If the name (plus a name augmentation, if required) is less than 32 characters in length, then no special action is performed. If the name is longer than 31 characters, the assembler (GAS) will generate a hash string based upon the function name, truncate the function name to 23 characters, and append the hash string to the truncated name. If the `/VERBOSE' compiler option is used, the assembler will print both the full and truncated names of each symbol that is truncated.
The `/NOCASE_HACK' compiler option should not be used when you are
compiling programs that use libg++. libg++ has several instances of
objects (i.e. Filebuf and filebuf) which become
indistinguishable in a case-insensitive environment. This leads to
cases where you need to inhibit augmentation selectively (if you were
using libg++ and Xlib in the same program, for example). There is no
special feature for doing this, but you can get the result by defining a
macro for each mixed case symbol for which you wish to inhibit
augmentation. The macro should expand into the lower case equivalent of
itself. For example:
#define StuDlyCapS studlycaps
These macro definitions can be placed in a header file to minimize the number of changes to your source code.
The main goal of GNU CC was to make a good, fast compiler for machines in the class that the GNU system aims to run on: 32-bit machines that address 8-bit bytes and have several general registers. Elegance, theoretical power and simplicity are only secondary.
GNU CC gets most of the information about the target machine from a machine description which gives an algebraic formula for each of the machine's instructions. This is a very clean way to describe the target. But when the compiler needs information that is difficult to express in this fashion, I have not hesitated to define an ad-hoc parameter to the machine description. The purpose of portability is to reduce the total work needed on the compiler; it was not of interest for its own sake.
GNU CC does not contain machine dependent code, but it does contain code
that depends on machine parameters such as endianness (whether the most
significant byte has the highest or lowest address of the bytes in a word)
and the availability of autoincrement addressing. In the RTL-generation
pass, it is often necessary to have multiple strategies for generating code
for a particular kind of syntax tree, strategies that are usable for different
combinations of parameters. Often I have not tried to address all possible
cases, but only the common ones or only the ones that I have encountered.
As a result, a new target may require additional strategies. You will know
if this happens because the compiler will call abort. Fortunately,
the new strategies can be added in a machine-independent fashion, and will
affect only the target machines that need them.
GNU CC is normally configured to use the same function calling convention normally in use on the target system. This is done with the machine-description macros described (see section Target Description Macros).
However, returning of structure and union values is done differently on some target machines. As a result, functions compiled with PCC returning such types cannot be called from code compiled with GNU CC, and vice versa. This does not cause trouble often because few Unix library routines return structures or unions.
GNU CC code returns structures and unions that are 1, 2, 4 or 8 bytes
long in the same registers used for int or double return
values. (GNU CC typically allocates variables of such types in
registers also.) Structures and unions of other sizes are returned by
storing them into an address passed by the caller (usually in a
register). The machine-description macros STRUCT_VALUE and
STRUCT_INCOMING_VALUE tell GNU CC where to pass this address.
By contrast, PCC on most target machines returns structures and unions of any size by copying the data into an area of static storage, and then returning the address of that storage as if it were a pointer value. The caller must copy the data from that memory area to the place where the value is wanted. This is slower than the method used by GNU CC, and fails to be reentrant.
On some target machines, such as RISC machines and the 80386, the standard system convention is to pass to the subroutine the address of where to return the value. On these machines, GNU CC has been configured to be compatible with the standard compiler, when this method is used. It may not be compatible for structures of 1, 2, 4 or 8 bytes.
GNU CC uses the system's standard convention for passing arguments. On some machines, the first few arguments are passed in registers; in others, all are passed on the stack. It would be possible to use registers for argument passing on any machine, and this would probably result in a significant speedup. But the result would be complete incompatibility with code that follows the standard convention. So this change is practical only if you are switching to GNU CC as the sole C compiler for the system. We may implement register argument passing on certain machines once we have a complete GNU system so that we can compile the libraries with GNU CC.
On some machines (particularly the Sparc), certain types of arguments are passed "by invisible reference". This means that the value is stored in memory, and the address of the memory location is passed to the subroutine.
If you use longjmp, beware of automatic variables. ANSI C says that
automatic variables that are not declared volatile have undefined
values after a longjmp. And this is all GNU CC promises to do,
because it is very difficult to restore register variables correctly, and
one of GNU CC's features is that it can put variables in registers without
your asking it to.
If you want a variable to be unaltered by longjmp, and you don't
want to write volatile because old C compilers don't accept it,
just take the address of the variable. If a variable's address is ever
taken, even if just to compute it and ignore it, then the variable cannot
go in a register:
{
int careful;
&careful;
...
}
Code compiled with GNU CC may call certain library routines. Most of
them handle arithmetic for which there are no instructions. This
includes multiply and divide on some machines, and floating point
operations on any machine for which floating point support is disabled
with `-msoft-float'. Some standard parts of the C library, such as
bcopy or memcpy, are also called automatically. The usual
function call interface is used for calling the library routines.
These library routines should be defined in the library `libgpc.a', which GNU CC automatically searches whenever it links a program. On machines that have multiply and divide instructions, if hardware floating point is in use, normally `libgpc.a' is not needed, but it is searched just in case.
Each arithmetic function is defined in `libgpc1.c' to use the corresponding C arithmetic operator. As long as the file is compiled with another C compiler, which supports all the C arithmetic operators, this file will work portably. However, `libgpc1.c' does not work if compiled with GNU CC, because each arithmetic function would compile into a call to itself!
The overall control structure of the compiler is in `toplev.c'. This file is responsible for initialization, decoding arguments, opening and closing files, and sequencing the passes.
The parsing pass is invoked only once, to parse the entire input. The RTL intermediate code for a function is generated as the function is parsed, a statement at a time. Each statement is read in as a syntax tree and then converted to RTL; then the storage for the tree for the statement is reclaimed. Storage for types (and the expressions for their sizes), declarations, and a representation of the binding contours and how they nest, remain until the function is finished being compiled; these are all needed to output the debugging information.
Each time the parsing pass reads a complete function definition or
top-level declaration, it calls either the function
rest_of_compilation, or the function
rest_of_decl_compilation in `toplev.c', which are
responsible for all further processing necessary, ending with output of
the assembler language. All other compiler passes run, in sequence,
within rest_of_compilation. When that function returns from
compiling a function definition, the storage used for that function
definition's compilation is entirely freed, unless it is an inline
function
Here is a list of all the passes of the compiler and their source files. Also included is a description of where debugging dumps can be requested with `-d' options.
if-conditions that are
comparisons, boolean operations or conditional expressions. Tail
recursion is detected at this time also. Decisions are made about how
best to arrange loops and how to output switch statements.
The source files for RTL generation include
`stmt.c',
`calls.c',
`expr.c',
`explow.c',
`expmed.c',
`function.c',
`optabs.c'
and `emit-rtl.c'.
Also, the file
`insn-emit.c', generated from the machine description by the
program genemit, is used in this pass. The header file
`expr.h' is used for communication within this pass.
The header files `insn-flags.h' and `insn-codes.h',
generated from the machine description by the programs genflags
and gencodes, tell this pass which standard names are available
for use and which patterns correspond to them.
Aside from debugging information output, none of the following passes
refers to the tree structure representation of the function (only
part of which is saved).
The decision of whether the function can and should be expanded inline
in its subsequent callers is made at the end of rtl generation. The
function must meet certain criteria, currently related to the size of
the function and the types and number of parameters it has. Note that
this function may contain loops, recursive calls to itself
(tail-recursive functions can be inlined!), gotos, in short, all
constructs supported by GNU CC. The file `integrate.c' contains
the code to save a function's rtl for later inlining and to inline that
rtl when the function is called. The header file `integrate.h'
is also used for this purpose.
The option `-dr' causes a debugging dump of the RTL code after
this pass. This dump file's name is made by appending `.rtl' to
the input file name.
Some additional files are used by all or many passes:
gen* also use these files to read and work with the machine
description RTL.
genconfig.
HARD_REG_SET, a bit-vector
with a bit for each hard register, and some macros to manipulate it.
This type is just int if the machine has few enough hard registers;
otherwise it is an array of int and some of the macros expand
into loops.
The configuration file `xm-machine.h' contains macro definitions that describe the machine and system on which the compiler is running, unlike the definitions in `machine.h', which describe the machine for which the compiler is producing output. Most of the values in `xm-machine.h' are actually the same on all machines that GNU CC runs on, so large parts of all configuration files are identical. But there are some macros that vary:
USG
VMS
FATAL_EXIT_CODE
SUCCESS_EXIT_CODE
HOST_WORDS_BIG_ENDIAN
HOST_FLOAT_WORDS_BIG_ENDIAN
DFmode,
XFmode or TFmode floating point numbers in memory with the
word containing the sign bit at the lowest address; otherwise, define it
to be zero.
This macro need not be defined if the ordering is the same as for
multi-word integers.
HOST_FLOAT_FORMAT
TARGET_FLOAT_FORMAT in section Storage Layout for the
alternatives and default.
HOST_BITS_PER_CHAR
char on the host
machine.
HOST_BITS_PER_SHORT
short on the host
machine.
HOST_BITS_PER_INT
int on the host
machine.
HOST_BITS_PER_LONG
long on the host
machine.
ONLY_INT_FIELDS
int bit fields, rather than other integral types, including
enum, as do most C compilers.
OBSTACK_CHUNK_SIZE
OBSTACK_CHUNK_ALLOC
xmalloc is used.
OBSTACK_CHUNK_FREE
free is used.
USE_C_ALLOCA
alloca implemented in C. This version of alloca can be
found in the file `alloca.c'; to use it, you must also alter the
`Makefile' variable ALLOCA. (This is done automatically
for the systems on which we know it is needed.)
If you do define this macro, you should probably do it as follows:
#ifndef __GNUC__ #define USE_C_ALLOCA #else #define alloca __builtin_alloca #endifso that when the compiler is compiled with GNU CC it uses the more efficient built-in
alloca function.
FUNCTION_CONVERSION_BUG
HAVE_VPRINTF
vprintf is available on your
system.
MULTIBYTE_CHARS
HAVE_PUTENV
putenv is available on your
system.
POSIX
NO_SYS_SIGLIST
sys_siglist.
DONT_DECLARE_SYS_SIGLIST
sys_siglist, and
there is already a declaration of it in the system header files.
USE_PROTOTYPES
NO_MD_PROTOTYPES
MD_CALL_PROTOTYPES
gen_call or gen_call_value functions generated from
the machine description file. If `USE_PROTOTYPES' is
defined to be 0, or the host compiler does not support
prototypes, or `NO_MD_PROTOTYPES' is defined, this macro has
no effect. As soon as all of the machine descriptions are
modified to have the appropriate number of arguments, this macro
will be removed.
Some systems do provide this variable, but with a different name such
as _sys_siglist. On these systems, you can define
sys_siglist as a macro which expands into the name actually
provided.
NO_STAB_H
PATH_SEPARATOR
DIR_SEPARATOR
OBJECT_SUFFIX
EXECUTABLE_SUFFIX
COLLECT_EXPORT_LIST
collect2 will scan the individual object files
specified on its command line and create an export list for the linker.
Define this macro for systems like AIX, where the linker discards
object files that are not referenced from main and uses export
lists.
In addition, configuration files for system V define bcopy,
bzero and bcmp as aliases. Some files define alloca
as a macro when compiled with GNU CC, in order to take advantage of the
benefit of GNU CC's built-in alloca.
When you configure GNU CC using the `configure' script (see section Installing GNU Pascal), it will construct the file `Makefile' from the template file `Makefile.in'. When it does this, it will incorporate makefile fragment files from the `config' directory, named `t-target' and `x-host'. If these files do not exist, it means nothing needs to be added for a given target or host.
The target makefile fragment, `t-target', defines special target dependent variables and targets used in the `Makefile':
LIBGCC1
CROSS_LIBGCC1
LIBGCC2_CFLAGS
LIB2FUNCS_EXTRA
CRTSTUFF_T_CFLAGS
MULTILIB_OPTIONS
MULTILIB_OPTIONS macro lists the set of options for which
special versions of `libgpc.a' must be built. Write options that
are mutually incompatible side by side, separated by a slash. Write
options that may be used together separated by a space. The build
procedure will build all combinations of compatible options.
For example, if you set MULTILIB_OPTIONS to `m68000/m68020
msoft-float', `Makefile' will build special versions of
`libgpc.a' using the options `-m68000', `-m68020',
`-msoft-float', `-m68000 -msoft-float', and `-m68020
-msoft-float'.
MULTILIB_DIRNAMES
MULTILIB_OPTIONS is used, this variable specifies the
directory names that should be used to hold the various libraries.
Write one element in MULTILIB_DIRNAMES for each element in
MULTILIB_OPTIONS. If MULTILIB_DIRNAMES is not used, the
default value will be MULTILIB_OPTIONS, with all slashes treated
as spaces.
For example, if MULTILIB_OPTIONS is `m68000/m68020
msoft-float', then the default value of MULTILIB_DIRNAMES is
`m68000 m68020 msoft-float'. You may specify a different value if
you desire a different set of directory names.
MULTILIB_MATCHES
MULTILIB_OPTIONS, GNU CC needs to know about
any synonyms. In that case, set MULTILIB_MATCHES to a list of
items of the form `option=option' to describe all relevant
synonyms. For example, `m68000=mc68000 m68020=mc68020'.
The host makefile fragment, `x-host', defines special host dependent variables and targets used in the `Makefile':
CC
CLIB
OLDCC
OLDAR
ar to use when building `libgpc1.a' for a native
compilation.
INSTALL
A machine description has two parts: a file of instruction patterns (`.md' file) and a C header file of macro definitions.
The `.md' file for a target machine contains a pattern for each instruction that the target machine supports (or at least each instruction that is worth telling the compiler about). It may also contain comments. A semicolon causes the rest of the line to be a comment, unless the semicolon is inside a quoted string.
See the next chapter for information on the C header file.
Each instruction pattern contains an incomplete RTL expression, with pieces
to be filled in later, operand constraints that restrict how the pieces can
be filled in, and an output pattern or C code to generate the assembler
output, all wrapped up in a define_insn expression.
A define_insn is an RTL expression containing four or five operands:
match_operand,
match_operator, and match_dup expressions that stand for
operands of the instruction.
If the vector has only one element, that element is the template for the
instruction pattern. If the vector has multiple elements, then the
instruction pattern is a parallel expression containing the
elements described.
operands.
define_insnHere is an actual example of an instruction pattern, for the 68000/68020.
(define_insn "tstsi"
[(set (cc0)
(match_operand:SI 0 "general_operand" "rm"))]
""
"*
{ if (TARGET_68020 || ! ADDRESS_REG_P (operands[0]))
return \"tstl %0\";
return \"cmpl #0,%0\"; }")
This is an instruction that sets the condition codes based on the value of
a general operand. It has no condition, so any insn whose RTL description
has the form shown may be handled according to this pattern. The name
`tstsi' means "test a SImode value" and tells the RTL generation
pass that, when it is necessary to test such a value, an insn to do so
can be constructed using this pattern.
The output control string is a piece of C code which chooses which output template to return based on the kind of operand and the specific type of CPU for which code is being generated.
`"rm"' is an operand constraint. Its meaning is explained below.
The RTL template is used to define which insns match the particular pattern and how to find their operands. For named patterns, the RTL template also says how to construct an insn from specified operands.
Construction involves substituting specified operands into a copy of the template. Matching involves determining the values that serve as the operands in the insn being matched. Both of these activities are controlled by special expression types that direct matching and substitution of the operands.
(match_operand:m n predicate constraint)
match_operand
expression in the pattern for each operand number. Usually operands
are numbered in the order of appearance in match_operand
expressions.
predicate is a string that is the name of a C function that accepts two
arguments, an expression and a machine mode. During matching, the
function will be called with the putative operand as the expression and
m as the mode argument (if m is not specified,
VOIDmode will be used, which normally causes predicate to accept
any mode). If it returns zero, this instruction pattern fails to match.
predicate may be an empty string; then it means no test is to be done
on the operand, so anything which occurs in this position is valid.
Most of the time, predicate will reject modes other than m---but
not always. For example, the predicate address_operand uses
m as the mode of memory ref that the address should be valid for.
Many predicates accept const_int nodes even though their mode is
VOIDmode.
constraint controls reloading and the choice of the best register
class to use for a value, as explained later (see section Operand Constraints).
People are often unclear on the difference between the constraint and the
predicate. The predicate helps decide whether a given insn matches the
pattern. The constraint plays no role in this decision; instead, it
controls various decisions in the case of an insn which does match.
On CISC machines, the most common predicate is
"general_operand". This function checks that the putative
operand is either a constant, a register or a memory reference, and that
it is valid for mode m.
For an operand that must be a register, predicate should be
"register_operand". Using "general_operand" would be
valid, since the reload pass would copy any non-register operands
through registers, but this would make GNU CC do extra work, it would
prevent invariant operands (such as constant) from being removed from
loops, and it would prevent the register allocator from doing the best
possible job. On RISC machines, it is usually most efficient to allow
predicate to accept only objects that the constraints allow.
For an operand that must be a constant, you must be sure to either use
"immediate_operand" for predicate, or make the instruction
pattern's extra condition require a constant, or both. You cannot
expect the constraints to do this work! If the constraints allow only
constants, but the predicate allows something else, the compiler will
crash when that case arises.
(match_scratch:m n constraint)
scratch or reg
expression.
When matching patterns, this is equivalent to
(match_operand:m n "scratch_operand" pred)but, when generating RTL, it produces a (
scratch:m)
expression.
If the last few expressions in a parallel are clobber
expressions whose operands are either a hard register or
match_scratch, the combiner can add or delete them when
necessary. See section Side Effect Expressions.
(match_dup n)
match_dup acts just like match_operand:
the operand is substituted into the insn being constructed. But in
matching, match_dup behaves differently. It assumes that operand
number n has already been determined by a match_operand
appearing earlier in the recognition template, and it matches only an
identical-looking expression.
(match_operator:m n predicate [operands...])
commutative_operator is defined as
follows, to match any expression whose operator is one of the
commutative arithmetic operators of RTL and whose mode is mode:
int
commutative_operator (x, mode)
rtx x;
enum machine_mode mode;
{
enum rtx_code code = GET_CODE (x);
if (GET_MODE (x) != mode)
return 0;
return (GET_RTX_CLASS (code) == 'c'
|| code == EQ || code == NE);
}
Then the following pattern will match any RTL expression consisting
of a commutative operator applied to two general operands:
(match_operator:SI 3 "commutative_operator" [(match_operand:SI 1 "general_operand" "g") (match_operand:SI 2 "general_operand" "g")])Here the vector
[operands...] contains two patterns
because the expressions to be matched all contain two operands.
When this pattern does match, the two operands of the commutative
operator are recorded as operands 1 and 2 of the insn. (This is done
by the two instances of match_operand.) Operand 3 of the insn
will be the entire commutative expression: use GET_CODE
(operands[3]) to see which commutative operator was used.
The machine mode m of match_operator works like that of
match_operand: it is passed as the second argument to the
predicate function, and that function is solely responsible for
deciding whether the expression to be matched "has" that mode.
When constructing an insn, argument 3 of the gen-function will specify
the operation (i.e. the expression code) for the expression to be
made. It should be an RTL expression, whose expression code is copied
into a new expression whose operands are arguments 1 and 2 of the
gen-function. The subexpressions of argument 3 are not used;
only its expression code matters.
When match_operator is used in a pattern for matching an insn,
it usually best if the operand number of the match_operator
is higher than that of the actual operands of the insn. This improves
register allocation because the register allocator often looks at
operands 1 and 2 of insns to see if it can do register tying.
There is no way to specify constraints in match_operator. The
operand of the insn which corresponds to the match_operator
never has any constraints because it is never reloaded as a whole.
However, if parts of its operands are matched by
match_operand patterns, those parts may have constraints of
their own.
(match_op_dup:m n[operands...])
match_dup, except that it applies to operators instead of
operands. When constructing an insn, operand number n will be
substituted at this point. But in matching, match_op_dup behaves
differently. It assumes that operand number n has already been
determined by a match_operator appearing earlier in the
recognition template, and it matches only an identical-looking
expression.
(match_parallel n predicate [subpat...])
parallel expression with a variable number of elements. This
expression should only appear at the top level of an insn pattern.
When constructing an insn, operand number n will be substituted at
this point. When matching an insn, it matches if the body of the insn
is a parallel expression with at least as many elements as the
vector of subpat expressions in the match_parallel, if each
subpat matches the corresponding element of the parallel,
and the function predicate returns nonzero on the
parallel that is the body of the insn. It is the responsibility
of the predicate to validate elements of the parallel beyond
those listed in the match_parallel.
A typical use of match_parallel is to match load and store
multiple expressions, which can contain a variable number of elements
in a parallel. For example,
(define_insn ""
[(match_parallel 0 "load_multiple_operation"
[(set (match_operand:SI 1 "gpc_reg_operand" "=r")
(match_operand:SI 2 "memory_operand" "m"))
(use (reg:SI 179))
(clobber (reg:SI 179))])]
""
"loadm 0,0,%1,%2")
This example comes from `a29k.md'. The function
load_multiple_operations is defined in `a29k.c' and checks
that subsequent elements in the parallel are the same as the
set in the pattern, except that they are referencing subsequent
registers and memory locations.
An insn that matches this pattern might look like:
(parallel
[(set (reg:SI 20) (mem:SI (reg:SI 100)))
(use (reg:SI 179))
(clobber (reg:SI 179))
(set (reg:SI 21)
(mem:SI (plus:SI (reg:SI 100)
(const_int 4))))
(set (reg:SI 22)
(mem:SI (plus:SI (reg:SI 100)
(const_int 8))))])
(match_par_dup n [subpat...])
match_op_dup, but for match_parallel instead of
match_operator.
(address (match_operand:m n "address_operand" ""))
address expressions never appear in RTL code, only in machine
descriptions. And they are used only in machine descriptions that do
not use the operand constraint feature. When operand constraints are
in use, the letter `p' in the constraint serves this purpose.
m is the machine mode of the memory location being
addressed, not the machine mode of the address itself. That mode is
always the same on a given target machine (it is Pmode, which
normally is SImode), so there is no point in mentioning it;
thus, no machine mode is written in the address expression. If
some day support is added for machines in which addresses of different
kinds of objects appear differently or are used differently (such as
the PDP-10), different formats would perhaps need different machine
modes and these modes might be written in the address
expression.
The output template is a string which specifies how to output the assembler code for an instruction pattern. Most of the template is a fixed string which is output literally. The character `%' is used to specify where to substitute an operand; it can also be used to identify places where different variants of the assembler require different syntax.
In the simplest case, a `%' followed by a digit n says to output operand n at that point in the string.
`%' followed by a letter and a digit says to output an operand in an
alternate fashion. Four letters have standard, built-in meanings described
below. The machine description macro PRINT_OPERAND can define
additional letters with nonstandard meanings.
`%cdigit' can be used to substitute an operand that is a constant value without the syntax that normally indicates an immediate operand.
`%ndigit' is like `%cdigit' except that the value of the constant is negated before printing.
`%adigit' can be used to substitute an operand as if it were a memory reference, with the actual operand treated as the address. This may be useful when outputting a "load address" instruction, because often the assembler syntax for such an instruction requires you to write the operand as if it were a memory reference.
`%ldigit' is used to substitute a label_ref into a jump
instruction.
`%=' outputs a number which is unique to each instruction in the entire compilation. This is useful for making local labels to be referred to more than once in a single template that generates multiple assembler instructions.
`%' followed by a punctuation character specifies a substitution that
does not use an operand. Only one case is standard: `%%' outputs a
`%' into the assembler code. Other nonstandard cases can be
defined in the PRINT_OPERAND macro. You must also define
which punctuation characters are valid with the
PRINT_OPERAND_PUNCT_VALID_P macro.
The template may generate multiple assembler instructions. Write the text for the instructions, with `\;' between them.
When the RTL contains two operands which are required by constraint to match each other, the output template must refer only to the lower-numbered operand. Matching operands are not always identical, and the rest of the compiler arranges to put the proper RTL expression for printing into the lower-numbered operand.
One use of nonstandard letters or punctuation following `%' is to
distinguish between different assembler languages for the same machine; for
example, Motorola syntax versus MIT syntax for the 68000. Motorola syntax
requires periods in most opcode names, while MIT syntax does not. For
example, the opcode `movel' in MIT syntax is `move.l' in Motorola
syntax. The same file of patterns is used for both kinds of output syntax,
but the character sequence `%.' is used in each place where Motorola
syntax wants a period. The PRINT_OPERAND macro for Motorola syntax
defines the sequence to output a period; the macro for MIT syntax defines
it to do nothing.
As a special case, a template consisting of the single character #
instructs the compiler to first split the insn, and then output the
resulting instructions separately. This helps eliminate redundancy in the
output templates. If you have a define_insn that needs to emit
multiple assembler instructions, and there is an matching define_split
already defined, then you can simply use # as the output template
instead of writing an output template that emits the multiple assembler
instructions.
If ASSEMBLER_DIALECT is defined, you can use
`{option0|option1|option2}' constructs in the templates. These
describe multiple variants of assembler language syntax.
See section Output of Assembler Instructions.
Often a single fixed template string cannot produce correct and efficient assembler code for all the cases that are recognized by a single instruction pattern. For example, the opcodes may depend on the kinds of operands; or some unfortunate combinations of operands may require extra machine instructions.
If the output control string starts with a `@', then it is actually a series of templates, each on a separate line. (Blank lines and leading spaces and tabs are ignored.) The templates correspond to the pattern's constraint alternatives (see section Multiple Alternative Constraints). For example, if a target machine has a two-address add instruction `addr' to add into a register and another `addm' to add a register to memory, you might write this pattern:
(define_insn "addsi3"
[(set (match_operand:SI 0 "general_operand" "=r,m")
(plus:SI (match_operand:SI 1 "general_operand" "0,0")
(match_operand:SI 2 "general_operand" "g,r")))]
""
"@
addr %2,%0
addm %2,%0")
If the output control string starts with a `*', then it is not an
output template but rather a piece of C program that should compute a
template. It should execute a return statement to return the
template-string you want. Most such templates use C string literals, which
require doublequote characters to delimit them. To include these
doublequote characters in the string, prefix each one with `\'.
The operands may be found in the array operands, whose C data type
is rtx [].
It is very common to select different ways of generating assembler code
based on whether an immediate operand is within a certain range. Be
careful when doing this, because the result of INTVAL is an
integer on the host machine. If the host machine has more bits in an
int than the target machine has in the mode in which the constant
will be used, then some of the bits you get from INTVAL will be
superfluous. For proper results, you must carefully disregard the
values of those bits.
It is possible to output an assembler instruction and then go on to output
or compute more of them, using the subroutine output_asm_insn. This
receives two arguments: a template-string and a vector of operands. The
vector may be operands, or it may be another array of rtx
that you declare locally and initialize yourself.
When an insn pattern has multiple alternatives in its constraints, often
the appearance of the assembler code is determined mostly by which alternative
was matched. When this is so, the C code can test the variable
which_alternative, which is the ordinal number of the alternative
that was actually satisfied (0 for the first, 1 for the second alternative,
etc.).
For example, suppose there are two opcodes for storing zero, `clrreg'
for registers and `clrmem' for memory locations. Here is how
a pattern could use which_alternative to choose between them:
(define_insn ""
[(set (match_operand:SI 0 "general_operand" "=r,m")
(const_int 0))]
""
"*
return (which_alternative == 0
? \"clrreg %0\" : \"clrmem %0\");
")
The example above, where the assembler code to generate was solely determined by the alternative, could also have been specified as follows, having the output control string start with a `@':
(define_insn ""
[(set (match_operand:SI 0 "general_operand" "=r,m")
(const_int 0))]
""
"@
clrreg %0
clrmem %0")
Each match_operand in an instruction pattern can specify a
constraint for the type of operands allowed.
Constraints can say whether
an operand may be in a register, and which kinds of register; whether the
operand can be a memory reference, and which kinds of address; whether the
operand may be an immediate constant, and which possible values it may
have. Constraints can also require two operands to match.
The simplest kind of constraint is a string full of letters, each of which describes one kind of operand that is permitted. Here are the letters that are allowed:
const_double) is
allowed, but only if the target floating point format is the same as
that of the host machine (on which the compiler is running).
const_double) is
allowed.
general_operand. This is normally used in the constraint of
a match_scratch when certain alternatives will not actually
require a scratch register.
addl #35,r12Matching constraints are used in these circumstances. More precisely, the two operands that match must include one input-only operand and one output-only operand. Moreover, the digit must be a smaller number than the number of the operand that uses it in the constraint. For operands to match in a particular case usually means that they are identical-looking RTL expressions. But in a few special cases specific kinds of dissimilarity are allowed. For example,
*x
as an input operand will match *x++ as an output operand.
For proper results in such cases, the output template should always
use the output-operand's number when printing the operand.
address_operand
as the predicate in the match_operand. This predicate interprets
the mode specified in the match_operand as the mode of the memory
reference for which the address would be valid.
EXTRA_CONSTRAINT is passed the
operand as its first argument and the constraint letter as its
second operand.
A typical use for this would be to distinguish certain types of
memory references that affect other insn operands.
Do not define these constraint letters to accept register references
(reg); the reload pass does not expect this and would not handle
it properly.
In order to have valid assembler code, each operand must satisfy its constraint. But a failure to do so does not prevent the pattern from applying to an insn. Instead, it directs the compiler to modify the code so that the constraint will be satisfied. Usually this is done by copying an operand into a register.
Contrast, therefore, the two instruction patterns that follow:
(define_insn ""
[(set (match_operand:SI 0 "general_operand" "=r")
(plus:SI (match_dup 0)
(match_operand:SI 1 "general_operand" "r")))]
""
"...")
which has two operands, one of which must appear in two places, and
(define_insn ""
[(set (match_operand:SI 0 "general_operand" "=r")
(plus:SI (match_operand:SI 1 "general_operand" "0")
(match_operand:SI 2 "general_operand" "r")))]
""
"...")
which has three operands, two of which are required by a constraint to be identical. If we are considering an insn of the form
(insn n prev next
(set (reg:SI 3)
(plus:SI (reg:SI 6) (reg:SI 109)))
...)
the first pattern would not apply at all, because this insn does not contain two identical subexpressions in the right place. The pattern would say, "That does not look like an add instruction; try other patterns." The second pattern would say, "Yes, that's an add instruction, but there is something wrong with it." It would direct the reload pass of the compiler to generate additional insns to make the constraint true. The results might look like this:
(insn n2 prev n
(set (reg:SI 3) (reg:SI 6))
...)
(insn n n2 next
(set (reg:SI 3)
(plus:SI (reg:SI 3) (reg:SI 109)))
...)
It is up to you to make sure that each operand, in each pattern, has constraints that can handle any RTL expression that could be present for that operand. (When multiple alternatives are in use, each pattern must, for each possible combination of operand expressions, have at least one alternative which can handle that combination of operands.) The constraints don't need to allow any possible operand--when this is the case, they do not constrain--but they must at least point the way to reloading any possible operand so that it will fit.
If the operand's predicate can recognize registers, but the constraint does not permit them, it can make the compiler crash. When this operand happens to be a register, the reload pass will be stymied, because it does not know how to copy a register temporarily into memory.
Sometimes a single instruction has multiple alternative sets of possible operands. For example, on the 68000, a logical-or instruction can combine register or an immediate value into memory, or it can combine any kind of operand into a register; but it cannot combine one memory location into another.
These constraints are represented as multiple alternatives. An alternative can be described by a series of letters for each operand. The overall constraint for an operand is made from the letters for this operand from the first alternative, a comma, the letters for this operand from the second alternative, a comma, and so on until the last alternative. Here is how it is done for fullword logical-or on the 68000:
(define_insn "iorsi3"
[(set (match_operand:SI 0 "general_operand" "=m,d")
(ior:SI (match_operand:SI 1 "general_operand" "%0,0")
(match_operand:SI 2 "general_operand" "dKs,dmKs")))]
...)
The first alternative has `m' (memory) for operand 0, `0' for operand 1 (meaning it must match operand 0), and `dKs' for operand 2. The second alternative has `d' (data register) for operand 0, `0' for operand 1, and `dmKs' for operand 2. The `=' and `%' in the constraints apply to all the alternatives; their meaning is explained in the next section (see section Register Class Preferences).
If all the operands fit any one alternative, the instruction is valid. Otherwise, for each alternative, the compiler counts how many instructions must be added to copy the operands so that that alternative applies. The alternative requiring the least copying is chosen. If two alternatives need the same amount of copying, the one that comes first is chosen. These choices can be altered with the `?' and `!' characters:
?
!
When an insn pattern has multiple alternatives in its constraints, often
the appearance of the assembler code is determined mostly by which
alternative was matched. When this is so, the C code for writing the
assembler code can use the variable which_alternative, which is
the ordinal number of the alternative that was actually satisfied (0 for
the first, 1 for the second alternative, etc.). See section C Statements for Assembler Output.
The operand constraints have another function: they enable the compiler to decide which kind of hardware register a pseudo register is best allocated to. The compiler examines the constraints that apply to the insns that use the pseudo register, looking for the machine-dependent letters such as `d' and `a' that specify classes of registers. The pseudo register is put in whichever class gets the most "votes". The constraint letters `g' and `r' also vote: they vote in favor of a general register. The machine description says which registers are considered general.
Of course, on some machines all registers are equivalent, and no register classes are defined. Then none of this complexity is relevant.
Here are constraint modifier characters.
(define_insn "addhi3"
[(set (match_operand:HI 0 "general_operand" "=m,r")
(plus:HI (match_operand:HI 1 "general_operand" "%0,0")
(match_operand:HI 2 "general_operand" "di,g")))]
...)
(define_insn "extendhisi2"
[(set (match_operand:SI 0 "general_operand" "=*d,a")
(sign_extend:SI
(match_operand:HI 1 "general_operand" "0,g")))]
...)
Whenever possible, you should use the general-purpose constraint letters
in asm arguments, since they will convey meaning more readily to
people reading your code. Failing that, use the constraint letters
that usually have very similar meanings across architectures. The most
commonly used constraints are `m' and `r' (for memory and
general-purpose registers respectively; see section Simple Constraints), and
`I', usually the letter indicating the most common
immediate-constant format.
For each machine architecture, the `config/machine.h' file
defines additional constraints. These constraints are used by the
compiler itself for instruction generation, as well as for asm
statements; therefore, some of the constraints are not particularly
interesting for asm. The constraints are defined through these
macros:
REG_CLASS_FROM_LETTER
CONST_OK_FOR_LETTER_P
CONST_DOUBLE_OK_FOR_LETTER_P
EXTRA_CONSTRAINT
Inspecting these macro definitions in the compiler source for your machine is the best way to be certain you have the right constraints. However, here is a summary of the machine-dependent constraints available on some particular machines.
f
F
G
I
J
K
L
M
Q
asm statements)
R
S
l
b
q
h
A
a
f
I
J
K
L
M
N
O
P
G
H
asm statements, use the machine
independent `E' or `F' instead)
b
f
h
q
c
l
x
y
I
J
K
L
M
N
O
P
G
Q
asm statements)
q
b, c, or d register
A
d register (for 64-bit ints)
f
t
u
a
b
c
d
D
S
I
J
K
L
M
lea instruction)
N
out instruction)
G
f
fp0 to fp3)
l
r0 to r15)
b
g0 to g15)
d
I
J
K
G
H
d
f
h
l
x
y
z
I
J
K
L
lui)
M
N
O
P
G
Q
asm statements)
R
asm statements)
S
asm statements)
a
d
f
x
y
I
J
K
L
G
H
f
I
J
K
sethi instruction)
G
H
Q
asm statements)
S
T
U
Some machines are so clean that operand constraints are not required. For example, on the Vax, an operand valid in one context is valid in any other context. On such a machine, every operand constraint would be `g', excepting only operands of "load address" instructions which are written as if they referred to a memory location's contents but actual refer to its address. They would have constraint `p'.
For such machines, instead of writing `g' and `p' for all
the constraints, you can choose to write a description with empty constraints.
Then you write `""' for the constraint in every match_operand.
Address operands are identified by writing an address expression
around the match_operand, not by their constraints.
When the machine description has just empty constraints, certain parts of compilation are skipped, making the compiler faster. However, few machines actually do not need constraints; all machine descriptions now in existence use constraints.
Here is a table of the instruction names that are meaningful in the RTL generation pass of the compiler. Giving one of these names to an instruction pattern tells the RTL generation pass that it can use the pattern in to accomplish a certain task.
subreg with mode m of a register whose
own mode is wider than m, the effect of this instruction is
to store the specified value in the part of the register that corresponds
to mode m. The effect on the rest of the register is undefined.
This class of patterns is special in several ways. First of all, each
of these names must be defined, because there is no other way
to copy a datum from one place to another.
Second, these patterns are not used solely in the RTL generation pass.
Even the reload pass can generate move insns to copy values from stack
slots into temporary registers. When it does so, one of the operands is
a hard register and the other is an operand that can need to be reloaded
into a register.
Therefore, when given such a pair of operands, the pattern must generate
RTL which needs no reloading and needs no temporary registers--no
registers other than the operands. For example, if you support the
pattern with a define_expand, then in such a case the
define_expand mustn't call force_reg or any other such
function which might generate new pseudo registers.
This requirement exists even for subword modes on a RISC machine where
fetching those modes from memory normally requires several insns and
some temporary registers. Look in `spur.md' to see how the
requirement can be satisfied.
During reload a memory reference with an invalid address may be passed
as an operand. Such an address will be replaced with a valid address
later in the reload pass. In this case, nothing may be done with the
address except to use it as it stands. If it is copied, it will not be
replaced with a valid address. No attempt should be made to make such
an address into a valid address and no routine (such as
change_address) that will do so may be called. Note that
general_operand will fail when applied to such an address.
The global variable reload_in_progress (which must be explicitly
declared if required) can be used to determine whether such special
handling is required.
The variety of operands that have reloads depends on the rest of the
machine description, but typically on a RISC machine these can only be
pseudo registers that did not get hard registers, while on other
machines explicit memory references will get optional reloads.
If a scratch register is required to move an object to or from memory,
it can be allocated using gen_reg_rtx prior to reload. But this
is impossible during and after reload. If there are cases needing
scratch registers after reload, you must define
SECONDARY_INPUT_RELOAD_CLASS and perhaps also
SECONDARY_OUTPUT_RELOAD_CLASS to detect them, and provide
patterns `reload_inm' or `reload_outm' to handle
them. See section Register Classes.
The constraints on a `movem' must permit moving any hard
register to any other hard register provided that
HARD_REGNO_MODE_OK permits mode m in both registers and
REGISTER_MOVE_COST applied to their classes returns a value of 2.
It is obligatory to support floating point `movem'
instructions into and out of any registers that can hold fixed point
values, because unions and structures (which have modes SImode or
DImode) can be in those registers and they may have floating
point members.
There may also be a need to support fixed point `movem'
instructions in and out of floating point registers. Unfortunately, I
have forgotten why this was so, and I don't know whether it is still
true. If HARD_REGNO_MODE_OK rejects fixed point values in
floating point registers, then the constraints of the fixed point
`movem' instructions must be designed to avoid ever trying to
reload into a floating point register.
SECONDARY_RELOAD_CLASS
macro in see section Register Classes.
subreg
with mode m of a register whose natural mode is wider,
the `movstrictm' instruction is guaranteed not to alter
any of the register except the part which belongs to mode m.
define_expand (see section Defining RTL Sequences for Code Generation)
and make the pattern fail if the restrictions are not met.
Write the generated insn as a parallel with elements being a
set of one register from the appropriate memory location (you may
also need use or clobber elements). Use a
match_parallel (see section RTL Template) to recognize the insn. See
`a29k.md' and `rs6000.md' for examples of the use of this insn
pattern.
HImode, and store
a SImode product in operand 0.
find_reg_note and look for a REG_UNUSED note on the
quotient or remainder and generate the appropriate instruction.
ashlm3 instructions.
sqrt built-in function of C always uses the mode which
corresponds to the C data type double.
ffs built-in function of C always uses the mode which
corresponds to the C data type int.
(set (cc0) (compare (match_operand:m 0 ...)
(match_operand:m 1 ...)))
(set (cc0) (match_operand:m 0 ...))`tstm' patterns should not be defined for machines that do not use
(cc0). Doing so would confuse the optimizer since it
would no longer be clear which set operations were comparisons.
The `cmpm' patterns should be used instead.
Pmode.
The number of bytes to move is the third operand, in mode m.
The fourth operand is the known shared alignment of the source and
destination, in the form of a const_int rtx. Thus, if the
compiler knows that both source and destination are word-aligned,
it may provide the value 4 for this operand.
These patterns need not give special consideration to the possibility
that the source and destination strings might overlap.
mem referring to the first character of the string,
operand 2 is the character to search for (normally zero),
and operand 3 is a constant describing the known alignment
of the beginning of the string.
word_mode.
Operand 1 may have mode byte_mode or word_mode; often
word_mode is allowed only for registers. Operands 2 and 3 must
be valid for word_mode.
The RTL generation pass generates this instruction only with constants
for operands 2 and 3.
The bit-field value is sign-extended to a full word integer
before it is stored in operand 0.
word_mode) into a bit
field in operand 0, where operand 1 specifies the width in bits and
operand 2 the starting bit. Operand 0 may have mode byte_mode or
word_mode; often word_mode is allowed only for registers.
Operands 1 and 2 must be valid for word_mode.
The RTL generation pass generates this instruction only with constants
for operands 1 and 2.
eq, lt or leu.
You specify the mode that the operand must have when you write the
match_operand expression. The compiler automatically sees
which mode you have used and supplies an operand of that mode.
The value stored for a true condition must have 1 as its low bit, or
else must be negative. Otherwise the instruction is not suitable and
you should omit it from the machine description. You describe to the
compiler exactly which value is stored by defining the macro
STORE_FLAG_VALUE (see section Miscellaneous Parameters). If a description cannot be
found that can be used for all the `scond' patterns, you
should omit those operations from the machine description.
These operations may fail, but should do so only in relatively
uncommon cases; if they would fail for common cases involving
integer comparisons, it is best to omit these patterns.
If these operations are omitted, the compiler will usually generate code
that copies the constant one to the target and branches around an
assignment of zero to the target. If this code is more efficient than
the potential instructions used for the `scond' pattern
followed by those required to convert the result into a 1 or a zero in
SImode, you should omit the `scond' operations from
the machine description.
label_ref that
refers to the label to jump to. Jump if the condition codes meet
condition cond.
Some machines do not follow the model assumed here where a comparison
instruction is followed by a conditional branch instruction. In that
case, the `cmpm' (and `tstm') patterns should
simply store the operands away and generate all the required insns in a
define_expand (see section Defining RTL Sequences for Code Generation) for the conditional
branch operations. All calls to expand `bcond' patterns are
immediately preceded by calls to expand either a `cmpm'
pattern or a `tstm' pattern.
Machines that use a pseudo register for the condition code value, or
where the mode used for the comparison depends on the condition being
tested, should also use the above mechanism. See section Defining Jump Instruction Patterns
The above discussion also applies to the `movmodecc' and
`scond' patterns.
SImode, except it is normally a const_int);
operand 2 is the number of registers used as operands.
On most machines, operand 2 is not actually stored into the RTL
pattern. It is supplied for the sake of some RISC machines which need
to put this information into the assembler code; they can put it in
the RTL instead of operand 1.
Operand 0 should be a mem RTX whose address is the address of the
function. Note, however, that this address can be a symbol_ref
expression even if it would not be a legitimate memory address on the
target machine. If it is also not a valid argument for a call
instruction, the pattern for this operation should be a
define_expand (see section Defining RTL Sequences for Code Generation) that places the
address into a register and uses that register in the call instruction.
BLKmode objects use the `call'
insn.
RETURN_POPS_ARGS is non-zero. They should emit a parallel
that contains both the function call and a set to indicate the
adjustment made to the frame pointer.
For machines where RETURN_POPS_ARGS can be non-zero, the use of these
patterns increases the number of functions for which the frame pointer
can be eliminated, if desired.
parallel
expression where each element is a set expression that indicates
the saving of a function return value into the result block.
This instruction pattern should be defined to support
__builtin_apply on machines where special instructions are needed
to call a subroutine with arbitrary arguments or to save the value
returned. This instruction pattern is required on machines that have
multiple registers that can hold a return value (i.e.
FUNCTION_VALUE_REGNO_P is true for more than one register).
reload_completed is non-zero and the function's
epilogue would only be a single instruction. For machines with register
windows, the routine leaf_function_p may be used to determine if
a register window push is required.
Machines that have conditional return instructions should define patterns
such as
(define_insn ""
[(set (pc)
(if_then_else (match_operator
0 "comparison_operator"
[(cc0) (const_int 0)])
(return)
(pc)))]
"condition"
"...")
where condition would normally be the same condition specified on the
named `return' pattern.
__builtin_return on machines where special
instructions are needed to return a value of any type.
Operand 0 is a memory location where the result of calling a function
with __builtin_apply is stored; operand 1 is a parallel
expression where each element is a set expression that indicates
the restoring of a function return value from the result block.
(const_int 0) will do as an
RTL pattern.
SImode.
CASE_DROPS_THROUGH is defined,
then an out-of-bounds index drops through to the code following
the jump table instead of jumping to this label. In that case,
this label is not actually used by the `casesi' instruction,
but it is always provided as an operand.)
addr_vec or addr_diff_vec inside of a
jump_insn. The number of elements in the table is one plus the
difference between the upper bound and the lower bound.
CASE_VECTOR_PC_RELATIVE is defined then the first operand is an
offset which counts from the address of the table; otherwise, it is an
absolute address to jump to. In either case, the first operand has
mode Pmode.
The `tablejump' insn is always the last insn before the jump
table it uses. Its assembler code normally has no need to use the
second operand, but you should incorporate it in the RTL pattern so
that the jump optimizer will not delete the table as unreachable code.
Pmode. Do not define these patterns on
such machines.
Some machines require special handling for stack pointer saves and
restores. On those machines, define the patterns corresponding to the
non-standard cases by using a define_expand (see section Defining RTL Sequences for Code Generation) that produces the required insns. The three types of
saves and restores are:
alloca. Only
the epilogue uses the restored stack pointer, allowing a simpler save or
restore sequence on some machines.
VOIDmode if no save area is needed for a particular type of save
(either because no save is needed or because a machine-specific save
area can be used). Operand 0 is the stack pointer and operand 1 is the
save area for restore operations. If `save_stack_block' is
defined, operand 0 must not be VOIDmode since these saves can be
arbitrarily nested.
A save area is a mem that is at a constant offset from
virtual_stack_vars_rtx when the stack pointer is saved for use by
nonlocal gotos and a reg in the other two cases.
STACK_GROWS_DOWNWARD is undefined) operand 0 from
the stack pointer to create space for dynamically allocated data.
Do not define this pattern if all that must be done is the subtraction.
Some machines require other operations such as stack probes or
maintaining the back chain. Define this pattern to emit those
operations in addition to updating the stack pointer.
Sometimes an insn can match more than one instruction pattern. Then the pattern that appears first in the machine description is the one used. Therefore, more specific patterns (patterns that will match fewer things) and faster instructions (those that will produce better code when they do match) should usually go first in the description.
In some cases the effect of ordering the patterns can be used to hide a pattern when it is not valid. For example, the 68000 has an instruction for converting a fullword to floating point and another for converting a byte to floating point. An instruction converting an integer to floating point could match either one. We put the pattern to convert the fullword first to make sure that one will be used rather than the other. (Otherwise a large integer might be generated as a single-byte immediate quantity, which would not work.) Instead of using this pattern ordering it would be possible to make the pattern for convert-a-byte smart enough to deal properly with any constant value.
Every machine description must have a named pattern for each of the conditional branch names `bcond'. The recognition template must always have the form
(set (pc)
(if_then_else (cond (cc0) (const_int 0))
(label_ref (match_operand 0 "" ""))
(pc)))
In addition, every machine description must have an anonymous pattern for each of the possible reverse-conditional branches. Their templates look like
(set (pc)
(if_then_else (cond (cc0) (const_int 0))
(pc)
(label_ref (match_operand 0 "" ""))))
They are necessary because jump optimization can turn direct-conditional branches into reverse-conditional branches.
It is often convenient to use the match_operator construct to
reduce the number of patterns that must be specified for branches. For
example,
(define_insn ""
[(set (pc)
(if_then_else (match_operator 0 "comparison_operator"
[(cc0) (const_int 0)])
(pc)
(label_ref (match_operand 1 "" ""))))]
"condition"
"...")
In some cases machines support instructions identical except for the machine mode of one or more operands. For example, there may be "sign-extend halfword" and "sign-extend byte" instructions whose patterns are
(set (match_operand:SI 0 ...)
(extend:SI (match_operand:HI 1 ...)))
(set (match_operand:SI 0 ...)
(extend:SI (match_operand:QI 1 ...)))
Constant integers do not specify a machine mode, so an instruction to
extend a constant value could match either pattern. The pattern it
actually will match is the one that appears first in the file. For correct
results, this must be the one for the widest possible mode (HImode,
here). If the pattern matches the QImode instruction, the results
will be incorrect if the constant value does not actually fit that mode.
Such instructions to extend constants are rarely generated because they are optimized away, but they do occasionally happen in nonoptimized compilations.
If a constraint in a pattern allows a constant, the reload pass may replace a register with a constant permitted by the constraint in some cases. Similarly for memory references. Because of this substitution, you should not provide separate patterns for increment and decrement instructions. Instead, they should be generated from the same pattern that supports register-register add insns by examining the operands and generating the appropriate machine instruction.
For most machines, GNU CC assumes that the machine has a condition code. A comparison insn sets the condition code, recording the results of both signed and unsigned comparison of the given operands. A separate branch insn tests the condition code and branches or not according its value. The branch insns come in distinct signed and unsigned flavors. Many common machines, such as the Vax, the 68000 and the 32000, work this way.
Some machines have distinct signed and unsigned compare instructions, and
only one set of conditional branch instructions. The easiest way to handle
these machines is to treat them just like the others until the final stage
where assembly code is written. At this time, when outputting code for the
compare instruction, peek ahead at the following branch using
next_cc0_user (insn). (The variable insn refers to the insn
being output, in the output-writing code in an instruction pattern.) If
the RTL says that is an unsigned branch, output an unsigned compare;
otherwise output a signed compare. When the branch itself is output, you
can treat signed and unsigned branches identically.
The reason you can do this is that GNU CC always generates a pair of
consecutive RTL insns, possibly separated by note insns, one to
set the condition code and one to test it, and keeps the pair inviolate
until the end.
To go with this technique, you must define the machine-description macro
NOTICE_UPDATE_CC to do CC_STATUS_INIT; in other words, no
compare instruction is superfluous.
Some machines have compare-and-branch instructions and no condition code. A similar technique works for them. When it is time to "output" a compare instruction, record its operands in two static variables. When outputting the branch-on-condition-code instruction that follows, actually output a compare-and-branch instruction that uses the remembered operands.
It also works to define patterns for compare-and-branch instructions. In optimizing compilation, the pair of compare and branch instructions will be combined according to these patterns. But this does not happen if optimization is not requested. So you must use one of the solutions above in addition to any special patterns you define.
In many RISC machines, most instructions do not affect the condition code and there may not even be a separate condition code register. On these machines, the restriction that the definition and use of the condition code be adjacent insns is not necessary and can prevent important optimizations. For example, on the IBM RS/6000, there is a delay for taken branches unless the condition code register is set three instructions earlier than the conditional branch. The instruction scheduler cannot perform this optimization if it is not permitted to separate the definition and use of the condition code register.
On these machines, do not use (cc0), but instead use a register
to represent the condition code. If there is a specific condition code
register in the machine, use a hard register. If the condition code or
comparison result can be placed in any general register, or if there are
multiple condition registers, use a pseudo register.
On some machines, the type of branch instruction generated may depend on
the way the condition code was produced; for example, on the 68k and
Sparc, setting the condition code directly from an add or subtract
instruction does not clear the overflow bit the way that a test
instruction does, so a different branch instruction must be used for
some conditional branches. For machines that use (cc0), the set
and use of the condition code must be adjacent (separated only by
note insns) allowing flags in cc_status to be used.
(See section Condition Code Status.) Also, the comparison and branch insns can be
located from each other by using the functions prev_cc0_setter
and next_cc0_user.
However, this is not true on machines that do not use (cc0). On
those machines, no assumptions can be made about the adjacency of the
compare and branch insns and the above methods cannot be used. Instead,
we use the machine mode of the condition code register to record
different formats of the condition code register.
Registers used to store the condition code value should have a mode that
is in class MODE_CC. Normally, it will be CCmode. If
additional modes are required (as for the add example mentioned above in
the Sparc), define the macro EXTRA_CC_MODES to list the
additional modes required (see section Condition Code Status). Also define
EXTRA_CC_NAMES to list the names of those modes and
SELECT_CC_MODE to choose a mode given an operand of a compare.
If it is known during RTL generation that a different mode will be required (for example, if the machine has separate compare instructions for signed and unsigned quantities, like most IBM processors), they can be specified at that time.
If the cases that require different modes would be made by instruction
combination, the macro SELECT_CC_MODE determines which machine
mode should be used for the comparison result. The patterns should be
written using that mode. To support the case of the add on the Sparc
discussed above, we have the pattern
(define_insn ""
[(set (reg:CC_NOOV 0)
(compare:CC_NOOV
(plus:SI (match_operand:SI 0 "register_operand" "%r")
(match_operand:SI 1 "arith_operand" "rI"))
(const_int 0)))]
""
"...")
The SELECT_CC_MODE macro on the Sparc returns CC_NOOVmode
for comparisons whose argument is a plus.
There are often cases where multiple RTL expressions could represent an operation performed by a single machine instruction. This situation is most commonly encountered with logical, branch, and multiply-accumulate instructions. In such cases, the compiler attempts to convert these multiple RTL expressions into a single canonical form to reduce the number of insn patterns required.
In addition to algebraic simplifications, following canonicalizations are performed:
neg, not,
mult, plus, or minus expression, it will be the
first operand.
compare operator, a constant is always the second operand
on machines where cc0 is used (see section Defining Jump Instruction Patterns). On other
machines, there are rare cases where the compiler might want to construct
a compare with a constant as the first operand. However, these
cases are not common enough for it to be worthwhile to provide a pattern
matching a constant as the first operand unless the machine actually has
such an instruction.
An operand of neg, not, mult, plus, or
minus is made the first operand under the same conditions as
above.
(minus x (const_int n)) is converted to
(plus x (const_int -n)).
mem), a left shift is
converted into the appropriate multiplication by a power of two.
De`Morgan's Law is used to move bitwise negation inside a bitwise
logical-and or logical-or operation. If this results in only one
operand being a not expression, it will be the first one.
A machine that has an instruction that performs a bitwise logical-and of one
operand with the bitwise negation of the other should specify the pattern
for that instruction as
(define_insn ""
[(set (match_operand:m 0 ...)
(and:m (not:m (match_operand:m 1 ...))
(match_operand:m 2 ...)))]
"..."
"...")
Similarly, a pattern for a "NAND" instruction should be written
(define_insn ""
[(set (match_operand:m 0 ...)
(ior:m (not:m (match_operand:m 1 ...))
(not:m (match_operand:m 2 ...))))]
"..."
"...")
In both cases, it is not necessary to include patterns for the many
logically equivalent RTL expressions.
(xor:m x y)
and (not:m (xor:m x y)).
(plus:m (plus:m x y) constant)
cc0,
(compare x (const_int 0)) will be converted to
x.
zero_extract rather than the equivalent
and or sign_extract operations.
In addition to instruction patterns the `md' file may contain definitions of machine-specific peephole optimizations.
The combiner does not notice certain peephole optimizations when the data flow in the program does not suggest that it should try them. For example, sometimes two consecutive insns related in purpose can be combined even though the second one does not appear to use a register computed in the first one. A machine-specific peephole optimizer can detect such opportunities.
A definition looks like this:
(define_peephole [insn-pattern-1 insn-pattern-2 ...] "condition" "template" "optional insn-attributes")
The last string operand may be omitted if you are not using any
machine-specific information in this machine description. If present,
it must obey the same rules as in a define_insn.
In this skeleton, insn-pattern-1 and so on are patterns to match consecutive insns. The optimization applies to a sequence of insns when insn-pattern-1 matches the first one, insn-pattern-2 matches the next, and so on.
Each of the insns matched by a peephole must also match a
define_insn. Peepholes are checked only at the last stage just
before code generation, and only optionally. Therefore, any insn which
would match a peephole but no define_insn will cause a crash in code
generation in an unoptimized compilation, or at various optimization
stages.
The operands of the insns are matched with match_operands,
match_operator, and match_dup, as usual. What is not
usual is that the operand numbers apply to all the insn patterns in the
definition. So, you can check for identical operands in two insns by
using match_operand in one insn and match_dup in the
other.
The operand constraints used in match_operand patterns do not have
any direct effect on the applicability of the peephole, but they will
be validated afterward, so make sure your constraints are general enough
to apply whenever the peephole matches. If the peephole matches
but the constraints are not satisfied, the compiler will crash.
It is safe to omit constraints in all the operands of the peephole; or you can write constraints which serve as a double-check on the criteria previously tested.
Once a sequence of insns matches the patterns, the condition is checked. This is a C expression which makes the final decision whether to perform the optimization (we do so if the expression is nonzero). If condition is omitted (in other words, the string is empty) then the optimization is applied to every sequence of insns that matches the patterns.
The defined peephole optimizations are applied after register allocation is complete. Therefore, the peephole definition can check which operands have ended up in which kinds of registers, just by looking at the operands.
The way to refer to the operands in condition is to write
operands[i] for operand number i (as matched by
(match_operand i ...)). Use the variable insn
to refer to the last of the insns being matched; use
prev_active_insn to find the preceding insns.
When optimizing computations with intermediate results, you can use
condition to match only when the intermediate results are not used
elsewhere. Use the C expression dead_or_set_p (insn,
op), where insn is the insn in which you expect the value
to be used for the last time (from the value of insn, together
with use of prev_nonnote_insn), and op is the intermediate
value (from operands[i]).
Applying the optimization means replacing the sequence of insns with one
new insn. The template controls ultimate output of assembler code
for this combined insn. It works exactly like the template of a
define_insn. Operand numbers in this template are the same ones
used in matching the original sequence of insns.
The result of a defined peephole optimizer does not need to match any of the insn patterns in the machine description; it does not even have an opportunity to match them. The peephole optimizer definition itself serves as the insn pattern to control how the insn is output.
Defined peephole optimizers are run as assembler code is being output, so the insns they produce are never combined or rearranged in any way.
Here is an example, taken from the 68000 machine description:
(define_peephole
[(set (reg:SI 15) (plus:SI (reg:SI 15) (const_int 4)))
(set (match_operand:DF 0 "register_operand" "=f")
(match_operand:DF 1 "register_operand" "ad"))]
"FP_REG_P (operands[0]) && ! FP_REG_P (operands[1])"
"*
{
rtx xoperands[2];
xoperands[1] = gen_rtx (REG, SImode, REGNO (operands[1]) + 1);
#ifdef MOTOROLA
output_asm_insn (\"move.l %1,(sp)\", xoperands);
output_asm_insn (\"move.l %1,-(sp)\", operands);
return \"fmove.d (sp)+,%0\";
#else
output_asm_insn (\"movel %1,sp@\", xoperands);
output_asm_insn (\"movel %1,sp@-\", operands);
return \"fmoved sp@+,%0\";
#endif
}
")
The effect of this optimization is to change
jbsr _foobar addql #4,sp movel d1,sp@- movel d0,sp@- fmoved sp@+,fp0
into
jbsr _foobar movel d1,sp@ movel d0,sp@- fmoved sp@+,fp0
insn-pattern-1 and so on look almost like the second
operand of define_insn. There is one important difference: the
second operand of define_insn consists of one or more RTX's
enclosed in square brackets. Usually, there is only one: then the same
action can be written as an element of a define_peephole. But
when there are multiple actions in a define_insn, they are
implicitly enclosed in a parallel. Then you must explicitly
write the parallel, and the square brackets within it, in the
define_peephole. Thus, if an insn pattern looks like this,
(define_insn "divmodsi4"
[(set (match_operand:SI 0 "general_operand" "=d")
(div:SI (match_operand:SI 1 "general_operand" "0")
(match_operand:SI 2 "general_operand" "dmsK")))
(set (match_operand:SI 3 "general_operand" "=d")
(mod:SI (match_dup 1) (match_dup 2)))]
"TARGET_68020"
"divsl%.l %2,%3:%0")
then the way to mention this insn in a peephole is as follows:
(define_peephole
[...
(parallel
[(set (match_operand:SI 0 "general_operand" "=d")
(div:SI (match_operand:SI 1 "general_operand" "0")
(match_operand:SI 2 "general_operand" "dmsK")))
(set (match_operand:SI 3 "general_operand" "=d")
(mod:SI (match_dup 1) (match_dup 2)))])
...]
...)
On some target machines, some standard pattern names for RTL generation
cannot be handled with single insn, but a sequence of RTL insns can
represent them. For these target machines, you can write a
define_expand to specify how to generate the sequence of RTL.
A define_expand is an RTL expression that looks almost like a
define_insn; but, unlike the latter, a define_expand is used
only for RTL generation and it can produce more than one RTL insn.
A define_expand RTX has four operands:
define_expand must have a name, since the only
use for it is to refer to it by name.
define_peephole in that it is a vector of RTL expressions
each being one insn.
define_insn that
has a standard name. Therefore, the condition (if present) may not
depend on the data in the insn being matched, but only the
target-machine-type flags. The compiler needs to test these conditions
during initialization in order to learn exactly which named instructions
are available in a particular run.
emit_insn, etc.
Any such insns precede the ones that come from the RTL template.
Every RTL insn emitted by a define_expand must match some
define_insn in the machine description. Otherwise, the compiler
will crash when trying to generate code for the insn or trying to optimize
it.
The RTL template, in addition to controlling generation of RTL insns, also describes the operands that need to be specified when this pattern is used. In particular, it gives a predicate for each operand.
A true operand, which needs to be specified in order to generate RTL from
the pattern, should be described with a match_operand in its first
occurrence in the RTL template. This enters information on the operand's
predicate into the tables that record such things. GNU CC uses the
information to preload the operand into a register if that is required for
valid RTL code. If the operand is referred to more than once, subsequent
references should use match_dup.
The RTL template may also refer to internal "operands" which are
temporary registers or labels used only within the sequence made by the
define_expand. Internal operands are substituted into the RTL
template with match_dup, never with match_operand. The
values of the internal operands are not passed in as arguments by the
compiler when it requests use of this pattern. Instead, they are computed
within the pattern, in the preparation statements. These statements
compute the values and store them into the appropriate elements of
operands so that match_dup can find them.
There are two special macros defined for use in the preparation statements:
DONE and FAIL. Use them with a following semicolon,
as a statement.
DONE
DONE macro to end RTL generation for the pattern. The
only RTL insns resulting from the pattern on this occasion will be
those already emitted by explicit calls to emit_insn within the
preparation statements; the RTL template will not be generated.
FAIL
extv, extzv, and insv)
operations.
Here is an example, the definition of left-shift for the SPUR chip:
(define_expand "ashlsi3"
[(set (match_operand:SI 0 "register_operand" "")
(ashift:SI
(match_operand:SI 1 "register_operand" "")
(match_operand:SI 2 "nonmemory_operand" "")))]
""
"
{
if (GET_CODE (operands[2]) != CONST_INT
|| (unsigned) INTVAL (operands[2]) > 3)
FAIL;
}")
This example uses define_expand so that it can generate an RTL insn
for shifting when the shift-count is in the supported range of 0 to 3 but
fail in other cases where machine insns aren't available. When it fails,
the compiler tries another strategy using different patterns (such as, a
library call).
If the compiler were able to handle nontrivial condition-strings in
patterns with names, then it would be possible to use a
define_insn in that case. Here is another case (zero-extension
on the 68000) which makes more use of the power of define_expand:
(define_expand "zero_extendhisi2"
[(set (match_operand:SI 0 "general_operand" "")
(const_int 0))
(set (strict_low_part
(subreg:HI
(match_dup 0)
0))
(match_operand:HI 1 "general_operand" ""))]
""
"operands[1] = make_safe_from (operands[1], operands[0]);")
Here two RTL insns are generated, one to clear the entire output operand
and the other to copy the input operand into its low half. This sequence
is incorrect if the input operand refers to [the old value of] the output
operand, so the preparation statement makes sure this isn't so. The
function make_safe_from copies the operands[1] into a
temporary register if it refers to operands[0]. It does this
by emitting another RTL insn.
Finally, a third example shows the use of an internal operand.
Zero-extension on the SPUR chip is done by and-ing the result
against a halfword mask. But this mask cannot be represented by a
const_int because the constant value is too large to be legitimate
on this machine. So it must be copied into a register with
force_reg and then the register used in the and.
(define_expand "zero_extendhisi2"
[(set (match_operand:SI 0 "register_operand" "")
(and:SI (subreg:SI
(match_operand:HI 1 "register_operand" "")
0)
(match_dup 2)))]
""
"operands[2]
= force_reg (SImode, gen_rtx (CONST_INT,
VOIDmode, 65535)); ")
Note: If the define_expand is used to serve a
standard binary or unary arithmetic operation or a bitfield operation,
then the last insn it generates must not be a code_label,
barrier or note. It must be an insn,
jump_insn or call_insn. If you don't need a real insn
at the end, emit an insn to copy the result of the operation into
itself. Such an insn will generate no code, but it can avoid problems
in the compiler.
There are two cases where you should specify how to split a pattern into multiple insns. On machines that have instructions requiring delay slots (see section Delay Slot Scheduling) or that have instructions whose output is not available for multiple cycles (see section Specifying Function Units), the compiler phases that optimize these cases need to be able to move insns into one-instruction delay slots. However, some insns may generate more than one machine instruction. These insns cannot be placed into a delay slot.
Often you can rewrite the single insn as a list of individual insns, each corresponding to one machine instruction. The disadvantage of doing so is that it will cause the compilation to be slower and require more space. If the resulting insns are too complex, it may also suppress some optimizations. The compiler splits the insn if there is a reason to believe that it might improve instruction or delay slot scheduling.
The insn combiner phase also splits putative insns. If three insns are
merged into one insn with a complex expression that cannot be matched by
some define_insn pattern, the combiner phase attempts to split
the complex pattern into two insns that are recognized. Usually it can
break the complex pattern into two patterns by splitting out some
subexpression. However, in some other cases, such as performing an
addition of a large constant in two insns on a RISC machine, the way to
split the addition into two insns is machine-dependent.
The define_split definition tells the compiler how to split a
complex insn into several simpler insns. It looks like this:
(define_split [insn-pattern] "condition" [new-insn-pattern-1 new-insn-pattern-2 ...] "preparation statements")
insn-pattern is a pattern that needs to be split and
condition is the final condition to be tested, as in a
define_insn. When an insn matching insn-pattern and
satisfying condition is found, it is replaced in the insn list
with the insns given by new-insn-pattern-1,
new-insn-pattern-2, etc.
The preparation statements are similar to those statements that
are specified for define_expand (see section Defining RTL Sequences for Code Generation)
and are executed before the new RTL is generated to prepare for the
generated code or emit some insns whose pattern is not fixed. Unlike
those in define_expand, however, these statements must not
generate any new pseudo-registers. Once reload has completed, they also
must not allocate any space in the stack frame.
Patterns are matched against insn-pattern in two different
circumstances. If an insn needs to be split for delay slot scheduling
or insn scheduling, the insn is already known to be valid, which means
that it must have been matched by some define_insn and, if
reload_completed is non-zero, is known to satisfy the constraints
of that define_insn. In that case, the new insn patterns must
also be insns that are matched by some define_insn and, if
reload_completed is non-zero, must also satisfy the constraints
of those definitions.
As an example of this usage of define_split, consider the following
example from `a29k.md', which splits a sign_extend from
HImode to SImode into a pair of shift insns:
(define_split
[(set (match_operand:SI 0 "gen_reg_operand" "")
(sign_extend:SI (match_operand:HI 1 "gen_reg_operand" "")))]
""
[(set (match_dup 0)
(ashift:SI (match_dup 1)
(const_int 16)))
(set (match_dup 0)
(ashiftrt:SI (match_dup 0)
(const_int 16)))]
"
{ operands[1] = gen_lowpart (SImode, operands[1]); }")
When the combiner phase tries to split an insn pattern, it is always the
case that the pattern is not matched by any define_insn.
The combiner pass first tries to split a single set expression
and then the same set expression inside a parallel, but
followed by a clobber of a pseudo-reg to use as a scratch
register. In these cases, the combiner expects exactly two new insn
patterns to be generated. It will verify that these patterns match some
define_insn definitions, so you need not do this test in the
define_split (of course, there is no point in writing a
define_split that will never produce insns that match).
Here is an example of this use of define_split, taken from
`rs6000.md':
(define_split
[(set (match_operand:SI 0 "gen_reg_operand" "")
(plus:SI (match_operand:SI 1 "gen_reg_operand" "")
(match_operand:SI 2 "non_add_cint_operand" "")))]
""
[(set (match_dup 0) (plus:SI (match_dup 1) (match_dup 3)))
(set (match_dup 0) (plus:SI (match_dup 0) (match_dup 4)))]
"
{
int low = INTVAL (operands[2]) & 0xffff;
int high = (unsigned) INTVAL (operands[2]) >> 16;
if (low & 0x8000)
high++, low |= 0xffff0000;
operands[3] = gen_rtx (CONST_INT, VOIDmode, high << 16);
operands[4] = gen_rtx (CONST_INT, VOIDmode, low);
}")
Here the predicate non_add_cint_operand matches any
const_int that is not a valid operand of a single add
insn. The add with the smaller displacement is written so that it
can be substituted into the address of a subsequent operation.
An example that uses a scratch register, from the same file, generates an equality comparison of a register and a large constant:
(define_split
[(set (match_operand:CC 0 "cc_reg_operand" "")
(compare:CC (match_operand:SI 1 "gen_reg_operand" "")
(match_operand:SI 2 "non_short_cint_operand" "")))
(clobber (match_operand:SI 3 "gen_reg_operand" ""))]
"find_single_use (operands[0], insn, 0)
&& (GET_CODE (*find_single_use (operands[0], insn, 0)) == EQ
|| GET_CODE (*find_single_use (operands[0], insn, 0)) == NE)"
[(set (match_dup 3) (xor:SI (match_dup 1) (match_dup 4)))
(set (match_dup 0) (compare:CC (match_dup 3) (match_dup 5)))]
"
{
/* Get the constant we are comparing against, C, and see what it
looks like sign-extended to 16 bits. Then see what constant
could be XOR'ed with C to get the sign-extended value. */
int c = INTVAL (operands[2]);
int sextc = (c << 16) >> 16;
int xorv = c ^ sextc;
operands[4] = gen_rtx (CONST_INT, VOIDmode, xorv);
operands[5] = gen_rtx (CONST_INT, VOIDmode, sextc);
}")
To avoid confusion, don't write a single define_split that
accepts some insns that match some define_insn as well as some
insns that don't. Instead, write two separate define_split
definitions, one for the insns that are valid and one for the insns that
are not valid.
In addition to describing the instruction supported by the target machine,
the `md' file also defines a group of attributes and a set of
values for each. Every generated insn is assigned a value for each attribute.
One possible attribute would be the effect that the insn has on the machine's
condition code. This attribute can then be used by NOTICE_UPDATE_CC
to track the condition codes.
The define_attr expression is used to define each attribute required
by the target machine. It looks like:
(define_attr name list-of-values default)
name is a string specifying the name of the attribute being defined.
list-of-values is either a string that specifies a comma-separated list of values that can be assigned to the attribute, or a null string to indicate that the attribute takes numeric values.
default is an attribute expression that gives the value of this attribute for insns that match patterns whose definition does not include an explicit value for this attribute. See section Example of Attribute Specifications, for more information on the handling of defaults. See section Constant Attributes, for information on attributes that do not depend on any particular insn.
For each defined attribute, a number of definitions are written to the `insn-attr.h' file. For cases where an explicit set of values is specified for an attribute, the following are defined:
For example, if the following is present in the `md' file:
(define_attr "type" "branch,fp,load,store,arith" ...)
the following lines will be written to the file `insn-attr.h'.
#define HAVE_ATTR_type
enum attr_type {TYPE_BRANCH, TYPE_FP, TYPE_LOAD,
TYPE_STORE, TYPE_ARITH};
extern enum attr_type get_attr_type ();
If the attribute takes numeric values, no enum type will be
defined and the function to obtain the attribute's value will return
int.
RTL expressions used to define attributes use the codes described above plus a few specific to attribute definitions, to be discussed below. Attribute value expressions must have one of the following forms:
(const_int i)
const_int or as an integer represented as a string in
const_string, eq_attr (see below), and set_attr
(see section Assigning Attribute Values to Insns) expressions.
(const_string value)
define_attr.
If the attribute whose value is being specified is numeric, value
must be a string containing a non-negative integer (normally
const_int would be used in this case). Otherwise, it must
contain one of the valid values for the attribute.
(if_then_else test true-value false-value)
(cond [test1 value1 ...] default)
cond expression is that of the
value corresponding to the first true test expression. If
none of the test expressions are true, the value of the cond
expression is that of the default expression.
test expressions can have one of the following forms:
(const_int i)
(not test)
(ior test1 test2)
(and test1 test2)
(match_operand:m n pred constraints)
VOIDmode) and the function specified by the string
pred returns a non-zero value when passed operand n and mode
m (this part of the test is ignored if pred is the null
string).
The constraints operand is ignored and should be the null string.
(le arith1 arith2)
(leu arith1 arith2)
(lt arith1 arith2)
(ltu arith1 arith2)
(gt arith1 arith2)
(gtu arith1 arith2)
(ge arith1 arith2)
(geu arith1 arith2)
(ne arith1 arith2)
(eq arith1 arith2)
plus, minus, mult, div, mod,
abs, neg, and, ior, xor, not,
ashift, lshiftrt, and ashiftrt expressions.
const_int and symbol_ref are always valid terms (see section Computing the Length of an Insn,for additional forms). symbol_ref is a string
denoting a C expression that yields an int when evaluated by the
`get_attr_...' routine. It should normally be a global
variable.
(eq_attr name value)
(eq_attr "type" "load,store")is equivalent to
(ior (eq_attr "type" "load") (eq_attr "type" "store"))If name specifies an attribute of `alternative', it refers to the value of the compiler variable
which_alternative
(see section C Statements for Assembler Output) and the values must be small integers. For
example,
(eq_attr "alternative" "2,3")is equivalent to
(ior (eq (symbol_ref "which_alternative") (const_int 2))
(eq (symbol_ref "which_alternative") (const_int 3)))
Note that, for most attributes, an eq_attr test is simplified in cases
where the value of the attribute being tested is known for all insns matching
a particular pattern. This is by far the most common case.
(attr_flag name)
attr_flag expression is true if the flag
specified by name is true for the insn currently being
scheduled.
name is a string specifying one of a fixed set of flags to test.
Test the flags forward and backward to determine the
direction of a conditional branch. Test the flags very_likely,
likely, very_unlikely, and unlikely to determine
if a conditional branch is expected to be taken.
If the very_likely flag is true, then the likely flag is also
true. Likewise for the very_unlikely and unlikely flags.
This example describes a conditional branch delay slot which
can be nullified for forward branches that are taken (annul-true) or
for backward branches which are not taken (annul-false).
(define_delay (eq_attr "type" "cbranch")
[(eq_attr "in_branch_delay" "true")
(and (eq_attr "in_branch_delay" "true")
(attr_flag "forward"))
(and (eq_attr "in_branch_delay" "true")
(attr_flag "backward"))])
The forward and backward flags are false if the current
insn being scheduled is not a conditional branch.
The very_likely and likely flags are true if the
insn being scheduled is not a conditional branch. The
The very_unlikely and unlikely flags are false if the
insn being scheduled is not a conditional branch.
attr_flag is only used during delay slot scheduling and has no
meaning to other passes of the compiler.
The value assigned to an attribute of an insn is primarily determined by
which pattern is matched by that insn (or which define_peephole
generated it). Every define_insn and define_peephole can
have an optional last argument to specify the values of attributes for
matching insns. The value of any attribute not specified in a particular
insn is set to the default value for that attribute, as specified in its
define_attr. Extensive use of default values for attributes
permits the specification of the values for only one or two attributes
in the definition of most insn patterns, as seen in the example in the
next section.
The optional last argument of define_insn and
define_peephole is a vector of expressions, each of which defines
the value for a single attribute. The most general way of assigning an
attribute's value is to use a set expression whose first operand is an
attr expression giving the name of the attribute being set. The
second operand of the set is an attribute expression
(see section Attribute Expressions) giving the value of the attribute.
When the attribute value depends on the `alternative' attribute
(i.e., which is the applicable alternative in the constraint of the
insn), the set_attr_alternative expression can be used. It
allows the specification of a vector of attribute expressions, one for
each alternative.
When the generality of arbitrary attribute expressions is not required,
the simpler set_attr expression can be used, which allows
specifying a string giving either a single attribute value or a list
of attribute values, one for each alternative.
The form of each of the above specifications is shown below. In each case, name is a string specifying the attribute to be set.
(set_attr name value-string)
(set_attr_alternative name [value1 value2 ...])
cond with
tests on the `alternative' attribute.
(set (attr name) value)
set must be the special RTL expression
attr, whose sole operand is a string giving the name of the
attribute being set. value is the value of the attribute.
The following shows three different ways of representing the same attribute value specification:
(set_attr "type" "load,store,arith")
(set_attr_alternative "type"
[(const_string "load") (const_string "store")
(const_string "arith")])
(set (attr "type")
(cond [(eq_attr "alternative" "1") (const_string "load")
(eq_attr "alternative" "2") (const_string "store")]
(const_string "arith")))
The define_asm_attributes expression provides a mechanism to
specify the attributes assigned to insns produced from an asm
statement. It has the form:
(define_asm_attributes [attr-sets])
where attr-sets is specified the same as for both the
define_insn and the define_peephole expressions.
These values will typically be the "worst case" attribute values. For example, they might indicate that the condition code will be clobbered.
A specification for a length attribute is handled specially. The
way to compute the length of an asm insn is to multiply the
length specified in the expression define_asm_attributes by the
number of machine instructions specified in the asm statement,
determined by counting the number of semicolons and newlines in the
string. Therefore, the value of the length attribute specified
in a define_asm_attributes should be the maximum possible length
of a single machine instruction.
The judicious use of defaulting is important in the efficient use of
insn attributes. Typically, insns are divided into types and an
attribute, customarily called type, is used to represent this
value. This attribute is normally used only to define the default value
for other attributes. An example will clarify this usage.
Assume we have a RISC machine with a condition code and in which only full-word operations are performed in registers. Let us assume that we can divide all insns into loads, stores, (integer) arithmetic operations, floating point operations, and branches.
Here we will concern ourselves with determining the effect of an insn on the condition code and will limit ourselves to the following possible effects: The condition code can be set unpredictably (clobbered), not be changed, be set to agree with the results of the operation, or only changed if the item previously set into the condition code has been modified.
Here is part of a sample `md' file for such a machine:
(define_attr "type" "load,store,arith,fp,branch" (const_string "arith"))
(define_attr "cc" "clobber,unchanged,set,change0"
(cond [(eq_attr "type" "load")
(const_string "change0")
(eq_attr "type" "store,branch")
(const_string "unchanged")
(eq_attr "type" "arith")
(if_then_else (match_operand:SI 0 "" "")
(const_string "set")
(const_string "clobber"))]
(const_string "clobber")))
(define_insn ""
[(set (match_operand:SI 0 "general_operand" "=r,r,m")
(match_operand:SI 1 "general_operand" "r,m,r"))]
""
"@
move %0,%1
load %0,%1
store %0,%1"
[(set_attr "type" "arith,load,store")])
Note that we assume in the above example that arithmetic operations performed on quantities smaller than a machine word clobber the condition code since they will set the condition code to a value corresponding to the full-word result.
For many machines, multiple types of branch instructions are provided, each
for different length branch displacements. In most cases, the assembler
will choose the correct instruction to use. However, when the assembler
cannot do so, GCC can when a special attribute, the `length'
attribute, is defined. This attribute must be defined to have numeric
values by specifying a null string in its define_attr.
In the case of the `length' attribute, two additional forms of arithmetic terms are allowed in test expressions:
(match_dup n)
label_ref.
(pc)
For normal insns, the length will be determined by value of the
`length' attribute. In the case of addr_vec and
addr_diff_vec insn patterns, the length is computed as
the number of vectors multiplied by the size of each vector.
Lengths are measured in addressable storage units (bytes).
The following macros can be used to refine the length computation:
FIRST_INSN_ADDRESS
length insn attribute is used, this macro specifies the
value to be assigned to the address of the first insn in a function. If
not specified, 0 is used.
ADJUST_INSN_LENGTH (insn, length)
addr_vec
insn must be increased by two to compensate for the fact that alignment
may be required.
The routine that returns get_attr_length (the value of the
length attribute) can be used by the output routine to
determine the form of the branch instruction to be written, as the
example below illustrates.
As an example of the specification of variable-length branches, consider the IBM 360. If we adopt the convention that a register will be set to the starting address of a function, we can jump to labels within 4k of the start using a four-byte instruction. Otherwise, we need a six-byte sequence to load the address from memory and then branch to it.
On such a machine, a pattern for a branch instruction might be specified as follows:
(define_insn "jump"
[(set (pc)
(label_ref (match_operand 0 "" "")))]
""
"*
{
return (get_attr_length (insn) == 4
? \"b %l0\" : \"l r15,=a(%l0); br r15\");
}"
[(set (attr "length") (if_then_else (lt (match_dup 0) (const_int 4096))
(const_int 4)
(const_int 6)))])
A special form of define_attr, where the expression for the
default value is a const expression, indicates an attribute that
is constant for a given run of the compiler. Constant attributes may be
used to specify which variety of processor is used. For example,
(define_attr "cpu" "m88100,m88110,m88000"
(const
(cond [(symbol_ref "TARGET_88100") (const_string "m88100")
(symbol_ref "TARGET_88110") (const_string "m88110")]
(const_string "m88000"))))
(define_attr "memory" "fast,slow"
(const
(if_then_else (symbol_ref "TARGET_FAST_MEM")
(const_string "fast")
(const_string "slow"))))
The routine generated for constant attributes has no parameters as it
does not depend on any particular insn. RTL expressions used to define
the value of a constant attribute may use the symbol_ref form,
but may not use either the match_operand form or eq_attr
forms involving insn attributes.
The insn attribute mechanism can be used to specify the requirements for delay slots, if any, on a target machine. An instruction is said to require a delay slot if some instructions that are physically after the instruction are executed as if they were located before it. Classic examples are branch and call instructions, which often execute the following instruction before the branch or call is performed.
On some machines, conditional branch instructions can optionally annul instructions in the delay slot. This means that the instruction will not be executed for certain branch outcomes. Both instructions that annul if the branch is true and instructions that annul if the branch is false are supported. Delay slot scheduling differs from instruction scheduling in that determining whether an instruction needs a delay slot is dependent only on the type of instruction being generated, not on data flow between the instructions. See the next section for a discussion of data-dependent instruction scheduling.
The requirement of an insn needing one or more delay slots is indicated
via the define_delay expression. It has the following form:
(define_delay test
[delay-1 annul-true-1 annul-false-1
delay-2 annul-true-2 annul-false-2
...])
test is an attribute test that indicates whether this
define_delay applies to a particular insn. If so, the number of
required delay slots is determined by the length of the vector specified
as the second argument. An insn placed in delay slot n must
satisfy attribute test delay-n. annul-true-n is an
attribute test that specifies which insns may be annulled if the branch
is true. Similarly, annul-false-n specifies which insns in the
delay slot may be annulled if the branch is false. If annulling is not
supported for that delay slot, (nil) should be coded.
For example, in the common case where branch and call insns require a single delay slot, which may contain any insn other than a branch or call, the following would be placed in the `md' file:
(define_delay (eq_attr "type" "branch,call")
[(eq_attr "type" "!branch,call") (nil) (nil)])
Multiple define_delay expressions may be specified. In this
case, each such expression specifies different delay slot requirements
and there must be no insn for which tests in two define_delay
expressions are both true.
For example, if we have a machine that requires one delay slot for branches but two for calls, no delay slot can contain a branch or call insn, and any valid insn in the delay slot for the branch can be annulled if the branch is true, we might represent this as follows:
(define_delay (eq_attr "type" "branch")
[(eq_attr "type" "!branch,call")
(eq_attr "type" "!branch,call")
(nil)])
(define_delay (eq_attr "type" "call")
[(eq_attr "type" "!branch,call") (nil) (nil)
(eq_attr "type" "!branch,call") (nil) (nil)])
On most RISC machines, there are instructions whose results are not available for a specific number of cycles. Common cases are instructions that load data from memory. On many machines, a pipeline stall will result if the data is referenced too soon after the load instruction.
In addition, many newer microprocessors have multiple function units, usually one for integer and one for floating point, and often will incur pipeline stalls when a result that is needed is not yet ready.
The descriptions in this section allow the specification of how much time must elapse between the execution of an instruction and the time when its result is used. It also allows specification of when the execution of an instruction will delay execution of similar instructions due to function unit conflicts.
For the purposes of the specifications in this section, a machine is divided into function units, each of which execute a specific class of instructions in first-in-first-out order. Function units that accept one instruction each cycle and allow a result to be used in the succeeding instruction (usually via forwarding) need not be specified. Classic RISC microprocessors will normally have a single function unit, which we can call `memory'. The newer "superscalar" processors will often have function units for floating point operations, usually at least a floating point adder and multiplier.
Each usage of a function units by a class of insns is specified with a
define_function_unit expression, which looks like this:
(define_function_unit name multiplicity simultaneity
test ready-delay issue-delay
[conflict-list])
name is a string giving the name of the function unit.
multiplicity is an integer specifying the number of identical units in the processor. If more than one unit is specified, they will be scheduled independently. Only truly independent units should be counted; a pipelined unit should be specified as a single unit. (The only common example of a machine that has multiple function units for a single instruction class that are truly independent and not pipelined are the two multiply and two increment units of the CDC 6600.)
simultaneity specifies the maximum number of insns that can be executing in each instance of the function unit simultaneously or zero if the unit is pipelined and has no limit.
All define_function_unit definitions referring to function unit
name must have the same name and values for multiplicity and
simultaneity.
test is an attribute test that selects the insns we are describing
in this definition. Note that an insn may use more than one function
unit and a function unit may be specified in more than one
define_function_unit.
ready-delay is an integer that specifies the number of cycles after which the result of the instruction can be used without introducing any stalls.
issue-delay is an integer that specifies the number of cycles after the instruction matching the test expression begins using this unit until a subsequent instruction can begin. A cost of N indicates an N-1 cycle delay. A subsequent instruction may also be delayed if an earlier instruction has a longer ready-delay value. This blocking effect is computed using the simultaneity, ready-delay, issue-delay, and conflict-list terms. For a normal non-pipelined function unit, simultaneity is one, the unit is taken to block for the ready-delay cycles of the executing insn, and smaller values of issue-delay are ignored.
conflict-list is an optional list giving detailed conflict costs for this unit. If specified, it is a list of condition test expressions to be applied to insns chosen to execute in name following the particular insn matching test that is already executing in name. For each insn in the list, issue-delay specifies the conflict cost; for insns not in the list, the cost is zero. If not specified, conflict-list defaults to all instructions that use the function unit.
Typical uses of this vector are where a floating point function unit can pipeline either single- or double-precision operations, but not both, or where a memory unit can pipeline loads, but not stores, etc.
As an example, consider a classic RISC machine where the result of a load instruction is not available for two cycles (a single "delay" instruction is required) and where only one load instruction can be executed simultaneously. This would be specified as:
(define_function_unit "memory" 1 1 (eq_attr "type" "load") 2 0)
For the case of a floating point function unit that can pipeline either single or double precision, but not both, the following could be specified:
(define_function_unit "fp" 1 0 (eq_attr "type" "sp_fp") 4 4 [(eq_attr "type" "dp_fp")]) (define_function_unit "fp" 1 0 (eq_attr "type" "dp_fp") 4 4 [(eq_attr "type" "sp_fp")])
Note: The scheduler attempts to avoid function unit conflicts
and uses all the specifications in the define_function_unit
expression. It has recently come to our attention that these
specifications may not allow modeling of some of the newer
"superscalar" processors that have insns using multiple pipelined
units. These insns will cause a potential conflict for the second unit
used during their execution and there is no way of representing that
conflict. We welcome any examples of how function unit conflicts work
in such processors and suggestions for their representation.
In addition to the file `machine.md', a machine description includes a C header file conventionally given the name `machine.h'. This header file defines numerous macros that convey the information about the target machine that does not fit into the scheme of the `.md' file. The file `tm.h' should be a link to `machine.h'. The header file `config.h' includes `tm.h' and most compiler source files include `config.h'.
You can control the compilation driver.
SWITCH_TAKES_ARG (char)
WORD_SWITCH_TAKES_ARG (name)
SWITCH_TAKES_ARG is used for multi-character option names.
By default, this macro is defined as
DEFAULT_WORD_SWITCH_TAKES_ARG, which handles the standard options
properly. You need not define WORD_SWITCH_TAKES_ARG unless you
wish to add additional options which take arguments. Any redefinition
should call DEFAULT_WORD_SWITCH_TAKES_ARG and then check for
additional options.
SWITCHES_NEED_SPACES
CPP_SPEC
NO_BUILTIN_SIZE_TYPE
__SIZE_TYPE__. The macro __SIZE_TYPE__ must then be defined
by CPP_SPEC instead.
This should be defined if SIZE_TYPE depends on target dependent flags
which are not accessible to the preprocessor. Otherwise, it should not
be defined.
NO_BUILTIN_PTRDIFF_TYPE
__PTRDIFF_TYPE__. The macro __PTRDIFF_TYPE__ must then be
defined by CPP_SPEC instead.
This should be defined if PTRDIFF_TYPE depends on target dependent flags
which are not accessible to the preprocessor. Otherwise, it should not
be defined.
SIGNED_CHAR_SPEC
char will be treated as
unsigned char by cc1.
Do not define this macro unless you need to override the default
definition.
CC1_SPEC
cc1. It can also specify how to translate options you
give to GNU CC into options for GNU CC to pass to the cc1.
Do not define this macro if it does not need to do anything.
CC1PLUS_SPEC
cc1plus. It can also specify how to translate options you
give to GNU CC into options for GNU CC to pass to the cc1plus.
Do not define this macro if it does not need to do anything.
ASM_SPEC
ASM_FINAL_SPEC
LINK_SPEC
LIB_SPEC
LINK_SPEC. The difference
between the two is that LIB_SPEC is used at the end of the
command given to the linker.
If this macro is not defined, a default is provided that
loads the standard C library from the usual place. See `gcc.c'.
LIBGCC_SPEC
LIB_SPEC.
If this macro is not defined, the GNU CC driver provides a default that
passes the string `-lgcc' to the linker unless the `-shared'
option is specified.
STARTFILE_SPEC
LINK_SPEC. The
difference between the two is that STARTFILE_SPEC is used at
the very beginning of the command given to the linker.
If this macro is not defined, a default is provided that loads the
standard C startup file from the usual place. See `gcc.c'.
ENDFILE_SPEC
LINK_SPEC. The
difference between the two is that ENDFILE_SPEC is used at
the very end of the command given to the linker.
Do not define this macro if it does not need to do anything.
LINK_LIBGCC_SPECIAL
LINK_LIBGCC_SPECIAL_1
LINK_LIBGCC_SPECIAL, except that it does
not affect `-L' options.
MULTILIB_DEFAULTS
MULTILIB_OPTIONS.
Do not define this macro if MULTILIB_OPTIONS is not defined in
the target makefile fragment or if none of the options listed in
MULTILIB_OPTIONS are set by default.
See section The Target Makefile Fragment.
RELATIVE_PREFIX_NOT_LINKDIR
gcc that it should only translate
a `-B' prefix into a `-L' linker option if the prefix
indicates an absolute file name.
STANDARD_EXEC_PREFIX
MD_EXEC_PREFIX
STANDARD_EXEC_PREFIX. MD_EXEC_PREFIX is not searched
when the `-b' option is used, or the compiler is built as a cross
compiler.
STANDARD_STARTFILE_PREFIX
MD_STARTFILE_PREFIX
MD_EXEC_PREFIX is not searched when the
`-b' option is used, or when the compiler is built as a cross
compiler.
MD_STARTFILE_PREFIX_1
INIT_ENVIRONMENT
putenv to
initialize the necessary environment variables.
LOCAL_INCLUDE_DIR
LOCAL_INCLUDE_DIR
comes before SYSTEM_INCLUDE_DIR in the search order.
Cross compilers do not use this macro and do not search either
`/usr/local/include' or its replacement.
SYSTEM_INCLUDE_DIR
SYSTEM_INCLUDE_DIR comes before
STANDARD_INCLUDE_DIR in the search order.
Cross compilers do not use this macro and do not search the directory
specified.
STANDARD_INCLUDE_DIR
INCLUDE_DEFAULTS
GCC_INCLUDE_DIR, LOCAL_INCLUDE_DIR,
SYSTEM_INCLUDE_DIR, GPLUSPLUS_INCLUDE_DIR, and
STANDARD_INCLUDE_DIR. In addition, GPLUSPLUS_INCLUDE_DIR
and GCC_INCLUDE_DIR are defined automatically by `Makefile',
and specify private search areas for GCC. The directory
GPLUSPLUS_INCLUDE_DIR is used only for C++ programs.
The definition should be an initializer for an array of structures.
Each array element should have two elements: the directory name (a
string constant) and a flag for C++-only directories. Mark the end of
the array with a null element. For example, here is the definition used
for VMS:
#define INCLUDE_DEFAULTS \
{ \
{ "GNU_GXX_INCLUDE:", 1}, \
{ "GNU_CC_INCLUDE:", 0}, \
{ "SYS$SYSROOT:[SYSLIB.]", 0}, \
{ ".", 0}, \
{ 0, 0} \
}
Here is the order of prefixes tried for exec files:
GCC_EXEC_PREFIX, if any.
COMPILER_PATH.
STANDARD_EXEC_PREFIX.
MD_EXEC_PREFIX, if any.
Here is the order of prefixes tried for startfiles:
GCC_EXEC_PREFIX, if any.
LIBRARY_PATH
(native only, cross compilers do not use this).
STANDARD_EXEC_PREFIX.
MD_EXEC_PREFIX, if any.
MD_STARTFILE_PREFIX, if any.
STANDARD_STARTFILE_PREFIX.
Here are run-time target specifications.
CPP_PREDEFINES
"-Dmc68000 -Dsun -Dunix"The result is to define the macros
__mc68000__, __sun__
and __unix__ unconditionally, and the macros mc68000,
sun and unix provided `-ansi' is not specified.
extern int target_flags;
TARGET_...
TARGET_68020 that tests a bit in
target_flags.
Define a macro TARGET_featurename for each such option.
Its definition should test a bit in target_flags; for example:
#define TARGET_68020 (target_flags & 1)One place where these macros are used is in the condition-expressions of instruction patterns. Note how
TARGET_68020 appears
frequently in the 68000 machine description file, `m68k.md'.
Another place they are used is in the definitions of the other
macros in the `machine.h' file.
TARGET_SWITCHES
target_flags. Its definition is an initializer
with a subgrouping for each command option.
Each subgrouping contains a string constant, that defines the option
name, and a number, which contains the bits to set in
target_flags. A negative number says to clear bits instead;
the negative of the number is which bits to clear. The actual option
name is made by appending `-m' to the specified name.
One of the subgroupings should have a null string. The number in
this grouping is the default value for target_flags. Any
target options act starting with that value.
Here is an example which defines `-m68000' and `-m68020'
with opposite meanings, and picks the latter as the default:
#define TARGET_SWITCHES \
{ { "68020", 1}, \
{ "68000", -1}, \
{ "", 1}}
TARGET_OPTIONS
TARGET_SWITCHES but defines names of command
options that have values. Its definition is an initializer with a
subgrouping for each command option.
Each subgrouping contains a string constant, that defines the fixed part
of the option name, and the address of a variable. The variable, type
char *, is set to the variable part of the given option if the fixed
part matches. The actual option name is made by appending `-m' to the
specified name.
Here is an example which defines `-mshort-data-number'. If the
given option is `-mshort-data-512', the variable m88k_short_data
will be set to the string "512".
extern char *m88k_short_data;
#define TARGET_OPTIONS \
{ { "short-data-", &m88k_short_data } }
TARGET_VERSION
stderr a string
describing the particular machine description choice. Every machine
description should define TARGET_VERSION. For example:
#ifdef MOTOROLA #define TARGET_VERSION \ fprintf (stderr, " (68k, Motorola syntax)"); #else #define TARGET_VERSION \ fprintf (stderr, " (68k, MIT syntax)"); #endif
OVERRIDE_OPTIONS
OVERRIDE_OPTIONS to take account of this. This macro, if
defined, is executed once just after all the command options have been
parsed.
Don't use this macro to turn on various extra optimizations for
`-O'. That is what OPTIMIZATION_OPTIONS is for.
OPTIMIZATION_OPTIONS (level)
write_symbols in
this macro! The debugging options are not supposed to alter the
generated code.
CAN_DEBUG_WITHOUT_FP
Note that the definitions of the macros in this table which are sizes or
alignments measured in bits do not need to be constant. They can be C
expressions that refer to static variables, such as the target_flags.
See section Run-time Target Specification.
BITS_BIG_ENDIAN
BYTES_BIG_ENDIAN.
BYTES_BIG_ENDIAN
WORDS_BIG_ENDIAN
LIBGCC2_WORDS_BIG_ENDIAN
FLOAT_WORDS_BIG_ENDIAN
DFmode, XFmode or
TFmode floating point numbers are stored in memory with the word
containing the sign bit at the lowest address; otherwise define it to
have the value 0. This macro need not be a constant.
You need not define this macro if the ordering is the same as for
multi-word integers.
BITS_PER_UNIT
BITS_PER_WORD
MAX_BITS_PER_WORD
BITS_PER_WORD. Otherwise, it is the constant value that is the
largest value that BITS_PER_WORD can have at run-time.
UNITS_PER_WORD
MIN_UNITS_PER_WORD
UNITS_PER_WORD. Otherwise, it is the constant value that is the
smallest value that UNITS_PER_WORD can have at run-time.
POINTER_SIZE
Pmode. If it is not equal to the width of Pmode,
you must define POINTERS_EXTEND_UNSIGNED.
POINTERS_EXTEND_UNSIGNED
POINTER_SIZE bits wide to Pmode
are sign-extended and zero if they are zero-extended.
You need not define this macro if the POINTER_SIZE is equal
to the width of Pmode.
PROMOTE_MODE (m, unsignedp, type)
word_mode if
m is an integer mode narrower than BITS_PER_WORD. In most
cases, only integer modes should be widened because wider-precision
floating-point operations are usually more expensive than their narrower
counterparts.
For most machines, the macro definition does not change unsignedp.
However, some machines, have instructions that preferentially handle
either signed or unsigned quantities of certain modes. For example, on
the DEC Alpha, 32-bit loads from memory and 32-bit add instructions
sign-extend the result to 64 bits. On such machines, set
unsignedp according to which kind of extension is more efficient.
Do not define this macro if it would never modify m.
PROMOTE_FUNCTION_ARGS
PROMOTE_MODE
should also be done for outgoing function arguments.
PROMOTE_FUNCTION_RETURN
PROMOTE_MODE
should also be done for the return value of functions.
If this macro is defined, FUNCTION_VALUE must perform the same
promotions done by PROMOTE_MODE.
PROMOTE_FOR_CALL_ONLY
PROMOTE_MODE
should only be performed for outgoing function arguments or
function return values, as specified by PROMOTE_FUNCTION_ARGS
and PROMOTE_FUNCTION_RETURN, respectively.
PARM_BOUNDARY
STACK_BOUNDARY
PUSH_ROUNDING is not defined, the stack will always be aligned
to the specified boundary. If PUSH_ROUNDING is defined and specifies a
less strict alignment than STACK_BOUNDARY, the stack may be
momentarily unaligned while pushing arguments.
FUNCTION_BOUNDARY
BIGGEST_ALIGNMENT
BIGGEST_FIELD_ALIGNMENT
BIGGEST_ALIGNMENT for
structure fields only.
MAX_OFILE_ALIGNMENT
__attribute__ ((aligned (n))) construct. If not defined,
the default value is BIGGEST_ALIGNMENT.
DATA_ALIGNMENT (type, basic-align)
strcpy calls that copy
constants to character arrays can be done inline.
CONSTANT_ALIGNMENT (constant, basic-align)
strcpy calls that copy
constants can be done inline.
EMPTY_FIELD_BOUNDARY
int : 0;.
Note that PCC_BITFIELD_TYPE_MATTERS also affects the alignment
that results from an empty field.
STRUCTURE_SIZE_BOUNDARY
BITS_PER_UNIT.
STRICT_ALIGNMENT
PCC_BITFIELD_TYPE_MATTERS
int,
short, or other integer type) imposes an alignment for the
entire structure, as if the structure really did contain an ordinary
field of that type. In addition, the bitfield is placed within the
structure so that it would fit within such a field, not crossing a
boundary for it.
Thus, on most machines, a bitfield whose type is written as int
would not cross a four-byte boundary, and would force four-byte
alignment for the whole structure. (The alignment used may not be four
bytes; it is controlled by the other alignment parameters.)
If the macro is defined, its definition should be a C expression;
a nonzero value for the expression enables this behavior.
Note that if this macro is not defined, or its value is zero, some
bitfields may cross more than one alignment boundary. The compiler can
support such references if there are `insv', `extv', and
`extzv' insns that can directly reference memory.
The other known way of making bitfields work is to define
STRUCTURE_SIZE_BOUNDARY as large as BIGGEST_ALIGNMENT.
Then every structure can be accessed with fullwords.
Unless the machine has bitfield instructions or you define
STRUCTURE_SIZE_BOUNDARY that way, you must define
PCC_BITFIELD_TYPE_MATTERS to have a nonzero value.
If your aim is to make GNU CC use the same conventions for laying out
bitfields as are used by another compiler, here is how to investigate
what the other compiler does. Compile and run this program:
struct foo1
{
char x;
char :0;
char y;
};
struct foo2
{
char x;
int :0;
char y;
};
main ()
{
printf ("Size of foo1 is %d\n",
sizeof (struct foo1));
printf ("Size of foo2 is %d\n",
sizeof (struct foo2));
exit (0);
}
If this prints 2 and 5, then the compiler's behavior is what you would
get from PCC_BITFIELD_TYPE_MATTERS.
BITFIELD_NBYTES_LIMITED
ROUND_TYPE_SIZE (struct, size, align)
ROUND_TYPE_ALIGN (struct, computed, specified)
BIGGEST_ALIGNMENT
MAX_FIXED_MODE_SIZE
GET_MODE_BITSIZE
(DImode) is assumed.
CHECK_FLOAT_VALUE (mode, value, overflow)
double) for mode mode. This means that you check whether
value fits within the possible range of values for mode
mode on this target machine. The mode mode is always
a mode of class MODE_FLOAT. overflow is nonzero if
the value is already known to be out of range.
If value is not valid or if overflow is nonzero, you should
set overflow to 1 and then assign some valid value to value.
Allowing an invalid value to go through the compiler can produce
incorrect assembler code which may even cause Unix assemblers to crash.
This macro need not be defined if there is no work for it to do.
TARGET_FLOAT_FORMAT
IEEE_FLOAT_FORMAT
VAX_FLOAT_FORMAT
UNKNOWN_FLOAT_FORMAT
HOST_FLOAT_FORMAT
(see section The Configuration File) to determine whether the target machine has the same
format as the host machine. If any other formats are actually in use on
supported machines, new codes should be defined for them.
The ordering of the component words of floating point values stored in
memory is controlled by FLOAT_WORDS_BIG_ENDIAN for the target
machine and HOST_FLOAT_WORDS_BIG_ENDIAN for the host.
These macros define the sizes and other characteristics of the standard basic data types used in programs being compiled. Unlike the macros in the previous section, these apply to specific features of C and related languages, rather than to fundamental aspects of storage layout.
INT_TYPE_SIZE
int on the
target machine. If you don't define this, the default is one word.
MAX_INT_TYPE_SIZE
int on the target
machine. If this is undefined, the default is INT_TYPE_SIZE.
Otherwise, it is the constant value that is the largest value that
INT_TYPE_SIZE can have at run-time. This is used in cpp.
SHORT_TYPE_SIZE
short on the
target machine. If you don't define this, the default is half a word.
(If this would be less than one storage unit, it is rounded up to one
unit.)
LONG_TYPE_SIZE
long on the
target machine. If you don't define this, the default is one word.
MAX_LONG_TYPE_SIZE
long on the
target machine. If this is undefined, the default is
LONG_TYPE_SIZE. Otherwise, it is the constant value that is the
largest value that LONG_TYPE_SIZE can have at run-time. This is
used in cpp.
LONG_LONG_TYPE_SIZE
long long on the
target machine. If you don't define this, the default is two
words. If you want to support GNU Ada on your machine, the value of
macro must be at least 64.
CHAR_TYPE_SIZE
char on the
target machine. If you don't define this, the default is one quarter
of a word. (If this would be less than one storage unit, it is rounded up
to one unit.)
MAX_CHAR_TYPE_SIZE
char on the
target machine. If this is undefined, the default is
CHAR_TYPE_SIZE. Otherwise, it is the constant value that is the
largest value that CHAR_TYPE_SIZE can have at run-time. This is
used in cpp.
FLOAT_TYPE_SIZE
float on the
target machine. If you don't define this, the default is one word.
DOUBLE_TYPE_SIZE
double on the
target machine. If you don't define this, the default is two
words.
LONG_DOUBLE_TYPE_SIZE
long double on
the target machine. If you don't define this, the default is two
words.
DEFAULT_SIGNED_CHAR
char should be signed or unsigned by default. The user can
always override this default with the options `-fsigned-char'
and `-funsigned-char'.
DEFAULT_SHORT_ENUMS
enum type
only as many bytes as it takes to represent the range of possible values
of that type. A nonzero value means to do that; a zero value means all
enum types should be allocated like int.
If you don't define the macro, the default is 0.
SIZE_TYPE
size_t is defined using the
contents of the string.
The string can contain more than one keyword. If so, separate them with
spaces, and write first any length keyword, then unsigned if
appropriate, and finally int. The string must exactly match one
of the data type names defined in the function
init_decl_processing in the file `c-decl.c'. You may not
omit int or change the order--that would cause the compiler to
crash on startup.
If you don't define this macro, the default is "long unsigned
int".
PTRDIFF_TYPE
ptrdiff_t is defined using the contents of the string. See
SIZE_TYPE above for more information.
If you don't define this macro, the default is "long int".
WCHAR_TYPE
wchar_t is defined using
the contents of the string. See SIZE_TYPE above for more
information.
If you don't define this macro, the default is "int".
WCHAR_TYPE_SIZE
cpp, which cannot make use of
WCHAR_TYPE.
MAX_WCHAR_TYPE_SIZE
WCHAR_TYPE_SIZE. Otherwise, it is the constant value that is the
largest value that WCHAR_TYPE_SIZE can have at run-time. This is
used in cpp.
OBJC_INT_SELECTORS
int.
If this macro is not defined, then selectors should have the type
struct objc_selector *.
OBJC_SELECTORS_WITHOUT_LABELS
TARGET_BELL
TARGET_BS
TARGET_TAB
TARGET_NEWLINE
TARGET_VT
TARGET_FF
TARGET_CR
This section explains how to describe what registers the target machine has, and how (in general) they can be used.
The description of which registers a specific instruction can use is done with register classes; see section Register Classes. For information on using registers to access a stack frame, see section Registers That Address the Stack Frame. For passing values in registers, see section Passing Arguments in Registers. For returning values in registers, see section How Scalar Function Values Are Returned.
Registers have various characteristics.
FIRST_PSEUDO_REGISTER
FIRST_PSEUDO_REGISTER-1; thus, the first
pseudo register's number really is assigned the number
FIRST_PSEUDO_REGISTER.
FIXED_REGISTERS
CONDITIONAL_REGISTER_USAGE, or by
the user with the command options `-ffixed-reg',
`-fcall-used-reg' and `-fcall-saved-reg'.
CALL_USED_REGISTERS
FIXED_REGISTERS but has 1 for each register that is
clobbered (in general) by function calls as well as for fixed
registers. This macro therefore identifies the registers that are not
available for general allocation of values that must live across
function calls.
If a register has 0 in CALL_USED_REGISTERS, the compiler
automatically saves it on function entry and restores it on function
exit, if the register is used within the function.
CONDITIONAL_REGISTER_USAGE
fixed_regs and call_used_regs (both of type char
[]) after they have been initialized from the two preceding macros.
This is necessary in case the fixed or call-clobbered registers depend
on target flags.
You need not define this macro if it has no work to do.
If the usage of an entire class of registers depends on the target
flags, you may indicate this to GCC by using this macro to modify
fixed_regs and call_used_regs to 1 for each of the
registers in the classes which should not be used by GCC. Also define
the macro REG_CLASS_FROM_LETTER to return NO_REGS if it
is called with a letter for a class that shouldn't be used.
(However, if this class is not included in GENERAL_REGS and all
of the insn patterns whose constraints permit this class are
controlled by target switches, then GCC will automatically avoid using
these registers when the target switches are opposed to them.)
NON_SAVING_SETJMP
setjmp and related functions fail to save the registers, or that
longjmp fails to restore them. To compensate, the compiler
avoids putting variables in registers in functions that use
setjmp.
INCOMING_REGNO (out)
OUTGOING_REGNO (in)
Registers are allocated in order.
REG_ALLOC_ORDER
REG_ALLOC_ORDER to be an initializer that lists
the highest numbered allocatable register first.
ORDER_REGS_FOR_LOCAL_ALLOC
reg_alloc_order.
Element 0 should be the register to allocate first; element 1, the next
register; and so on.
The macro body should not assume anything about the contents of
reg_alloc_order before execution of the macro.
On most machines, it is not necessary to define this macro.
This section discusses the macros that describe which kinds of values (specifically, which machine modes) each register can hold, and how many consecutive registers are needed for a given mode.
HARD_REGNO_NREGS (regno, mode)
#define HARD_REGNO_NREGS(REGNO, MODE) \
((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) \
/ UNITS_PER_WORD))
HARD_REGNO_MODE_OK (regno, mode)
#define HARD_REGNO_MODE_OK(REGNO, MODE) 1It is not necessary for this macro to check for the numbers of fixed registers, because the allocation mechanism considers them to be always occupied. On some machines, double-precision values must be kept in even/odd register pairs. The way to implement that is to define this macro to reject odd register numbers for such modes. The minimum requirement for a mode to be OK in a register is that the `movmode' instruction pattern support moves between the register and any other hard register for which the mode is OK; and that moving a value into the register and back out not alter it. Since the same instruction used to move
SImode will work for all
narrower integer modes, it is not necessary on any machine for
HARD_REGNO_MODE_OK to distinguish between these modes, provided
you define patterns `movhi', etc., to take advantage of this. This
is useful because of the interaction between HARD_REGNO_MODE_OK
and MODES_TIEABLE_P; it is very desirable for all integer modes
to be tieable.
Many machines have special registers for floating point arithmetic.
Often people assume that floating point machine modes are allowed only
in floating point registers. This is not true. Any registers that
can hold integers can safely hold a floating point machine
mode, whether or not floating arithmetic can be done on it in those
registers. Integer move instructions can be used to move the values.
On some machines, though, the converse is true: fixed-point machine
modes may not go in floating registers. This is true if the floating
registers normalize any value stored in them, because storing a
non-floating value there would garble it. In this case,
HARD_REGNO_MODE_OK should reject fixed-point machine modes in
floating registers. But if the floating registers do not automatically
normalize, if you can store any bit pattern in one and retrieve it
unchanged without a trap, then any machine mode may go in a floating
register, so you can define this macro to say so.
The primary significance of special floating registers is rather that
they are the registers acceptable in floating point arithmetic
instructions. However, this is of no concern to
HARD_REGNO_MODE_OK. You handle it by writing the proper
constraints for those instructions.
On some machines, the floating registers are especially slow to access,
so that it is better to store a value in a stack frame than in such a
register if floating point arithmetic is not being done. As long as the
floating registers are not in class GENERAL_REGS, they will not
be used unless some pattern's constraint asks for one.
MODES_TIEABLE_P (mode1, mode2)
HARD_REGNO_MODE_OK (r, mode1) and
HARD_REGNO_MODE_OK (r, mode2) are ever different
for any r, then MODES_TIEABLE_P (mode1,
mode2) must be zero.
On some machines, a leaf function (i.e., one which makes no calls) can run more efficiently if it does not make its own register window. Often this means it is required to receive its arguments in the registers where they are passed by the caller, instead of the registers where they would normally arrive.
The special treatment for leaf functions generally applies only when other conditions are met; for example, often they may use only those registers for its own variables and temporaries. We use the term "leaf function" to mean a function that is suitable for this special handling, so that functions with no calls are not necessarily "leaf functions".
GNU CC assigns register numbers before it knows whether the function is suitable for leaf function treatment. So it needs to renumber the registers in order to output a leaf function. The following macros accomplish this.
LEAF_REGISTERS
LEAF_REG_REMAP (regno)
Normally, FUNCTION_PROLOGUE and FUNCTION_EPILOGUE must
treat leaf functions specially. It can test the C variable
leaf_function which is nonzero for leaf functions. (The variable
leaf_function is defined only if LEAF_REGISTERS is
defined.)
There are special features to handle computers where some of the "registers" form a stack, as in the 80387 coprocessor for the 80386. Stack registers are normally written by pushing onto the stack, and are numbered relative to the top of the stack.
Currently, GNU CC can only handle one group of stack-like registers, and they must be consecutively numbered.
STACK_REGS
FIRST_STACK_REG
LAST_STACK_REG
These features do not work very well. They exist because they used to be required to generate correct code for the 80387 coprocessor of the 80386. They are no longer used by that machine description and may be removed in a later version of the compiler. Don't use them!
OVERLAPPING_REGNO_P (regno)
INSN_CLOBBERS_REGNO_P (insn, regno)
PRESERVE_DEATH_INFO_REGNO_P (regno)
REG_DEAD notes are needed for hard register number regno
at the time of outputting the assembler code. When this is so, a few
optimizations that take place after register allocation and could
invalidate the death notes are not done when this register is
involved.
You would arrange to preserve death info for a register when some of the
code in the machine description which is executed to write the assembler
code looks at the death notes. This is necessary only when the actual
hardware feature which GNU CC thinks of as a register is not actually a
register of the usual sort. (It might, for example, be a hardware
stack.)
If this macro is not defined, it means that no death notes need to be
preserved. This is the usual situation.
On many machines, the numbered registers are not all equivalent. For example, certain registers may not be allowed for indexed addressing; certain registers may not be allowed in some instructions. These machine restrictions are described to the compiler using register classes.
You define a number of register classes, giving each one a name and saying which of the registers belong to it. Then you can specify register classes that are allowed as operands to particular instruction patterns.
In general, each register will belong to several classes. In fact, one
class must be named ALL_REGS and contain all the registers. Another
class must be named NO_REGS and contain no registers. Often the
union of two classes will be another class; however, this is not required.
One of the classes must be named GENERAL_REGS. There is nothing
terribly special about the name, but the operand constraint letters
`r' and `g' specify this class. If GENERAL_REGS is
the same as ALL_REGS, just define it as a macro which expands
to ALL_REGS.
Order the classes so that if class x is contained in class y then x has a lower class number than y.
The way classes other than GENERAL_REGS are specified in operand
constraints is through machine-dependent operand constraint letters.
You can define such letters to correspond to various classes, then use
them in operand constraints.
You should define a class for the union of two classes whenever some
instruction allows both classes. For example, if an instruction allows
either a floating point (coprocessor) register or a general register for a
certain operand, you should define a class FLOAT_OR_GENERAL_REGS
which includes both of them. Otherwise you will get suboptimal code.
You must also specify certain redundant information about the register classes: for each class, which classes contain it and which ones are contained in it; for each pair of classes, the largest class contained in their union.
When a value occupying several consecutive registers is expected in a
certain class, all the registers used must belong to that class.
Therefore, register classes cannot be used to enforce a requirement for
a register pair to start with an even-numbered register. The way to
specify this requirement is with HARD_REGNO_MODE_OK.
Register classes used for input-operands of bitwise-and or shift
instructions have a special requirement: each such class must have, for
each fixed-point machine mode, a subclass whose registers can transfer that
mode to or from memory. For example, on some machines, the operations for
single-byte values (QImode) are limited to certain registers. When
this is so, each register class that is used in a bitwise-and or shift
instruction must have a subclass consisting of registers from which
single-byte values can be loaded or stored. This is so that
PREFERRED_RELOAD_CLASS can always have a possible value to return.
enum reg_class
NO_REGS must be first. ALL_REGS
must be the last register class, followed by one more enumeral value,
LIM_REG_CLASSES, which is not a register class but rather
tells how many classes there are.
Each register class has a number, which is the value of casting
the class name to type int. The number serves as an index
in many of the tables described below.
N_REG_CLASSES
#define N_REG_CLASSES (int) LIM_REG_CLASSES
REG_CLASS_NAMES
REG_CLASS_CONTENTS
mask & (1 << r) is 1.
When the machine has more than 32 registers, an integer does not suffice.
Then the integers are replaced by sub-initializers, braced groupings containing
several integers. Each sub-initializer must be suitable as an initializer
for the type HARD_REG_SET which is defined in `hard-reg-set.h'.
REGNO_REG_CLASS (regno)
BASE_REG_CLASS
INDEX_REG_CLASS
REG_CLASS_FROM_LETTER (char)
NO_REGS. The register letter `r',
corresponding to class GENERAL_REGS, will not be passed
to this macro; you do not need to handle it.
REGNO_OK_FOR_BASE_P (num)
REGNO_OK_FOR_INDEX_P (num)
PREFERRED_RELOAD_CLASS (x, class)
#define PREFERRED_RELOAD_CLASS(X,CLASS) CLASSSometimes returning a more restrictive class makes better code. For example, on the 68000, when x is an integer constant that is in range for a `moveq' instruction, the value of this macro is always
DATA_REGS as long as class includes the data registers.
Requiring a data register guarantees that a `moveq' will be used.
If x is a const_double, by returning NO_REGS
you can force x into a memory constant. This is useful on
certain machines where immediate floating values cannot be loaded into
certain kinds of registers.
PREFERRED_OUTPUT_RELOAD_CLASS (x, class)
PREFERRED_RELOAD_CLASS, but for output reloads instead of
input reloads. If you don't define this macro, the default is to use
class, unchanged.
LIMIT_RELOAD_CLASS (mode, class)
PREFERRED_RELOAD_CLASS, this macro should be used when
there are certain modes that simply can't go in certain reload classes.
The value is a register class; perhaps class, or perhaps another,
smaller class.
Don't define this macro unless the target machine has limitations which
require the macro to do something nontrivial.
SECONDARY_RELOAD_CLASS (class, mode, x)
SECONDARY_INPUT_RELOAD_CLASS (class, mode, x)
SECONDARY_OUTPUT_RELOAD_CLASS (class, mode, x)
SECONDARY_INPUT_RELOAD_CLASS to return the
largest register class all of whose registers can be used as
intermediate registers or scratch registers.
If copying a register class in mode to x requires an
intermediate or scratch register, SECONDARY_OUTPUT_RELOAD_CLASS
should be defined to return the largest register class required. If the
requirements for input and output reloads are the same, the macro
SECONDARY_RELOAD_CLASS should be used instead of defining both
macros identically.
The values returned by these macros are often GENERAL_REGS.
Return NO_REGS if no spare register is needed; i.e., if x
can be directly copied to or from a register of class in
mode without requiring a scratch register. Do not define this
macro if it would always return NO_REGS.
If a scratch register is required (either with or without an
intermediate register), you should define patterns for
`reload_inm' or `reload_outm', as required
(see section Standard Pattern Names For Generation. These patterns, which will normally be
implemented with a define_expand, should be similar to the
`movm' patterns, except that operand 2 is the scratch
register.
Define constraints for the reload register and scratch register that
contain a single register class. If the original reload register (whose
class is class) can meet the constraint given in the pattern, the
value returned by these macros is used for the class of the scratch
register. Otherwise, two additional reload registers are required.
Their classes are obtained from the constraints in the insn pattern.
x might be a pseudo-register or a subreg of a
pseudo-register, which could either be in a hard register or in memory.
Use true_regnum to find out; it will return -1 if the pseudo is
in memory and the hard register number if it is in a register.
These macros should not be used in the case where a particular class of
registers can only be copied to memory and not to another class of
registers. In that case, secondary reload registers are not needed and
would not be helpful. Instead, a stack location must be used to perform
the copy and the movm pattern should use memory as a
intermediate storage. This case often occurs between floating-point and
general registers.
SECONDARY_MEMORY_NEEDED (class1, class2, m)
SECONDARY_MEMORY_NEEDED_RTX (mode)
SECONDARY_MEMORY_NEEDED is defined, the compiler
allocates a stack slot for a memory location needed for register copies.
If this macro is defined, the compiler instead uses the memory location
defined by this macro.
Do not define this macro if you do not define
SECONDARY_MEMORY_NEEDED.
SECONDARY_MEMORY_NEEDED_MODE (mode)
BITS_PER_WORD bits and performs the store and
load operations in a mode that many bits wide and whose class is the
same as that of mode.
This is right thing to do on most machines because it ensures that all
bits of the register are copied and prevents accesses to the registers
in a narrower mode, which some machines prohibit for floating-point
registers.
However, this default behavior is not correct on some machines, such as
the DEC Alpha, that store short integers in floating-point registers
differently than in integer registers. On those machines, the default
widening will not work correctly and you must define this macro to
suppress that widening in some cases. See the file `alpha.h' for
details.
Do not define this macro if you do not define
SECONDARY_MEMORY_NEEDED or if widening mode to a mode that
is BITS_PER_WORD bits wide is correct for your machine.
SMALL_REGISTER_CLASSES
SMALL_REGISTER_CLASSES on these machines. When it is
defined, the compiler allows registers explicitly used in the rtl to be
used as spill registers but avoids extending the lifetime of these
registers.
It is always safe to define this macro, but if you unnecessarily define
it, you will reduce the amount of optimizations that can be performed in
some cases. If you do not define this macro when it is required, the
compiler will run out of spill registers and print a fatal error
message. For most machines, you should not define this macro.
CLASS_LIKELY_SPILLED_P (class)
CLASS_MAX_NREGS (class, mode)
HARD_REGNO_NREGS. In fact,
the value of the macro CLASS_MAX_NREGS (class, mode)
should be the maximum value of HARD_REGNO_NREGS (regno,
mode) for all regno values in the class class.
This macro helps control the handling of multiple-word values
in the reload pass.
CLASS_CANNOT_CHANGE_SIZE
FLOAT_REGS.
Three other special macros describe which operands fit which constraint letters.
CONST_OK_FOR_LETTER_P (value, c)
CONST_DOUBLE_OK_FOR_LETTER_P (value, c)
const_double values.
If c is one of those letters, the expression should check that
value, an RTX of code const_double, is in the appropriate
range and return 1 if so, 0 otherwise. If c is not one of those
letters, the value should be 0 regardless of value.
const_double is used for all floating-point constants and for
DImode fixed-point constants. A given letter can accept either
or both kinds of values. It can use GET_MODE to distinguish
between these kinds.
EXTRA_CONSTRAINT (value, c)
This describes the stack layout and calling conventions.
Here is the basic stack layout.
STACK_GROWS_DOWNWARD
#ifdef so the precise
definition used does not matter.
FRAME_GROWS_DOWNWARD
ARGS_GROW_DOWNWARD
STARTING_FRAME_OFFSET
FRAME_GROWS_DOWNWARD, find the next slot's offset by
subtracting the first slot's length from STARTING_FRAME_OFFSET.
Otherwise, it is found by adding the length of the first slot to the
value STARTING_FRAME_OFFSET.
STACK_POINTER_OFFSET
ARGS_GROW_DOWNWARD, this is the offset to the location above
the first location at which outgoing arguments are placed.
FIRST_PARM_OFFSET (fundecl)
ARGS_GROW_DOWNWARD, this is the offset to the location above
the first argument's address.
STACK_DYNAMIC_OFFSET (fundecl)
alloca.
The default value for this macro is STACK_POINTER_OFFSET plus the
length of the outgoing arguments. The default is correct for most
machines. See `function.c' for details.
DYNAMIC_CHAIN_ADDRESS (frameaddr)
SETUP_FRAME_ADDRESSES ()
RETURN_ADDR_RTX (count, frameaddr)
RETURN_ADDR_IN_PREVIOUS_FRAME is defined.
RETURN_ADDR_IN_PREVIOUS_FRAME
This discusses registers that address the stack frame.
STACK_POINTER_REGNUM
FIXED_REGISTERS. On most machines,
the hardware determines which register this is.
FRAME_POINTER_REGNUM
HARD_FRAME_POINTER_REGNUM
FRAME_POINTER_REGNUM the number of a special, fixed register to
be used internally until the offset is known, and define
HARD_FRAME_POINTER_REGNUM to be actual the hard register number
used for the frame pointer.
You should define this macro only in the very rare circumstances when it
is not possible to calculate the offset between the frame pointer and
the automatic variables until after register allocation has been
completed. When this macro is defined, you must also indicate in your
definition of ELIMINABLE_REGS how to eliminate
FRAME_POINTER_REGNUM into either HARD_FRAME_POINTER_REGNUM
or STACK_POINTER_REGNUM.
Do not define this macro if it would be the same as
FRAME_POINTER_REGNUM.
ARG_POINTER_REGNUM
FIXED_REGISTERS, or arrange to be able to eliminate it
(see section Eliminating Frame Pointer and Arg Pointer).
STATIC_CHAIN_REGNUM
STATIC_CHAIN_INCOMING_REGNUM
STATIC_CHAIN_INCOMING_REGNUM, while the register
number as seen by the calling function is STATIC_CHAIN_REGNUM. If
these registers are the same, STATIC_CHAIN_INCOMING_REGNUM need
not be defined.
The static chain register need not be a fixed register.
If the static chain is passed in memory, these macros should not be
defined; instead, the next two macros should be defined.
STATIC_CHAIN
STATIC_CHAIN_INCOMING
mem expressions that denote where they are stored.
STATIC_CHAIN and STATIC_CHAIN_INCOMING give the locations
as seen by the calling and called functions, respectively. Often the former
will be at an offset from the stack pointer and the latter at an offset from
the frame pointer.
The variables stack_pointer_rtx, frame_pointer_rtx, and
arg_pointer_rtx will have been initialized prior to the use of these
macros and should be used to refer to those items.
If the static chain is passed in a register, the two previous macros should
be defined instead.
This is about eliminating the frame pointer and arg pointer.
FRAME_POINTER_REQUIRED
FRAME_POINTER_REQUIRED says. You don't need to worry about
them.
In a function that does not require a frame pointer, the frame pointer
register can be allocated for ordinary usage, unless you mark it as a
fixed register. See FIXED_REGISTERS for more information.
INITIAL_FRAME_POINTER_OFFSET (depth-var)
get_frame_size () and the tables of
registers regs_ever_live and call_used_regs.
If ELIMINABLE_REGS is defined, this macro will be not be used and
need not be defined. Otherwise, it must be defined even if
FRAME_POINTER_REQUIRED is defined to always be true; in that
case, you may set depth-var to anything.
ELIMINABLE_REGS
#define ELIMINABLE_REGS \
{{ARG_POINTER_REGNUM, STACK_POINTER_REGNUM}, \
{ARG_POINTER_REGNUM, FRAME_POINTER_REGNUM}, \
{FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM}}
Note that the elimination of the argument pointer with the stack pointer is
specified first since that is the preferred elimination.
CAN_ELIMINATE (from-reg, to-reg)
ELIMINABLE_REGS
is defined, and will usually be the constant 1, since most of the cases
preventing register elimination are things that the compiler already
knows about.
INITIAL_ELIMINATION_OFFSET (from-reg, to-reg, offset-var)
INITIAL_FRAME_POINTER_OFFSET. It
specifies the initial difference between the specified pair of
registers. This macro must be defined if ELIMINABLE_REGS is
defined.
LONGJMP_RESTORE_FROM_STACK
longjmp function restores registers from
the stack frames, rather than from those saved specifically by
setjmp. Certain quantities must not be kept in registers across
a call to setjmp on such machines.
The macros in this section control how arguments are passed on the stack. See the following section for other macros that control passing certain arguments in registers.
PROMOTE_PROTOTYPES
int should actually be passed as an
int. In addition to avoiding errors in certain cases of
mismatch, it also makes for better code on certain machines.
PUSH_ROUNDING (npushed)
#define PUSH_ROUNDING(BYTES) (BYTES)will suffice. But on other machines, instructions that appear to push one byte actually push two bytes in an attempt to maintain alignment. Then the definition should be
#define PUSH_ROUNDING(BYTES) (((BYTES) + 1) & ~1)
ACCUMULATE_OUTGOING_ARGS
current_function_outgoing_args_size. No space will be pushed
onto the stack for each call; instead, the function prologue should
increase the stack frame size by this amount.
Defining both PUSH_ROUNDING and ACCUMULATE_OUTGOING_ARGS
is not proper.
REG_PARM_STACK_SPACE (fndecl)
OUTGOING_REG_PARM_STACK_SPACE says
which.
MAYBE_REG_PARM_STACK_SPACE
FINAL_REG_PARM_STACK_SPACE (const_size, var_size)
REG_PARM_STACK_SPACE will only be
called for libcall functions, the current function, or for a function
being called when it is known that such stack space must be allocated.
In each case this value can be easily computed.
When deciding whether a called function needs such stack space, and how
much space to reserve, GNU CC uses these two macros instead of
REG_PARM_STACK_SPACE.
OUTGOING_REG_PARM_STACK_SPACE
ACCUMULATE_OUTGOING_ARGS is defined, this macro controls
whether the space for these arguments counts in the value of
current_function_outgoing_args_size.
STACK_PARMS_IN_REG_PARM_AREA
REG_PARM_STACK_SPACE is defined, but the
stack parameters don't skip the area specified by it.
Normally, when a parameter is not passed in registers, it is placed on the
stack beyond the REG_PARM_STACK_SPACE area. Defining this macro
suppresses this behavior and causes the parameter to be passed on the
stack in its natural location.
RETURN_POPS_ARGS (fundecl, funtype, stack-size)
FUNCTION_DECL that describes the declaration of the function.
From this it is possible to obtain the DECL_MACHINE_ATTRIBUTES of
the function.
funtype is a C variable whose value is a tree node that
describes the function in question. Normally it is a node of type
FUNCTION_TYPE that describes the data type of the function.
From this it is possible to obtain the data types of the value and
arguments (if known).
When a call to a library function is being considered, funtype
will contain an identifier node for the library function. Thus, if
you need to distinguish among various library functions, you can do so
by their names. Note that "library function" in this context means
a function used to perform arithmetic, whose name is known specially
in the compiler and was not mentioned in the C code being compiled.
stack-size is the number of bytes of arguments passed on the
stack. If a variable number of bytes is passed, it is zero, and
argument popping will always be the responsibility of the calling function.
On the Vax, all functions always pop their arguments, so the definition
of this macro is stack-size. On the 68000, using the standard
calling convention, no functions pop their arguments, so the value of
the macro is always 0 in this case. But an alternative calling
convention is available in which functions that take a fixed number of
arguments pop them but other functions (such as printf) pop
nothing (the caller pops all). When this convention is in use,
funtype is examined to determine whether a function takes a fixed
number of arguments.
This section describes the macros which let you control how various types of arguments are passed in registers or how they are arranged in the stack.
FUNCTION_ARG (cum, mode, type, named)
reg RTX for the
hard register in which to pass the argument, or zero to pass the
argument on the stack.
For machines like the Vax and 68000, where normally all arguments are
pushed, zero suffices as a definition.
The usual way to make the ANSI library `stdarg.h' work on a machine
where some arguments are usually passed in registers, is to cause
nameless arguments to be passed on the stack instead. This is done
by making FUNCTION_ARG return 0 whenever named is 0.
You may use the macro MUST_PASS_IN_STACK (mode, type)
in the definition of this macro to determine if this argument is of a
type that must be passed in the stack. If REG_PARM_STACK_SPACE
is not defined and FUNCTION_ARG returns non-zero for such an
argument, the compiler will abort. If REG_PARM_STACK_SPACE is
defined, the argument will be computed in the stack and then loaded into
a register.
FUNCTION_INCOMING_ARG (cum, mode, type, named)
FUNCTION_ARG computes the register in which
the caller passes the value, and FUNCTION_INCOMING_ARG should
be defined in a similar fashion to tell the function being called
where the arguments will arrive.
If FUNCTION_INCOMING_ARG is not defined, FUNCTION_ARG
serves both purposes.
FUNCTION_ARG_PARTIAL_NREGS (cum, mode, type, named)
double or a
structure) crosses that boundary, its first few words must be passed
in registers and the rest must be pushed. This macro tells the
compiler when this occurs, and how many of the words should go in
registers.
FUNCTION_ARG for these arguments should return the first
register to be used by the caller for this argument; likewise
FUNCTION_INCOMING_ARG, for the called function.
FUNCTION_ARG_PASS_BY_REFERENCE (cum, mode, type, named)
REG_PARM_STACK_SPACE is not defined, a suitable
definition of this macro might be
#define FUNCTION_ARG_PASS_BY_REFERENCE\ (CUM, MODE, TYPE, NAMED) \ MUST_PASS_IN_STACK (MODE, TYPE)
FUNCTION_ARG_CALLEE_COPIES (cum, mode, type, named)
CUMULATIVE_ARGS
FUNCTION_ARG and other related values. For some target machines,
the type int suffices and can hold the number of bytes of
argument so far.
There is no need to record in CUMULATIVE_ARGS anything about the
arguments that have been passed on the stack. The compiler has other
variables to keep track of that. For target machines on which all
arguments are passed on the stack, there is no need to store anything in
CUMULATIVE_ARGS; however, the data structure must exist and
should not be empty, so use int.
INIT_CUMULATIVE_ARGS (cum, fntype, libname)
CUMULATIVE_ARGS. The value of fntype is the tree node
for the data type of the function which will receive the args, or 0
if the args are to a compiler support library function.
When processing a call to a compiler support library function,
libname identifies which one. It is a symbol_ref rtx which
contains the name of the function, as a string. libname is 0 when
an ordinary C function call is being processed. Thus, each time this
macro is called, either libname or fntype is nonzero, but
never both of them at once.
INIT_CUMULATIVE_INCOMING_ARGS (cum, fntype, libname)
INIT_CUMULATIVE_ARGS but overrides it for the purposes of
finding the arguments for the function being compiled. If this macro is
undefined, INIT_CUMULATIVE_ARGS is used instead.
The value passed for libname is always 0, since library routines
with special calling conventions are never compiled with GNU CC. The
argument libname exists for symmetry with
INIT_CUMULATIVE_ARGS.
FUNCTION_ARG_ADVANCE (cum, mode, type, named)
FUNCTION_ARG, etc.
This macro need not do anything if the argument in question was passed
on the stack. The compiler knows how to track the amount of stack space
used for arguments without any special help.
FUNCTION_ARG_PADDING (mode, type)
enum direction: either upward to pad above the argument,
downward to pad below, or none to inhibit padding.
The amount of padding is always just enough to reach the next
multiple of FUNCTION_ARG_BOUNDARY; this macro does not control
it.
This macro has a default definition which is right for most systems.
For little-endian machines, the default is to pad upward. For
big-endian machines, the default is to pad downward for an argument of
constant size shorter than an int, and upward otherwise.
FUNCTION_ARG_BOUNDARY (mode, type)
PARM_BOUNDARY is used for all arguments.
FUNCTION_ARG_REGNO_P (regno)
This section discusses the macros that control returning scalars as values--values that can fit in registers.
TRADITIONAL_RETURN_FLOAT
float to convert the value to double.
FUNCTION_VALUE (valtype, func)
TYPE_MODE
(valtype) to get the machine mode used to represent that type.
On many machines, only the mode is relevant. (Actually, on most
machines, scalar values are returned in the same place regardless of
mode).
If PROMOTE_FUNCTION_RETURN is defined, you must apply the same
promotion rules specified in PROMOTE_MODE if valtype is a
scalar type.
If the precise function being called is known, func is a tree
node (FUNCTION_DECL) for it; otherwise, func is a null
pointer. This makes it possible to use a different value-returning
convention for specific functions when all their calls are
known.
FUNCTION_VALUE is not used for return vales with aggregate data
types, because these are returned in another way. See
STRUCT_VALUE_REGNUM and related macros, below.
FUNCTION_OUTGOING_VALUE (valtype, func)
FUNCTION_VALUE computes the register in which
the caller will see the value. FUNCTION_OUTGOING_VALUE should be
defined in a similar fashion to tell the function where to put the
value.
If FUNCTION_OUTGOING_VALUE is not defined,
FUNCTION_VALUE serves both purposes.
FUNCTION_OUTGOING_VALUE is not used for return vales with
aggregate data types, because these are returned in another way. See
STRUCT_VALUE_REGNUM and related macros, below.
LIBCALL_VALUE (mode)
FUNCTION_DECL) for it; otherwise, func is a null
pointer. This makes it possible to use a different value-returning
convention for specific functions when all their calls are
known.
Note that "library function" in this context means a compiler
support routine, used to perform arithmetic, whose name is known
specially by the compiler and was not mentioned in the C code being
compiled.
The definition of LIBRARY_VALUE need not be concerned aggregate
data types, because none of the library functions returns such types.
FUNCTION_VALUE_REGNO_P (regno)
double, say) need not be
recognized by this macro. So for most machines, this definition
suffices:
#define FUNCTION_VALUE_REGNO_P(N) ((N) == 0)If the machine has register windows, so that the caller and the called function use different registers for the return value, this macro should recognize only the caller's register numbers.
APPLY_RESULT_SIZE
FUNCTION_VALUE_REGNO_P for
saving and restoring an arbitrary return value.
When a function value's mode is BLKmode (and in some other
cases), the value is not returned according to FUNCTION_VALUE
(see section How Scalar Function Values Are Returned). Instead, the caller passes the address of a
block of memory in which the value should be stored. This address
is called the structure value address.
This section describes how to control returning structure values in memory.
RETURN_IN_MEMORY (type)
tree, representing the data type of the value.
Note that values of mode BLKmode must be explicitly handled
by this macro. Also, the option `-fpcc-struct-return'
takes effect regardless of this macro. On most systems, it is
possible to leave the macro undefined; this causes a default
definition to be used, whose value is the constant 1 for BLKmode
values, and 0 otherwise.
Do not use this macro to indicate that structures and unions should always
be returned in memory. You should instead use DEFAULT_PCC_STRUCT_RETURN
to indicate this.
DEFAULT_PCC_STRUCT_RETURN
RETURN_IN_MEMORY macro.
If not defined, this defaults to the value 1.
STRUCT_VALUE_REGNUM
STRUCT_VALUE_REGNUM should be the number of that register.
STRUCT_VALUE
STRUCT_VALUE as an expression returning an RTX for the place
where the address is passed. If it returns 0, the address is passed as
an "invisible" first argument.
STRUCT_VALUE_INCOMING_REGNUM
STRUCT_VALUE_INCOMING
STRUCT_VALUE_INCOMING as an expression for an RTX for where the
called function should find the value. If it should find the value on
the stack, define this to create a mem which refers to the frame
pointer. A definition of 0 means that the address is passed as an
"invisible" first argument.
PCC_STATIC_STRUCT_RETURN
If you enable it, GNU CC can save registers around function calls. This makes it possible to use call-clobbered registers to hold variables that must live across calls.
DEFAULT_CALLER_SAVES
CALL_USED_REGISTERS has 1
for all registers. This macro enables `-fcaller-saves' by default.
Eventually that option will be enabled by default on all machines and both
the option and this macro will be eliminated.
CALLER_SAVE_PROFITABLE (refs, calls)
4 * calls < refs.
This section describes the macros that output function entry (prologue) and exit (epilogue) code.
FUNCTION_PROLOGUE (file, size)
regs_ever_live: element r is nonzero if hard register
r is used anywhere within the function. This implies the function
prologue should save register r, provided it is not one of the
call-used registers. (FUNCTION_EPILOGUE must likewise use
regs_ever_live.)
On machines that have "register windows", the function entry code does
not save on the stack the registers that are in the windows, even if
they are supposed to be preserved by function calls; instead it takes
appropriate steps to "push" the register stack, if any non-call-used
registers are used in the function.
On machines where functions may or may not have frame-pointers, the
function entry code must vary accordingly; it must set up the frame
pointer if one is wanted, and not otherwise. To determine whether a
frame pointer is in wanted, the macro can refer to the variable
frame_pointer_needed. The variable's value will be 1 at run
time in a function that needs a frame pointer. See section Eliminating Frame Pointer and Arg Pointer.
The function entry code is responsible for allocating any stack space
required for the function. This stack space consists of the regions
listed below. In most cases, these regions are allocated in the
order listed, with the last listed region closest to the top of the
stack (the lowest address if STACK_GROWS_DOWNWARD is defined, and
the highest address if it is not defined). You can use a different order
for a machine if doing so is more convenient or required for
compatibility reasons. Except in cases where required by standard
or by a debugger, there is no reason why the stack layout used by GCC
need agree with that used by other compilers for a machine.
current_function_pretend_args_size bytes of
uninitialized space just underneath the first argument arriving on the
stack. (This may not be at the very start of the allocated stack region
if the calling sequence has pushed anything else since pushing the stack
arguments. But usually, on such machines, nothing else has been pushed
yet, because the function prologue itself does all the pushing.) This
region is used on machines where an argument may be passed partly in
registers and partly in memory, and, in some cases to support the
features in `varargs.h' and `stdargs.h'.
ACCUMULATE_OUTGOING_ARGS is defined, a region of
current_function_outgoing_args_size bytes to be used for outgoing
argument lists of the function. See section Passing Function Arguments on the Stack.
FUNCTION_PROLOGUE and
FUNCTION_EPILOGUE to treat leaf functions specially. The C
variable leaf_function is nonzero for such a function.
EXIT_IGNORE_STACK
EXIT_IGNORE_STACK.
FUNCTION_EPILOGUE (file, size)
FUNCTION_PROLOGUE, and the
registers to restore are determined from regs_ever_live and
CALL_USED_REGISTERS in the same way.
On some machines, there is a single instruction that does all the work
of returning from the function. On these machines, give that
instruction the name `return' and do not define the macro
FUNCTION_EPILOGUE at all.
Do not define a pattern named `return' if you want the
FUNCTION_EPILOGUE to be used. If you want the target switches
to control whether return instructions or epilogues are used, define a
`return' pattern with a validity condition that tests the target
switches appropriately. If the `return' pattern's validity
condition is false, epilogues will be used.
On machines where functions may or may not have frame-pointers, the
function exit code must vary accordingly. Sometimes the code for these
two cases is completely different. To determine whether a frame pointer
is wanted, the macro can refer to the variable
frame_pointer_needed. The variable's value will be 1 when compiling
a function that needs a frame pointer.
Normally, FUNCTION_PROLOGUE and FUNCTION_EPILOGUE must
treat leaf functions specially. The C variable leaf_function is
nonzero for such a function. See section Handling Leaf Functions.
On some machines, some functions pop their arguments on exit while
others leave that for the caller to do. For example, the 68020 when
given `-mrtd' pops arguments in functions that take a fixed
number of arguments.
Your definition of the macro RETURN_POPS_ARGS decides which
functions pop their own arguments. FUNCTION_EPILOGUE needs to
know what was decided. The variable that is called
current_function_pops_args is the number of bytes of its
arguments that a function should pop. See section How Scalar Function Values Are Returned.
DELAY_SLOTS_FOR_EPILOGUE
ELIGIBLE_FOR_EPILOGUE_DELAY (insn, n)
DELAY_SLOTS_FOR_EPILOGUE returns).
If you reject a particular insn for a given delay slot, in principle, it
may be reconsidered for a subsequent delay slot. Also, other insns may
(at least in principle) be considered for the so far unfilled delay
slot.
The insns accepted to fill the epilogue delay slots are put in an RTL
list made with insn_list objects, stored in the variable
current_function_epilogue_delay_list. The insn for the first
delay slot comes first in the list. Your definition of the macro
FUNCTION_EPILOGUE should fill the delay slots by outputting the
insns in this list, usually by calling final_scan_insn.
You need not define this macro if you did not define
DELAY_SLOTS_FOR_EPILOGUE.
These macros will help you generate code for profiling.
FUNCTION_PROFILER (file, labelno)
mcount.
Before calling, the assembler code must load the address of a
counter variable into a register where mcount expects to
find the address. The name of this variable is `LP' followed
by the number labelno, so you would generate the name using
`LP%d' in a fprintf.
The details of how the address should be passed to mcount are
determined by your operating system environment, not by GNU CC. To
figure them out, compile a small program for profiling using the
system's installed C compiler and look at the assembler code that
results.
PROFILE_BEFORE_PROLOGUE
FUNCTION_BLOCK_PROFILER (file, labelno)
__bb_init_func once per object module, passing it as its sole
argument the address of a block allocated in the object module.
The name of the block is a local symbol made with this statement:
ASM_GENERATE_INTERNAL_LABEL (buffer, "LPBX", 0);Of course, since you are writing the definition of
ASM_GENERATE_INTERNAL_LABEL as well as that of this macro, you
can take a short cut in the definition of this macro and use the name
that you know will result.
The first word of this block is a flag which will be nonzero if the
object module has already been initialized. So test this word first,
and do not call __bb_init_func if the flag is nonzero.
BLOCK_PROFILER (file, blockno)
ASM_GENERATE_INTERNAL_LABEL (buffer, "LPBX", 2);Of course, since you are writing the definition of
ASM_GENERATE_INTERNAL_LABEL as well as that of this macro, you
can take a short cut in the definition of this macro and use the name
that you know will result.
BLOCK_PROFILER_CODE
GNU CC comes with an implementation of `varargs.h' and `stdarg.h' that work without change on machines that pass arguments on the stack. Other machines require their own implementations of varargs, and the two machine independent header files must have conditionals to include it.
ANSI `stdarg.h' differs from traditional `varargs.h' mainly in
the calling convention for va_start. The traditional
implementation takes just one argument, which is the variable in which
to store the argument pointer. The ANSI implementation of
va_start takes an additional second argument. The user is
supposed to write the last named argument of the function here.
However, va_start should not use this argument. The way to find
the end of the named arguments is with the built-in functions described
below.
__builtin_saveregs ()
va_start must use __builtin_saveregs, unless
you use SETUP_INCOMING_VARARGS (see below) instead.
On some machines, __builtin_saveregs is open-coded under the
control of the macro EXPAND_BUILTIN_SAVEREGS. On other machines,
it calls a routine written in assembler language, found in
`libgcc2.c'.
Code generated for the call to __builtin_saveregs appears at the
beginning of the function, as opposed to where the call to
__builtin_saveregs is written, regardless of what the code is.
This is because the registers must be saved before the function starts
to use them for its own purposes.
__builtin_args_info (category)
CUMULATIVE_ARGS data type to record how many
registers in each category have been used so far
__builtin_args_info accesses the same data structure of type
CUMULATIVE_ARGS after the ordinary argument layout is finished
with it, with category specifying which word to access. Thus, the
value indicates the first unused register in a given category.
Normally, you would use __builtin_args_info in the implementation
of va_start, accessing each category just once and storing the
value in the va_list object. This is because va_list will
have to update the values, and there is no way to alter the
values accessed by __builtin_args_info.
__builtin_next_arg (lastarg)
__builtin_args_info, for stack
arguments. It returns the address of the first anonymous stack
argument, as type void *. If ARGS_GROW_DOWNWARD, it
returns the address of the location above the first anonymous stack
argument. Use it in va_start to initialize the pointer for
fetching arguments from the stack. Also use it in va_start to
verify that the second parameter lastarg is the last named argument
of the current function.
__builtin_classify_type (object)
va_arg
has to embody these conventions. The easiest way to categorize the
specified data type is to use __builtin_classify_type together
with sizeof and __alignof__.
__builtin_classify_type ignores the value of object,
considering only its data type. It returns an integer describing what
kind of type that is--integer, floating, pointer, structure, and so on.
The file `typeclass.h' defines an enumeration that you can use to
interpret the values of __builtin_classify_type.
These machine description macros help implement varargs:
EXPAND_BUILTIN_SAVEREGS (args)
__builtin_saveregs. This code will be moved to the
very beginning of the function, before any parameter access are made.
The return value of this function should be an RTX that contains the
value to use as the return of __builtin_saveregs.
The argument args is a tree_list containing the arguments
that were passed to __builtin_saveregs.
If this macro is not defined, the compiler will output an ordinary
call to the library function `__builtin_saveregs'.
SETUP_INCOMING_VARARGS (args_so_far, mode, type,
__builtin_saveregs and
defining the macro EXPAND_BUILTIN_SAVEREGS. Use it to store the
anonymous register arguments into the stack so that all the arguments
appear to have been passed consecutively on the stack. Once this is
done, you can use the standard implementation of varargs that works for
machines that pass all their arguments on the stack.
The argument args_so_far is the CUMULATIVE_ARGS data
structure, containing the values that obtain after processing of the
named arguments. The arguments mode and type describe the
last named argument--its machine mode and its data type as a tree node.
The macro implementation should do two things: first, push onto the
stack all the argument registers not used for the named
arguments, and second, store the size of the data thus pushed into the
int-valued variable whose name is supplied as the argument
pretend_args_size. The value that you store here will serve as
additional offset for setting up the stack frame.
Because you must generate code to push the anonymous arguments at
compile time without knowing their data types,
SETUP_INCOMING_VARARGS is only useful on machines that have just
a single category of argument register and use it uniformly for all data
types.
If the argument second_time is nonzero, it means that the
arguments of the function are being analyzed for the second time. This
happens for an inline function, which is not actually compiled until the
end of the source file. The macro SETUP_INCOMING_VARARGS should
not generate any instructions in this case.
STRICT_ARGUMENT_NAMING
FUNCTION_ARG
is set for varargs and stdarg functions. With this macro defined,
the named argument is always true for named arguments, and false for
unnamed arguments. If this is not defined, but SETUP_INCOMING_VARARGS
is defined, then all arguments are treated as named. Otherwise, all named
arguments except the last are treated as named.
A trampoline is a small piece of code that is created at run time when the address of a nested function is taken. It normally resides on the stack, in the stack frame of the containing function. These macros tell GNU CC how to generate code to allocate and initialize a trampoline.
The instructions in the trampoline must do two things: load a constant address into the static chain register, and jump to the real address of the nested function. On CISC machines such as the m68k, this requires two instructions, a move immediate and a jump. Then the two addresses exist in the trampoline as word-long immediate operands. On RISC machines, it is often necessary to load each address into a register in two parts. Then pieces of each address form separate immediate operands.
The code generated to initialize the trampoline must store the variable parts--the static chain value and the function address--into the immediate operands of the instructions. On a CISC machine, this is simply a matter of copying each address to a memory reference at the proper offset from the start of the trampoline. On a RISC machine, it may be necessary to take out pieces of the address and store them separately.
TRAMPOLINE_TEMPLATE (file)
TRAMPOLINE_SECTION
TRAMPOLINE_SIZE
TRAMPOLINE_ALIGNMENT
BIGGEST_ALIGNMENT
is used for aligning trampolines.
INITIALIZE_TRAMPOLINE (addr, fnaddr, static_chain)
ALLOCATE_TRAMPOLINE (fp)
FUNCTION_PROLOGUE and
FUNCTION_EPILOGUE.
fp points to a data structure, a struct function, which
describes the compilation status of the immediate containing function of
the function which the trampoline is for. Normally (when
ALLOCATE_TRAMPOLINE is not defined), the stack slot for the
trampoline is in the stack frame of this containing function. Other
allocation strategies probably must do something analogous with this
information.
Implementing trampolines is difficult on many machines because they have separate instruction and data caches. Writing into a stack location fails to clear the memory in the instruction cache, so when the program jumps to that location, it executes the old contents.
Here are two possible solutions. One is to clear the relevant parts of the instruction cache whenever a trampoline is set up. The other is to make all trampolines identical, by having them jump to a standard subroutine. The former technique makes trampoline execution faster; the latter makes initialization faster.
To clear the instruction cache when a trampoline is initialized, define the following macros which describe the shape of the cache.
INSN_CACHE_SIZE
INSN_CACHE_LINE_WIDTH
INSN_CACHE_DEPTH
Alternatively, if the machine has system calls or instructions to clear the instruction cache directly, you can define the following macro.
CLEAR_INSN_CACHE (BEG, END)
asm statements. Both BEG and END are both pointer
expressions.
To use a standard subroutine, define the following macro. In addition, you must make sure that the instructions in a trampoline fill an entire cache line with identical instructions, or else ensure that the beginning of the trampoline code is always aligned at the same point in its cache line. Look in `m68k.h' as a guide.
TRANSFER_FROM_TRAMPOLINE
asm statements
which will be compiled with GNU CC. They go in a library function named
__transfer_from_trampoline.
If you need to avoid executing the ordinary prologue code of a compiled
C function when you jump to the subroutine, you can do so by placing a
special label of your own in the assembler code. Use one asm
statement to generate an assembler label, and another to make the label
global. Then trampolines can use that label to jump directly to your
special assembler code.
Here is an explanation of implicit calls to library routines.
MULSI3_LIBCALL
__mulsi3,
a function defined in `libgcc.a'.
DIVSI3_LIBCALL
__divsi3, a
function defined in `libgcc.a'.
UDIVSI3_LIBCALL
__udivsi3, a
function defined in `libgcc.a'.
MODSI3_LIBCALL
__modsi3, a function defined in `libgcc.a'.
UMODSI3_LIBCALL
__umodsi3, a function defined in `libgcc.a'.
MULDI3_LIBCALL
__muldi3,
a function defined in `libgcc.a'.
DIVDI3_LIBCALL
__divdi3, a
function defined in `libgcc.a'.
UDIVDI3_LIBCALL
__udivdi3, a
function defined in `libgcc.a'.
MODDI3_LIBCALL
__moddi3, a function defined in `libgcc.a'.
UMODDI3_LIBCALL
__umoddi3, a function defined in `libgcc.a'.
INIT_TARGET_OPTABS
init_optabs calls this macro after
initializing all the normal library routines.
TARGET_EDOM
EDOM on the target machine, as a C integer constant
expression. If you don't define this macro, GNU CC does not attempt to
deposit the value of EDOM into errno directly. Look in
`/usr/include/errno.h' to find the value of EDOM on your
system.
If you do not define TARGET_EDOM, then compiled code reports
domain errors by calling the library function and letting it report the
error. If mathematical functions on your system use matherr when
there is an error, then you should leave TARGET_EDOM undefined so
that matherr is used normally.
GEN_ERRNO_RTX
errno. (On certain systems,
errno may not actually be a variable.) If you don't define this
macro, a reasonable default is used.
TARGET_MEM_FUNCTIONS
memcpy and memset
rather than the BSD functions bcopy and bzero.
LIBGCC_NEEDS_DOUBLE
float arguments cannot be passed to
library routines (so they must be converted to double). This
macro affects both how library calls are generated and how the library
routines in `libgcc1.c' accept their arguments. It is useful on
machines where floating and fixed point arguments are passed
differently, such as the i860.
FLOAT_ARG_TYPE
float. (By default, they use a union
of float and int.)
The obvious choice would be float---but that won't work with
traditional C compilers that expect all arguments declared as float
to arrive as double. To avoid this conversion, the library routines
ask for the value as some other type and then treat it as a float.
On some systems, no other type will work for this. For these systems,
you must use LIBGCC_NEEDS_DOUBLE instead, to force conversion of
the values double before they are passed.
FLOATIFY (passed-value)
float argument as a float instead of the type it was
passed as. The default is an expression which takes the float
field of the union.
FLOAT_VALUE_TYPE
float. (By default, they
use int.)
The obvious choice would be float---but that won't work with
traditional C compilers gratuitously convert values declared as
float into double.
INTIFY (float-value)
float-returning library routine should be packaged in order to
return it. These functions are actually declared to return type
FLOAT_VALUE_TYPE (normally int).
These values can't be returned as type float because traditional
C compilers would gratuitously convert the value to a double.
A local variable named intify is always available when the macro
INTIFY is used. It is a union of a float field named
f and a field named i whose type is
FLOAT_VALUE_TYPE or int.
If you don't define this macro, the default definition works by copying
the value through that union.
nongcc_SI_type
SImode in the system's own C compiler.
You need not define this macro if that type is long int, as it usually
is.
nongcc_word_type
long int, as it usually
is.
perform_...
float and double in the
library routines in `libgcc1.c'. See that file for a full list
of these macros and their arguments.
On most machines, you don't need to define any of these macros, because
the C compiler that comes with the system takes care of doing them.
NEXT_OBJC_RUNTIME
This is about addressing modes.
HAVE_POST_INCREMENT
HAVE_PRE_INCREMENT
HAVE_POST_DECREMENT
HAVE_PRE_DECREMENT
CONSTANT_ADDRESS_P (x)
CONSTANT_P (x), but a few machines are more restrictive
in which constant addresses are supported.
CONSTANT_P accepts integer-values expressions whose values are
not explicitly known, such as symbol_ref, label_ref, and
high expressions and const arithmetic expressions, in
addition to const_int and const_double expressions.
MAX_REGS_PER_ADDRESS
GO_IF_LEGITIMATE_ADDRESS would ever
accept.
GO_IF_LEGITIMATE_ADDRESS (mode, x, label)
goto label;
executed if x (an RTX) is a legitimate memory address on the
target machine for a memory operand of mode mode.
It usually pays to define several simpler macros to serve as
subroutines for this one. Otherwise it may be too complicated to
understand.
This macro must exist in two variants: a strict variant and a
non-strict one. The strict variant is used in the reload pass. It
must be defined so that any pseudo-register that has not been
allocated a hard register is considered a memory reference. In
contexts where some kind of register is required, a pseudo-register
with no hard register must be rejected.
The non-strict variant is used in other passes. It must be defined to
accept all pseudo-registers in every context where some kind of
register is required.
Compiler source files that want to use the strict variant of this
macro define the macro REG_OK_STRICT. You should use an
#ifdef REG_OK_STRICT conditional to define the strict variant
in that case and the non-strict variant otherwise.
Subroutines to check for acceptable registers for various purposes (one
for base registers, one for index registers, and so on) are typically
among the subroutines used to define GO_IF_LEGITIMATE_ADDRESS.
Then only these subroutine macros need have two variants; the higher
levels of macros may be the same whether strict or not.
Normally, constant addresses which are the sum of a symbol_ref
and an integer are stored inside a const RTX to mark them as
constant. Therefore, there is no need to recognize such sums
specifically as legitimate addresses. Normally you would simply
recognize any const as legitimate.
Usually PRINT_OPERAND_ADDRESS is not prepared to handle constant
sums that are not marked with const. It assumes that a naked
plus indicates indexing. If so, then you must reject such
naked constant sums as illegitimate addresses, so that none of them will
be given to PRINT_OPERAND_ADDRESS.
On some machines, whether a symbolic address is legitimate depends on
the section that the address refers to. On these machines, define the
macro ENCODE_SECTION_INFO to store the information into the
symbol_ref, and then check for it here. When you see a
const, you will have to look inside it to find the
symbol_ref in order to determine the section. See section Defining the Output Assembler Language.
The best way to modify the name string is by adding text to the
beginning, with suitable punctuation to prevent any ambiguity. Allocate
the new name in saveable_obstack. You will have to modify
ASM_OUTPUT_LABELREF to remove and decode the added text and
output the name accordingly, and define STRIP_NAME_ENCODING to
access the original name string.
You can check the information stored here into the symbol_ref in
the definitions of the macros GO_IF_LEGITIMATE_ADDRESS and
PRINT_OPERAND_ADDRESS.
REG_OK_FOR_BASE_P (x)
reg
RTX) is valid for use as a base register. For hard registers, it
should always accept those which the hardware permits and reject the
others. Whether the macro accepts or rejects pseudo registers must be
controlled by REG_OK_STRICT as described above. This usually
requires two variant definitions, of which REG_OK_STRICT
controls the one actually used.
REG_OK_FOR_INDEX_P (x)
reg
RTX) is valid for use as an index register.
The difference between an index register and a base register is that
the index register may be scaled. If an address involves the sum of
two registers, neither one of them scaled, then either one may be
labeled the "base" and the other the "index"; but whichever
labeling is used must fit the machine's constraints of which registers
may serve in each capacity. The compiler will try both labelings,
looking for one that is valid, and will reload one or both registers
only if neither labeling works.
LEGITIMIZE_ADDRESS (x, oldx, mode, win)
GO_IF_LEGITIMATE_ADDRESS (mode, x, win);to avoid further processing if the address has become legitimate. x will always be the result of a call to
break_out_memory_refs,
and oldx will be the operand that was given to that function to produce
x.
The code generated by this macro should not alter the substructure of
x. If it transforms x into a more legitimate form, it
should assign x (which will always be a C variable) a new value.
It is not necessary for this macro to come up with a legitimate
address. The compiler has standard ways of doing so in all cases. In
fact, it is safe for this macro to do nothing. But often a
machine-dependent strategy can generate better code.
GO_IF_MODE_DEPENDENT_ADDRESS (addr, label)
goto
label; executed if memory address x (an RTX) can have
different meanings depending on the machine mode of the memory
reference it is used for or if the address is valid for some modes
but not others.
Autoincrement and autodecrement addresses typically have mode-dependent
effects because the amount of the increment or decrement is the size
of the operand being addressed. Some machines have other mode-dependent
addresses. Many RISC machines have no mode-dependent addresses.
You may assume that addr is a valid address for the machine.
LEGITIMATE_CONSTANT_P (x)
CONSTANT_P, so you need not check this. In fact,
`1' is a suitable definition for this macro on machines where
anything CONSTANT_P is valid.This describes the condition code status.
The file `conditions.h' defines a variable cc_status to
describe how the condition code was computed (in case the interpretation of
the condition code depends on the instruction that it was set by). This
variable contains the RTL expressions on which the condition code is
currently based, and several standard flags.
Sometimes additional machine-specific flags must be defined in the machine
description header file. It can also add additional machine-specific
information by defining CC_STATUS_MDEP.
CC_STATUS_MDEP
mdep
component of cc_status. It defaults to int.
This macro is not used on machines that do not use cc0.
CC_STATUS_MDEP_INIT
mdep field to "empty".
The default definition does nothing, since most machines don't use
the field anyway. If you want to use the field, you should probably
define this macro to initialize it.
This macro is not used on machines that do not use cc0.
NOTICE_UPDATE_CC (exp, insn)
cc_status
appropriately for an insn insn whose body is exp. It is
this macro's responsibility to recognize insns that set the condition
code as a byproduct of other activity as well as those that explicitly
set (cc0).
This macro is not used on machines that do not use cc0.
If there are insns that do not set the condition code but do alter
other machine registers, this macro must check to see whether they
invalidate the expressions that the condition code is recorded as
reflecting. For example, on the 68000, insns that store in address
registers do not set the condition code, which means that usually
NOTICE_UPDATE_CC can leave cc_status unaltered for such
insns. But suppose that the previous insn set the condition code
based on location `a4@(102)' and the current insn stores a new
value in `a4'. Although the condition code is not changed by
this, it will no longer be true that it reflects the contents of
`a4@(102)'. Therefore, NOTICE_UPDATE_CC must alter
cc_status in this case to say that nothing is known about the
condition code value.
The definition of NOTICE_UPDATE_CC must be prepared to deal
with the results of peephole optimization: insns whose patterns are
parallel RTXs containing various reg, mem or
constants which are just the operands. The RTL structure of these
insns is not sufficient to indicate what the insns actually do. What
NOTICE_UPDATE_CC should do when it sees one is just to run
CC_STATUS_INIT.
A possible definition of NOTICE_UPDATE_CC is to call a function
that looks at an attribute (see section Instruction Attributes) named, for example,
`cc'. This avoids having detailed information about patterns in
two places, the `md' file and in NOTICE_UPDATE_CC.
EXTRA_CC_MODES
enum machine_mode and all have class MODE_CC. By
convention, they should start with `CC' and end with `mode'.
You should only define this macro if your machine does not use cc0
and only if additional modes are required.
EXTRA_CC_NAMES
EXTRA_CC_MODES. For example, the Sparc defines this macro and
EXTRA_CC_MODES as
#define EXTRA_CC_MODES CC_NOOVmode, CCFPmode, CCFPEmode #define EXTRA_CC_NAMES "CC_NOOV", "CCFP", "CCFPE"This macro is not required if
EXTRA_CC_MODES is not defined.
SELECT_CC_MODE (op, x, y)
MODE_CC to be used when comparison
operation code op is applied to rtx x and y. For
example, on the Sparc, SELECT_CC_MODE is defined as (see
see section Defining Jump Instruction Patterns for a description of the reason for this
definition)
#define SELECT_CC_MODE(OP,X,Y) \
(GET_MODE_CLASS (GET_MODE (X)) == MODE_FLOAT \
? ((OP == EQ || OP == NE) ? CCFPmode : CCFPEmode) \
: ((GET_CODE (X) == PLUS || GET_CODE (X) == MINUS \
|| GET_CODE (X) == NEG) \
? CC_NOOVmode : CCmode))
You need not define this macro if EXTRA_CC_MODES is not defined.
CANONICALIZE_COMPARISON (code, op0, op1)
GT comparison, but you can use an LT
comparison instead and swap the order of the operands.
On such machines, define this macro to be a C statement to do any
required conversions. code is the initial comparison code
and op0 and op1 are the left and right operands of the
comparison, respectively. You should modify code, op0, and
op1 as required.
GNU CC will not assume that the comparison resulting from this macro is
valid but will see if the resulting insn matches a pattern in the
`md' file.
You need not define this macro if it would never change the comparison
code or operands.
REVERSIBLE_CC_MODE (mode)
SELECT_CC_MODE
can ever return mode for a floating-point inequality comparison,
then REVERSIBLE_CC_MODE (mode) must be zero.
You need not define this macro if it would always returns zero or if the
floating-point format is anything other than IEEE_FLOAT_FORMAT.
For example, here is the definition used on the Sparc, where floating-point
inequality comparisons are always given CCFPEmode:
#define REVERSIBLE_CC_MODE(MODE) ((MODE) != CCFPEmode)
These macros let you describe the relative speed of various operations on the target machine.
CONST_COSTS (x, code, outer_code)
switch statement that describes the relative costs
of constant RTL expressions. It must contain case labels for
expression codes const_int, const, symbol_ref,
label_ref and const_double. Each case must ultimately
reach a return statement to return the relative cost of the use
of that kind of constant value in an expression. The cost may depend on
the precise value of the constant, which is available for examination in
x, and the rtx code of the expression in which it is contained,
found in outer_code.
code is the expression code--redundant, since it can be
obtained with GET_CODE (x).
RTX_COSTS (x, code, outer_code)
CONST_COSTS but applies to nonconstant RTL expressions.
This can be used, for example, to indicate how costly a multiply
instruction is. In writing this macro, you can use the construct
COSTS_N_INSNS (n) to specify a cost equal to n fast
instructions. outer_code is the code of the expression in which
x is contained.
This macro is optional; do not define it if the default cost assumptions
are adequate for the target machine.
ADDRESS_COST (address)
CONST_COSTS values.
For most CISC machines, the default cost is a good approximation of the
true cost of the addressing mode. However, on RISC machines, all
instructions normally have the same length and execution time. Hence
all addresses will have equal costs.
In cases where more than one form of an address is known, the form with
the lowest cost will be used. If multiple forms have the same, lowest,
cost, the one that is the most complex will be used.
For example, suppose an address that is equal to the sum of a register
and a constant is used twice in the same basic block. When this macro
is not defined, the address will be computed in a register and memory
references will be indirect through that register. On machines where
the cost of the addressing mode containing the sum is no higher than
that of a simple indirect reference, this will produce an additional
instruction and possibly require an additional register. Proper
specification of this macro eliminates this overhead for such machines.
Similar use of this macro is made in strength reduction of loops.
address need not be valid as an address. In such a case, the cost
is not relevant and can be any value; invalid addresses need not be
assigned a different cost.
On machines where an address involving more than one register is as
cheap as an address computation involving only one register, defining
ADDRESS_COST to reflect this can cause two registers to be live
over a region of code where only one would have been if
ADDRESS_COST were not defined in that manner. This effect should
be considered in the definition of this macro. Equivalent costs should
probably only be given to addresses with different numbers of registers
on machines with lots of registers.
This macro will normally either not be defined or be defined as a
constant.
REGISTER_MOVE_COST (from, to)
GENERAL_REGS. A value of 4 is the
default; other values are interpreted relative to that.
It is not required that the cost always equal 2 when from is the
same as to; on some machines it is expensive to move between
registers if they are not general registers.
If reload sees an insn consisting of a single set between two
hard registers, and if REGISTER_MOVE_COST applied to their
classes returns a value of 2, reload does not check to ensure that the
constraints of the insn are met. Setting a cost of other than 2 will
allow reload to verify that the constraints are met. You should do this
if the `movm' pattern's constraints do not allow such copying.
MEMORY_MOVE_COST (m)
REGISTER_MOVE_COST.
If moving between registers and memory is more expensive than between
two registers, you should define this macro to express the relative cost.
BRANCH_COST
Here are additional macros which do not specify precise relative costs, but only that certain actions are more expensive than GNU CC would ordinarily expect.
SLOW_BYTE_ACCESS
char or a short) is no
faster than accessing a word of memory, i.e., if such access
require more than one instruction or if there is no difference in cost
between byte and (aligned) word loads.
When this macro is not defined, the compiler will access a field by
finding the smallest containing object; when it is defined, a fullword
load will be used if alignment permits. Unless bytes accesses are
faster than word accesses, using word accesses is preferable since it
may eliminate subsequent memory access if subsequent accesses occur to
other fields in the same word of the structure, but to different bytes.
SLOW_ZERO_EXTEND
char or short
to an int) can be done faster if the destination is a register
that is known to be zero.
If you define this macro, you must have instruction patterns that
recognize RTL structures like this:
(set (strict_low_part (subreg:QI (reg:SI ...) 0)) ...)and likewise for
HImode.
SLOW_UNALIGNED_ACCESS
STRICT_ALIGNMENT were non-zero when generating code for block
moves. This can cause significantly more instructions to be produced.
Therefore, do not set this macro non-zero if unaligned accesses only add a
cycle or two to the time for a memory access.
If the value of this macro is always zero, it need not be defined.
DONT_REDUCE_ADDR
MOVE_RATIO
NO_FUNCTION_CSE
NO_RECURSIVE_FUNCTION_CSE
ADJUST_COST (insn, link, dep_insn, cost)
An object file is divided into sections containing different types of data. In the most common case, there are three sections: the text section, which holds instructions and read-only data; the data section, which holds initialized writable data; and the bss section, which holds uninitialized data. Some systems have other kinds of sections.
The compiler must tell the assembler when to switch sections. These macros control what commands to output to tell the assembler this. You can also define additional sections.
TEXT_SECTION_ASM_OP
".text" is right.
DATA_SECTION_ASM_OP
".data" is right.
SHARED_SECTION_ASM_OP
DATA_SECTION_ASM_OP will be used.
INIT_SECTION_ASM_OP
EXTRA_SECTIONS
in_text and in_data. You need not define this macro
on a system with no other sections (that GCC needs to use).
EXTRA_SECTION_FUNCTIONS
text_section and
data_section, for your additional sections. Do not define this
macro if you do not define EXTRA_SECTIONS.
READONLY_DATA_SECTION
data_section or a function defined in EXTRA_SECTIONS) that
switches to the section to be used for read-only items.
If these items should be placed in the text section, this macro should
not be defined.
SELECT_SECTION (exp, reloc)
VAR_DECL node or a constant of some sort. reloc
indicates whether the initial value of exp requires link-time
relocations. Select the section by calling text_section or one
of the alternatives for other sections.
Do not define this macro if you put all read-only variables and
constants in the read-only data section (usually the text section).
SELECT_RTX_SECTION (mode, rtx)
const_int rtx. Select the section by
calling text_section or one of the alternatives for other
sections.
Do not define this macro if you put all constants in the read-only
data section.
JUMP_TABLES_IN_TEXT_SECTION
tablejump insns) should be
output in the text section, along with the assembler instructions.
Otherwise, the readonly data section is used.
This macro is irrelevant if there is no separate readonly data section.
ENCODE_SECTION_INFO (decl)
DECL_RTL (decl).
The value of the rtl will be a mem whose address is a
symbol_ref.
The usual thing for this macro to do is to record a flag in the
symbol_ref (such as SYMBOL_REF_FLAG) or to store a
modified name string in the symbol_ref (if one bit is not enough
information).
STRIP_NAME_ENCODING (var, sym_name)
ENCODE_SECTION_INFO alters the symbol's name string.
This section describes macros that help implement generation of position
independent code. Simply defining these macros is not enough to
generate valid PIC; you must also add support to the macros
GO_IF_LEGITIMATE_ADDRESS and PRINT_OPERAND_ADDRESS, as
well as LEGITIMIZE_ADDRESS. You must modify the definition of
`movsi' to do something appropriate when the source operand
contains a symbolic address. You may also need to alter the handling of
switch statements so that they use relative addresses.
PIC_OFFSET_TABLE_REGNUM
PIC_OFFSET_TABLE_REG_CALL_CLOBBERED
PIC_OFFSET_TABLE_REGNUM is clobbered by calls. Do not define
this macro if PPIC_OFFSET_TABLE_REGNUM is not defined.
FINALIZE_PIC
FINALIZE_PIC macro serves as a hook to emit these special
codes once the function is being compiled into assembly code, but not
before. (It is not done before, because in the case of compiling an
inline function, it would lead to multiple PIC prologues being
included in functions which used inline functions and were compiled to
assembly language.)
LEGITIMATE_PIC_OPERAND_P (x)
CONSTANT_P, so you need not
check this. You can also assume flag_pic is true, so you need not
check it either. You need not define this macro if all constants
(including SYMBOL_REF) can be immediate operands when generating
position independent code.
This section describes macros whose principal purpose is to describe how to write instructions in assembler language--rather than what the instructions do.
This describes the overall framework of an assembler file.
ASM_FILE_START (stream)
ASM_FILE_END (stream)
ASM_IDENTIFY_GCC (file)
ASM_COMMENT_START
ASM_APP_ON
asm
statement or group of consecutive ones. Normally this is
"#APP", which is a comment that has no effect on most
assemblers but tells the GNU assembler that it must check the lines
that follow for all valid assembler constructs.
ASM_APP_OFF
asm
statement or group of consecutive ones. Normally this is
"#NO_APP", which tells the GNU assembler to resume making the
time-saving assumptions that are valid for ordinary compiler output.
ASM_OUTPUT_SOURCE_FILENAME (stream, name)
ASM_OUTPUT_SOURCE_LINE (stream, line)
ASM_OUTPUT_IDENT (stream, string)
ASM_OUTPUT_SECTION_NAME (stream, decl, name)
FUNCTION_DECL, a
VAR_DECL or NULL_TREE. Some target formats do not support
arbitrary sections. Do not define this macro in such cases.
At present this macro is only used to support section attributes.
When this macro is undefined, section attributes are disabled.
OBJC_PROLOGUE
This describes data output.
ASM_OUTPUT_LONG_DOUBLE (stream, value)
ASM_OUTPUT_DOUBLE (stream, value)
ASM_OUTPUT_FLOAT (stream, value)
ASM_OUTPUT_THREE_QUARTER_FLOAT (stream, value)
ASM_OUTPUT_SHORT_FLOAT (stream, value)
ASM_OUTPUT_BYTE_FLOAT (stream, value)
TFmode,
DFmode, SFmode, TQFmode, HFmode, or
QFmode, respectively, whose value is value. value
will be a C expression of type REAL_VALUE_TYPE. Macros such as
REAL_VALUE_TO_TARGET_DOUBLE are useful for writing these
definitions.
ASM_OUTPUT_QUADRUPLE_INT (stream, exp)
ASM_OUTPUT_DOUBLE_INT (stream, exp)
ASM_OUTPUT_INT (stream, exp)
ASM_OUTPUT_SHORT (stream, exp)
ASM_OUTPUT_CHAR (stream, exp)
UNITS_PER_WORD, if the action of a macro
would be identical to repeatedly calling the macro corresponding to
a size of UNITS_PER_WORD, once for each word, you need not define
the macro.
ASM_OUTPUT_BYTE (stream, value)
ASM_BYTE_OP
"byte".
ASM_OUTPUT_ASCII (stream, ptr, len)
char * and len a C expression of type int.
If the assembler has a .ascii pseudo-op as found in the
Berkeley Unix assembler, do not define the macro
ASM_OUTPUT_ASCII.
ASM_OUTPUT_POOL_PROLOGUE (file funname fundecl size)
ASM_OUTPUT_SPECIAL_POOL_ENTRY (file, x, mode, align, labelno, jumpto)
ASM_OUTPUT_INTERNAL_LABEL (file, "LC", labelno);When you output a pool entry specially, you should end with a
goto to the label jumpto. This will prevent the same pool
entry from being output a second time in the usual manner.
You need not define this macro if it would do nothing.
IS_ASM_LOGICAL_LINE_SEPARATOR (C)
ASM_OPEN_PAREN
ASM_CLOSE_PAREN
#define ASM_OPEN_PAREN "("
#define ASM_CLOSE_PAREN ")"
These macros are provided by `real.h' for writing the definitions
of ASM_OUTPUT_DOUBLE and the like:
REAL_VALUE_TO_TARGET_SINGLE (x, l)
REAL_VALUE_TO_TARGET_DOUBLE (x, l)
REAL_VALUE_TO_TARGET_LONG_DOUBLE (x, l)
REAL_VALUE_TYPE, to the target's
floating point representation, and store its bit pattern in the array of
long int whose address is l. The number of elements in the
output array is determined by the size of the desired target floating
point data type: 32 bits of it go in each long int array
element. Each array element holds 32 bits of the result, even if
long int is wider than 32 bits on the host machine.
The array element values are designed so that you can print them out
using fprintf in the order they should appear in the target
machine's memory.
REAL_VALUE_TO_DECIMAL (x, format, string)
REAL_VALUE_TYPE, to a
decimal number and stores it as a string into string.
You must pass, as string, the address of a long enough block
of space to hold the result.
The argument format is a printf-specification that serves
as a suggestion for how to format the output string.
Each of the macros in this section is used to do the whole job of outputting a single uninitialized variable.
ASM_OUTPUT_COMMON (stream, name, size, rounded)
assemble_name (stream, name) to
output the name itself; before and after that, output the additional
assembler syntax for defining the name, and a newline.
This macro controls how the assembler definitions of uninitialized
global variables are output.
ASM_OUTPUT_ALIGNED_COMMON (stream, name, size, alignment)
ASM_OUTPUT_COMMON except takes the required alignment as a
separate, explicit argument. If you define this macro, it is used in
place of ASM_OUTPUT_COMMON, and gives you more flexibility in
handling the required alignment of the variable. The alignment is specified
as the number of bits.
ASM_OUTPUT_SHARED_COMMON (stream, name, size, rounded)
ASM_OUTPUT_COMMON, except that it
is used when name is shared. If not defined, ASM_OUTPUT_COMMON
will be used.
ASM_OUTPUT_LOCAL (stream, name, size, rounded)
assemble_name (stream, name) to
output the name itself; before and after that, output the additional
assembler syntax for defining the name, and a newline.
This macro controls how the assembler definitions of uninitialized
static variables are output.
ASM_OUTPUT_ALIGNED_LOCAL (stream, name, size, alignment)
ASM_OUTPUT_LOCAL except takes the required alignment as a
separate, explicit argument. If you define this macro, it is used in
place of ASM_OUTPUT_LOCAL, and gives you more flexibility in
handling the required alignment of the variable. The alignment is specified
as the number of bits.
ASM_OUTPUT_SHARED_LOCAL (stream, name, size, rounded)
ASM_OUTPUT_LOCAL, except that it
is used when name is shared. If not defined, ASM_OUTPUT_LOCAL
will be used.
This is about outputting labels.
ASM_OUTPUT_LABEL (stream, name)
assemble_name (stream, name) to
output the name itself; before and after that, output the additional
assembler syntax for defining the name, and a newline.
ASM_DECLARE_FUNCTION_NAME (stream, name, decl)
ASM_OUTPUT_LABEL). The argument decl is the
FUNCTION_DECL tree node representing the function.
If this macro is not defined, then the function name is defined in the
usual manner as a label (by means of ASM_OUTPUT_LABEL).
ASM_DECLARE_FUNCTION_SIZE (stream, name, decl)
FUNCTION_DECL tree node
representing the function.
If this macro is not defined, then the function size is not defined.
ASM_DECLARE_OBJECT_NAME (stream, name, decl)
ASM_OUTPUT_LABEL). The argument
decl is the VAR_DECL tree node representing the variable.
If this macro is not defined, then the variable name is defined in the
usual manner as a label (by means of ASM_OUTPUT_LABEL).
ASM_FINISH_DECLARE_OBJECT (stream, decl, toplevel, atend)
ASM_GLOBALIZE_LABEL (stream, name)
assemble_name (stream, name) to output the name
itself; before and after that, output the additional assembler syntax
for making that name global, and a newline.
ASM_WEAKEN_LABEL
assemble_name (stream, name) to output the name
itself; before and after that, output the additional assembler syntax
for making that name weak, and a newline.
If you don't define this macro, GNU CC will not support weak
symbols and you should not define the SUPPORTS_WEAK macro.
SUPPORTS_WEAK
ASM_WEAKEN_LABEL is defined, the default
definition is `1'; otherwise, it is `0'. Define this macro if
you want to control weak symbol support with a compiler flag such as
`-melf'.
ASM_OUTPUT_EXTERNAL (stream, decl, name)
ASM_OUTPUT_EXTERNAL_LIBCALL (stream, symref)
rtx and
is a symbol_ref.
This macro need not be defined if it does not need to output anything.
The GNU assembler and most Unix assemblers don't require anything.
ASM_OUTPUT_LABELREF (stream, name)
assemble_name.
ASM_OUTPUT_INTERNAL_LABEL (stream, prefix, num)
fprintf (stream, "L%s%d:\n", prefix, num)
ASM_GENERATE_INTERNAL_LABEL (string, prefix, num)
assemble_name, should
produce the output that ASM_OUTPUT_INTERNAL_LABEL would produce
with the same prefix and num.
If the string begins with `*', then assemble_name will
output the rest of the string unchanged. It is often convenient for
ASM_GENERATE_INTERNAL_LABEL to use `*' in this way. If the
string doesn't start with `*', then ASM_OUTPUT_LABELREF gets
to output the string, and may change it. (Of course,
ASM_OUTPUT_LABELREF is also part of your machine description, so
you should know what it does on your machine.)
ASM_FORMAT_PRIVATE_NAME (outvar, name, number)
char *) a newly allocated string made from the string
name and the number number, with some suitable punctuation
added. Use alloca to get space for the string.
The string will be used as an argument to ASM_OUTPUT_LABELREF to
produce an assembler label for an internal static variable whose name is
name. Therefore, the string must be such as to result in valid
assembler code. The argument number is different each time this
macro is executed; it prevents conflicts between similarly-named
internal static variables in different scopes.
Ideally this string should not be a valid C identifier, to prevent any
conflict with the user's own symbols. Most assemblers allow periods
or percent signs in assembler symbols; putting at least one of these
between the name and the number will suffice.
ASM_OUTPUT_DEF (stream, name, value)
OBJC_GEN_METHOD_LABEL (buf, is_inst, class_name, cat_name, sel_name)
char * which gives you a
buffer in which to store the name; its length is as long as
class_name, cat_name and sel_name put together, plus
50 characters extra.
The argument is_inst specifies whether the method is an instance
method or a class method; class_name is the name of the class;
cat_name is the name of the category (or NULL if the method is not
in a category); and sel_name is the name of the selector.
On systems where the assembler can handle quoted names, you can use this
macro to provide more human-readable names.
The compiled code for certain languages includes constructors
(also called initialization routines)---functions to initialize
data in the program when the program is started. These functions need
to be called before the program is "started"---that is to say, before
main is called.
Compiling some languages generates destructors (also called termination routines) that should be called when the program terminates.
To make the initialization and termination functions work, the compiler must output something in the assembler code to cause those functions to be called at the appropriate time. When you port the compiler to a new system, you need to specify how to do this.
There are two major ways that GCC currently supports the execution of initialization and termination functions. Each way has two variants. Much of the structure is common to all four variations.
The linker must build two lists of these functions--a list of
initialization functions, called __CTOR_LIST__, and a list of
termination functions, called __DTOR_LIST__.
Each list always begins with an ignored function pointer (which may hold 0, -1, or a count of the function pointers after it, depending on the environment). This is followed by a series of zero or more function pointers to constructors (or destructors), followed by a function pointer containing zero.
Depending on the operating system and its executable file format, either `crtstuff.c' or `libgcc2.c' traverses these lists at startup time and exit time. Constructors are called in reverse order of the list; destructors in forward order.
The best way to handle static constructors works only for object file formats which provide arbitrarily-named sections. A section is set aside for a list of constructors, and another for a list of destructors. Traditionally these are called `.ctors' and `.dtors'. Each object file that defines an initialization function also puts a word in the constructor section to point to that function. The linker accumulates all these words into one contiguous `.ctors' section. Termination functions are handled similarly.
To use this method, you need appropriate definitions of the macros
ASM_OUTPUT_CONSTRUCTOR and ASM_OUTPUT_DESTRUCTOR. Usually
you can get them by including `svr4.h'.
When arbitrary sections are available, there are two variants, depending
upon how the code in `crtstuff.c' is called. On systems that
support an init section which is executed at program startup,
parts of `crtstuff.c' are compiled into that section. The
program is linked by the gcc driver like this:
ld -o output_file crtbegin.o ... crtend.o -lgcc
The head of a function (__do_global_ctors) appears in the init
section of `crtbegin.o'; the remainder of the function appears in
the init section of `crtend.o'. The linker will pull these two
parts of the section together, making a whole function. If any of the
user's object files linked into the middle of it contribute code, then that
code will be executed as part of the body of __do_global_ctors.
To use this variant, you must define the INIT_SECTION_ASM_OP
macro properly.
If no init section is available, do not define
INIT_SECTION_ASM_OP. Then __do_global_ctors is built into
the text section like all other functions, and resides in
`libgcc.a'. When GCC compiles any function called main, it
inserts a procedure call to __main as the first executable code
after the function prologue. The __main function, also defined
in `libgcc2.c', simply calls `__do_global_ctors'.
In file formats that don't support arbitrary sections, there are again
two variants. In the simplest variant, the GNU linker (GNU ld)
and an `a.out' format must be used. In this case,
ASM_OUTPUT_CONSTRUCTOR is defined to produce a .stabs
entry of type `N_SETT', referencing the name __CTOR_LIST__,
and with the address of the void function containing the initialization
code as its value. The GNU linker recognizes this as a request to add
the value to a "set"; the values are accumulated, and are eventually
placed in the executable as a vector in the format described above, with
a leading (ignored) count and a trailing zero element.
ASM_OUTPUT_DESTRUCTOR is handled similarly. Since no init
section is available, the absence of INIT_SECTION_ASM_OP causes
the compilation of main to call __main as above, starting
the initialization process.
The last variant uses neither arbitrary sections nor the GNU linker.
This is preferable when you want to do dynamic linking and when using
file formats which the GNU linker does not support, such as `ECOFF'. In
this case, ASM_OUTPUT_CONSTRUCTOR does not produce an
N_SETT symbol; initialization and termination functions are
recognized simply by their names. This requires an extra program in the
linkage step, called collect2. This program pretends to be the
linker, for use with GNU CC; it does its job by running the ordinary
linker, but also arranges to include the vectors of initialization and
termination functions. These functions are called via __main as
described above.
Choosing among these configuration options has been simplified by a set of operating-system-dependent files in the `config' subdirectory. These files define all of the relevant parameters. Usually it is sufficient to include one into your specific machine-dependent configuration file. These files are:
Here are the macros that control how the compiler handles initialization and termination functions:
INIT_SECTION_ASM_OP
HAS_INIT_SECTION
main will not call __main as described above.
This macro should be defined for systems that control the contents of the
init section on a symbol-by-symbol basis, such as OSF/1, and should not
be defined explicitly for systems that support
INIT_SECTION_ASM_OP.
LD_INIT_SWITCH
LD_FINI_SWITCH
INVOKE__main
main will call __main despite the presence of
INIT_SECTION_ASM_OP. This macro should be defined for systems
where the init section is not actually run automatically, but is still
useful for collecting the lists of constructors and destructors.
ASM_OUTPUT_CONSTRUCTOR (stream, name)
assemble_name to output the name name; this
performs any system-specific syntactic transformations such as adding an
underscore.
If you don't define this macro, nothing special is output to arrange to
call the function. This is correct when the function will be called in
some other manner--for example, by means of the collect2 program,
which looks through the symbol table to find these functions by their
names.
ASM_OUTPUT_DESTRUCTOR (stream, name)
ASM_OUTPUT_CONSTRUCTOR but used for termination
functions rather than initialization functions.
If your system uses collect2 as the means of processing
constructors, then that program normally uses nm to scan an
object file for constructor functions to be called. On certain kinds of
systems, you can define these macros to make collect2 work faster
(and, in some cases, make it work at all):
OBJECT_FORMAT_COFF
collect2 can assume this format and scan
object files directly for dynamic constructor/destructor functions.
OBJECT_FORMAT_ROSE
collect2 can assume this format and scan object files directly
for dynamic constructor/destructor functions.
These macros are effective only in a native compiler; collect2 as
part of a cross compiler always uses nm for the target machine.
REAL_NM_FILE_NAME
nm. The default is to search the path normally for
nm.
If your system supports shared libraries and has a program to list the
dynamic dependencies of a given library or executable, you can define
these macros to enable support for running initialization and
termination functions in shared libraries:
LDD_SUFFIX
"ldd" under SunOS 4.
PARSE_LDD_OUTPUT (PTR)
LDD_SUFFIX. PTR is a variable
of type char * that points to the beginning of a line of output
from LDD_SUFFIX. If the line lists a dynamic dependency, the
code must advance PTR to the beginning of the filename on that
line. Otherwise, it must set PTR to NULL.
This describes assembler instruction output.
REGISTER_NAMES
ADDITIONAL_REGISTER_NAMES
asm option in declarations to refer
to registers using alternate names.
ASM_OUTPUT_OPCODE (stream, ptr)
char * which
points to the opcode name in its "internal" form--the form that is
written in the machine description. The definition should output the
opcode name to stream, performing any translation you desire, and
increment the variable ptr to point at the end of the opcode
so that it will not be output twice.
In fact, your macro definition may process less than the entire opcode
name, or more than the opcode name; but if you want to process text
that includes `%'-sequences to substitute operands, you must take
care of the substitution yourself. Just be sure to increment
ptr over whatever text should not be output normally.
If you need to look at the operand values, they can be found as the
elements of recog_operand.
If the macro definition does nothing, the instruction is output
in the usual way.
FINAL_PRESCAN_INSN (insn, opvec, noperands)
PRINT_OPERAND (stream, x, code)
reg_names whose type is
char *[]. reg_names is initialized from
REGISTER_NAMES.
When the machine description has a specification `%punct'
(a `%' followed by a punctuation character), this macro is called
with a null pointer for x and the punctuation character for
code.
PRINT_OPERAND_PUNCT_VALID_P (code)
PRINT_OPERAND macro. If
PRINT_OPERAND_PUNCT_VALID_P is not defined, it means that no
punctuation characters (except for the standard one, `%') are used
in this way.
PRINT_OPERAND_ADDRESS (stream, x)
ENCODE_SECTION_INFO to store the information into the
symbol_ref, and then check for it here. See section Defining the Output Assembler Language.
DBR_OUTPUT_SEQEND(file)
dbr_sequence_length to
determine the number of slots filled in a sequence (zero if not
currently outputting a sequence), to decide how many no-ops to output,
or whatever.
Don't define this macro if it has nothing to do, but it is helpful in
reading assembly output if the extent of the delay sequence is made
explicit (e.g. with white space).
Note that output routines for instructions with delay slots must be
prepared to deal with not being output as part of a sequence (i.e.
when the scheduling pass is not run, or when no slot fillers could be
found.) The variable final_sequence is null when not
processing a sequence, otherwise it contains the sequence rtx
being output.
REGISTER_PREFIX
LOCAL_LABEL_PREFIX
USER_LABEL_PREFIX
IMMEDIATE_PREFIX
asm_fprintf (see
`final.c'). These are useful when a single `md' file must
support multiple assembler formats. In that case, the various `tm.h'
files can define these macros differently.
ASSEMBLER_DIALECT
asm_fprintf. This construct outputs `option0',
`option1' or `option2', etc., if the value of
ASSEMBLER_DIALECT is zero, one or two, etc. Any special
characters within these strings retain their usual meaning.
If you do not define this macro, the characters `{', `|' and
`}' do not have any special meaning when used in templates or
operands to asm_fprintf.
Define the macros REGISTER_PREFIX, LOCAL_LABEL_PREFIX,
USER_LABEL_PREFIX and IMMEDIATE_PREFIX if you can express
the variations in assemble language syntax with that mechanism. Define
ASSEMBLER_DIALECT and use the `{option0|option1}' syntax
if the syntax variant are larger and involve such things as different
opcodes or operand order.
ASM_OUTPUT_REG_PUSH (stream, regno)
ASM_OUTPUT_REG_POP (stream, regno)
This concerns dispatch tables.
ASM_OUTPUT_ADDR_DIFF_ELT (stream, value, rel)
ASM_OUTPUT_INTERNAL_LABEL, and they must be printed in the same
way here. For example,
fprintf (stream, "\t.word L%d-L%d\n",
value, rel)
ASM_OUTPUT_ADDR_VEC_ELT (stream, value)
ASM_OUTPUT_INTERNAL_LABEL.
For example,
fprintf (stream, "\t.word L%d\n", value)
ASM_OUTPUT_CASE_LABEL (stream, prefix, num, table)
ASM_OUTPUT_INTERNAL_LABEL; the fourth argument is the
jump-table which follows (a jump_insn containing an
addr_vec or addr_diff_vec).
This feature is used on system V to output a swbeg statement
for the table.
If this macro is not defined, these labels are output with
ASM_OUTPUT_INTERNAL_LABEL.
ASM_OUTPUT_CASE_END (stream, num, table)
This describes commands for alignment.
ASM_OUTPUT_ALIGN_CODE (file)
ASM_OUTPUT_LOOP_ALIGN (file)
ASM_OUTPUT_SKIP (stream, nbytes)
int.
ASM_NO_SKIP_IN_TEXT
ASM_OUTPUT_SKIP should not be used in the
text section because it fails put zeros in the bytes that are skipped.
This is true on many Unix systems, where the pseudo--op to skip bytes
produces no-op instructions rather than zeros when used in the text
section.
ASM_OUTPUT_ALIGN (stream, power)
int.
This describes how to specify debugging information.
These macros affect all debugging formats.
DBX_REGISTER_NUMBER (regno)
DBX_REGISTER_NUMBER.
Otherwise, debuggers will be unable to access such a pair, because they
expect register pairs to be consecutive in their own numbering scheme.
If you find yourself defining DBX_REGISTER_NUMBER in way that
does not preserve register pairs, then what you must do instead is
redefine the actual register numbering scheme.
DEBUGGER_AUTO_OFFSET (x)
DEBUGGER_ARG_OFFSET (offset, x)
PREFERRED_DEBUGGING_TYPE
DBX_DEBUG,
SDB_DEBUG, DWARF_DEBUG, and XCOFF_DEBUG.
The value of this macro only affects the default debugging output; the
user can always get a specific type of output by using `-gstabs',
`-gcoff', `-gdwarf', or `-gxcoff'.
These are specific options for DBX output.
DBX_DEBUGGING_INFO
XCOFF_DEBUGGING_INFO
DEFAULT_GDB_EXTENSIONS
DEBUG_SYMS_TEXT
.stabs commands should be output while
in the text section.
ASM_STABS_OP
.stabs to define an ordinary debugging symbol. If you don't
define this macro, .stabs is used. This macro applies only to
DBX debugging information format.
ASM_STABD_OP
.stabd to define a debugging symbol whose value is the current
location. If you don't define this macro, .stabd is used.
This macro applies only to DBX debugging information format.
ASM_STABN_OP
.stabn to define a debugging symbol with no name. If you don't
define this macro, .stabn is used. This macro applies only to
DBX debugging information format.
DBX_NO_XREFS
DBX_CONTIN_LENGTH
.stabs directives) when it
exceeds a certain length (by default, 80 characters). On some
operating systems, DBX requires this splitting; on others, splitting
must not be done. You can inhibit splitting by defining this macro
with the value zero. You can override the default splitting-length by
defining this macro as an expression for the length you desire.
DBX_CONTIN_CHAR
.stabs string when a continuation follows. To use
a different character instead, define this macro as a character
constant for the character you want to use. Do not define this macro
if backslash is correct for your system.
DBX_STATIC_STAB_DATA_SECTION
DBX_TYPE_DECL_STABS_CODE
.stabs directive
for a typedef. The default is N_LSYM.
DBX_STATIC_CONST_VAR_CODE
.stabs directive
for a static variable located in the text section. DBX format does not
provide any "right" way to do this. The default is N_FUN.
DBX_REGPARM_STABS_CODE
.stabs directive
for a parameter passed in registers. DBX format does not provide any
"right" way to do this. The default is N_RSYM.
DBX_REGPARM_STABS_LETTER
'P'.
DBX_MEMPARM_STABS_LETTER
'p'.
DBX_FUNCTION_FIRST
DBX_LBRAC_FIRST
N_LBRAC symbol for a block should
precede the debugging information for variables and functions defined in
that block. Normally, in DBX format, the N_LBRAC symbol comes
first.
DBX_BLOCKS_FUNCTION_RELATIVE
N_LBRAC or N_RBRAC) should be relative to the start
of the enclosing function. Normally, GNU C uses an absolute address.
These are hooks for DBX format.
DBX_OUTPUT_LBRAC (stream, name)
assemble_name) whose value is the address where the scope begins.
DBX_OUTPUT_RBRAC (stream, name)
DBX_OUTPUT_LBRAC, but for the end of a scope level.
DBX_OUTPUT_ENUM (stream, type)
DBX_OUTPUT_FUNCTION_END (stream, function)
FUNCTION_DECL node for
the function.
DBX_OUTPUT_STANDARD_TYPES (syms)
tree which is a chain of all the predefined
global symbols, including names of data types.
Normally, DBX output starts with definitions of the types for integers
and characters, followed by all the other predefined types of the
particular language in no particular order.
On some machines, it is necessary to output different particular types
first. To do this, define DBX_OUTPUT_STANDARD_TYPES to output
those symbols in the necessary order. Any predefined types that you
don't explicitly output will be output afterward in no particular order.
Be careful not to define this macro so that it works only for C. There
are no global variables to access most of the built-in types, because
another language may have another set of types. The way to output a
particular type is to look through syms to see if you can find it.
Here is an example:
{
tree decl;
for (decl = syms; decl; decl = TREE_CHAIN (decl))
if (!strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)),
"long int"))
dbxout_symbol (decl);
...
}
This does nothing if the expected type does not exist.
See the function init_decl_processing in `c-decl.c' to find
the names to use for all the built-in C types.
Here is another way of finding a particular type:
{
tree decl;
for (decl = syms; decl; decl = TREE_CHAIN (decl))
if (TREE_CODE (decl) == TYPE_DECL
&& (TREE_CODE (TREE_TYPE (decl))
== INTEGER_CST)
&& TYPE_PRECISION (TREE_TYPE (decl)) == 16
&& TYPE_UNSIGNED (TREE_TYPE (decl)))
/* This must be unsigned short. */
dbxout_symbol (decl);
...
}
This describes file names in DBX format.
DBX_WORKING_DIRECTORY
DBX_OUTPUT_MAIN_SOURCE_FILENAME (stream, name)
DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (stream, name)
DBX_OUTPUT_MAIN_SOURCE_FILE_END (stream, name)
DBX_OUTPUT_SOURCE_FILENAME (stream, name)
Here are macros for SDB and DWARF output.
SDB_DEBUGGING_INFO
DWARF_DEBUGGING_INFO
PUT_SDB_...
SDB_DELIM
PUT_SDB_op macros if this is the only change
required.
SDB_GENERATE_FAKE
SDB_ALLOW_UNKNOWN_REFERENCES
SDB_ALLOW_FORWARD_REFERENCES
While all modern machines use 2's complement representation for integers, there are a variety of representations for floating point numbers. This means that in a cross-compiler the representation of floating point numbers in the compiled program may be different from that used in the machine doing the compilation.
Because different representation systems may offer different amounts of
range and precision, the cross compiler cannot safely use the host
machine's floating point arithmetic. Therefore, floating point constants
must be represented in the target machine's format. This means that the
cross compiler cannot use atof to parse a floating point constant;
it must have its own special routine to use instead. Also, constant
folding must emulate the target machine's arithmetic (or must not be done
at all).
The macros in the following table should be defined only if you are cross compiling between different floating point formats.
Otherwise, don't define them. Then default definitions will be set up which
use double as the data type, == to test for equality, etc.
You don't need to worry about how many times you use an operand of any of these macros. The compiler never uses operands which have side effects.
REAL_VALUE_TYPE
struct containing an array of int.
REAL_VALUES_EQUAL (x, y)
REAL_VALUE_TYPE.
REAL_VALUES_LESS (x, y)
REAL_VALUE_TYPE and
interpreted as floating point numbers in the target machine's
representation.
REAL_VALUE_LDEXP (x, scale)
ldexp, but using the target machine's floating point
representation. Both x and the value of the expression have
type REAL_VALUE_TYPE. The second argument, scale, is an
integer.
REAL_VALUE_FIX (x)
REAL_VALUE_TYPE.
REAL_VALUE_UNSIGNED_FIX (x)
REAL_VALUE_TYPE.
REAL_VALUE_RNDZINT (x)
REAL_VALUE_TYPE,
and so does the value.
REAL_VALUE_UNSIGNED_RNDZINT (x)
REAL_VALUE_TYPE, and so does the value.
REAL_VALUE_ATOF (string, mode)
char *, into a floating point number in the target machine's
representation for mode mode. The value has type
REAL_VALUE_TYPE.
REAL_INFINITY
REAL_VALUE_ISINF (x)
int.
By default, this is defined to call isinf.
REAL_VALUE_ISNAN (x)
int. By default, this is defined to call isnan.
Define the following additional macros if you want to make floating point constant folding work while cross compiling. If you don't define them, cross compilation is still possible, but constant folding will not happen for floating point values.
REAL_ARITHMETIC (output, code, x, y)
REAL_VALUE_TYPE in the target machine's representation, to
produce a result of the same type and representation which is stored
in output (which will be a variable).
The operation to be performed is specified by code, a tree code
which will always be one of the following: PLUS_EXPR,
MINUS_EXPR, MULT_EXPR, RDIV_EXPR,
MAX_EXPR, MIN_EXPR.
The expansion of this macro is responsible for checking for overflow.
If overflow happens, the macro expansion should execute the statement
return 0;, which indicates the inability to perform the
arithmetic operation requested.
REAL_VALUE_NEGATE (x)
REAL_VALUE_TYPE and are in the target machine's
floating point representation.
There is no way for this macro to report overflow, since overflow
can't happen in the negation operation.
REAL_VALUE_TRUNCATE (mode, x)
REAL_VALUE_TYPE.
However, the value should have an appropriate bit pattern to be output
properly as a floating constant whose precision accords with mode
mode.
There is no way for this macro to report overflow.
REAL_VALUE_TO_INT (low, high, x)
REAL_VALUE_FROM_INT (x, low, high)
Here are several miscellaneous parameters.
PREDICATE_CODES
#define PREDICATE_CODES \
{"gen_reg_rtx_operand", {SUBREG, REG}}, \
{"reg_or_short_cint_operand", {SUBREG, REG, CONST_INT}},
Defining this macro does not affect the generated code (however,
incorrect definitions that omit an rtl code that may be matched by the
predicate can cause the compiler to malfunction). Instead, it allows
the table built by `genrecog' to be more compact and efficient,
thus speeding up the compiler. The most important predicates to include
in the list specified by this macro are thoses used in the most insn
patterns.
CASE_VECTOR_MODE
CASE_VECTOR_PC_RELATIVE
CASE_DROPS_THROUGH
case insn when the index
value is out of range. This means the specified default-label is
actually ignored by the case insn proper.
CASE_VALUES_THRESHOLD
casesi instruction and
five otherwise. This is best for most machines.
WORD_REGISTER_OPERATIONS
LOAD_EXTEND_OP (mode)
SIGN_EXTEND for values
of mode for which the
insn sign-extends, ZERO_EXTEND for which it zero-extends, and
NIL for other modes.
This macro is not called with mode non-integral or with a width
greater than or equal to BITS_PER_WORD, so you may return any
value in this case. Do not define this macro if it would always return
NIL. On machines where this macro is defined, you will normally
define it as the constant SIGN_EXTEND or ZERO_EXTEND.
IMPLICIT_FIX_EXPR
FIX_ROUND_EXPR is used.
FIXUNS_TRUNC_LIKE_FIX_TRUNC
EASY_DIV_EXPR
TRUNC_DIV_EXPR, FLOOR_DIV_EXPR, CEIL_DIV_EXPR or
ROUND_DIV_EXPR. These four division operators differ in how
they round the result to an integer. EASY_DIV_EXPR is used
when it is permissible to use any of those kinds of division and the
choice should be made on the basis of efficiency.
MOVE_MAX
MAX_MOVE_MAX
MOVE_MAX. Otherwise, it is the constant value that is the
largest value that MOVE_MAX can have at run-time.
SHIFT_COUNT_TRUNCATED
SHIFT_COUNT_TRUNCATED
also enables deletion of truncations of the values that serve as
arguments to bitfield instructions.
If both types of instructions truncate the count (for shifts) and
position (for bitfield operations), or if no variable-position bitfield
instructions exist, you should define this macro.
However, on some machines, such as the 80386 and the 680x0, truncation
only applies to shift operations and not the (real or pretended)
bitfield operations. Define SHIFT_COUNT_TRUNCATED to be zero on
such machines. Instead, add patterns to the `md' file that include
the implied truncation of the shift instructions.
You need not define this macro if it would always have the value of zero.
TRULY_NOOP_TRUNCATION (outprec, inprec)
TRULY_NOOP_TRUNCATION returns 1 for a pair of sizes for
modes for which MODES_TIEABLE_P is 0, suboptimal code can result.
If this is the case, making TRULY_NOOP_TRUNCATION return 0 in
such cases may improve things.
STORE_FLAG_VALUE
MODE_INT mode.
A value of 1 or -1 means that the instruction implementing the
comparison operator returns exactly 1 or -1 when the comparison is true
and 0 when the comparison is false. Otherwise, the value indicates
which bits of the result are guaranteed to be 1 when the comparison is
true. This value is interpreted in the mode of the comparison
operation, which is given by the mode of the first operand in the
`scond' pattern. Either the low bit or the sign bit of
STORE_FLAG_VALUE be on. Presently, only those bits are used by
the compiler.
If STORE_FLAG_VALUE is neither 1 or -1, the compiler will
generate code that depends only on the specified bits. It can also
replace comparison operators with equivalent operations if they cause
the required bits to be set, even if the remaining bits are undefined.
For example, on a machine whose comparison operators return an
SImode value and where STORE_FLAG_VALUE is defined as
`0x80000000', saying that just the sign bit is relevant, the
expression
(ne:SI (and:SI x (const_int power-of-2)) (const_int 0))can be converted to
(ashift:SI x (const_int n))where n is the appropriate shift count to move the bit being tested into the sign bit. There is no way to describe a machine that always sets the low-order bit for a true value, but does not guarantee the value of any other bits, but we do not know of any machine that has such an instruction. If you are trying to port GNU CC to such a machine, include an instruction to perform a logical-and of the result with 1 in the pattern for the comparison operators and let us know (see section How to Report Bugs). Often, a machine will have multiple instructions that obtain a value from a comparison (or the condition codes). Here are rules to guide the choice of value for
STORE_FLAG_VALUE, and hence the instructions
to be used:
STORE_FLAG_VALUE. It is more efficient for the compiler to
"normalize" the value (convert it to, e.g., 1 or 0) than for the
comparison operators to do so because there may be opportunities to
combine the normalization with other operations.
STORE_FLAG_VALUE and its negation in the same number of
instructions. On those machines, you should also define a pattern for
those cases, e.g., one matching
(set A (neg:m (ne:m B C)))Some machines can also perform
and or plus operations on
condition code values with less instructions than the corresponding
`scond' insn followed by and or plus. On those
machines, define the appropriate patterns. Use the names incscc
and decscc, respectively, for the the patterns which perform
plus or minus operations on condition code values. See
`rs6000.md' for some examples. The GNU Superoptizer can be used to
find such instruction sequences on other machines.
You need not define STORE_FLAG_VALUE if the machine has no store-flag
instructions.
FLOAT_STORE_FLAG_VALUE
Pmode
SImode on 32-bit machine or DImode on 64-bit machines.
On some machines you must define this to be one of the partial integer
modes, such as PSImode.
The width of Pmode must be at least as large as the value of
POINTER_SIZE. If it is not equal, you must define the macro
POINTERS_EXTEND_UNSIGNED to specify how pointers are extended
to Pmode.
FUNCTION_MODE
call RTL expressions. On most machines this
should be QImode.
INTEGRATE_THRESHOLD (decl)
FUNCTION_DECL node.
The default definition of this macro is 64 plus 8 times the number of
arguments that the function accepts. Some people think a larger
threshold should be used on RISC machines.
SCCS_DIRECTIVE
#sccs directives
and print no error message.
NO_IMPLICIT_EXTERN_C
HANDLE_PRAGMA (stream)
#pragma is seen. The
argument stream is the stdio input stream from which the source
text can be read.
It is generally a bad idea to implement new uses of #pragma. The
only reason to define this macro is for compatibility with other
compilers that do support #pragma for the sake of any user
programs which already use it.
VALID_MACHINE_DECL_ATTRIBUTE (decl, attributes, identifier, args)
VALID_MACHINE_TYPE_ATTRIBUTE (type, attributes, identifier, args)
COMP_TYPE_ATTRIBUTES (type1, type2)
SET_DEFAULT_TYPE_ATTRIBUTES (type)
DOLLARS_IN_IDENTIFIERS
NO_DOLLAR_IN_LABEL
NO_DOT_IN_LABEL
DEFAULT_MAIN_RETURN
main
function to return a standard "success" value by default (if no other
value is explicitly returned).
The definition should be a C statement (sans semicolon) to generate the
appropriate rtl instructions. It is used only when compiling the end of
main.
HAVE_ATEXIT
atexit from the ANSI C standard. If this is not defined,
and INIT_SECTION_ASM_OP is not defined, a default
exit function will be provided to support C++.
EXIT_BODY
exit function needs to do something
besides calling an external function _cleanup before
terminating with _exit. The EXIT_BODY macro is
only needed if netiher HAVE_ATEXIT nor
INIT_SECTION_ASM_OP are defined.
INSN_SETS_ARE_DELAYED (insn)
jump_insn or an insn; GNU CC knows that
every call_insn has this behavior. On machines where some insn
or jump_insn is really a function call and hence has this behavior,
you should define this macro.
You need not define this macro if it would always return zero.
INSN_REFERENCES_ARE_DELAYED (insn)
jump_insn or an insn. On machines where
some insn or jump_insn is really a function call and its operands
are registers whose use is actually in the subroutine it calls, you should
define this macro. Doing so allows the delay slot scheduler to move
instructions which copy arguments into the argument registers into the delay
slot of insn.
You need not define this macro if it would always return zero.
MACHINE_DEPENDENT_REORG (insn)
Most of the work of the compiler is done on an intermediate representation called register transfer language. In this language, the instructions to be output are described, pretty much one by one, in an algebraic form that describes what the instruction does.
RTL is inspired by Lisp lists. It has both an internal form, made up of structures that point at other structures, and a textual form that is used in the machine description and in printed debugging dumps. The textual form uses nested parentheses to indicate the pointers in the internal form.
RTL uses five kinds of objects: expressions, integers, wide integers,
strings and vectors. Expressions are the most important ones. An RTL
expression ("RTX", for short) is a C structure, but it is usually
referred to with a pointer; a type that is given the typedef name
rtx.
An integer is simply an int; their written form uses decimal digits.
A wide integer is an integral object whose type is HOST_WIDE_INT
(see section The Configuration File); their written form uses decimal digits.
A string is a sequence of characters. In core it is represented as a
char * in usual C fashion, and it is written in C syntax as well.
However, strings in RTL may never be null. If you write an empty string in
a machine description, it is represented in core as a null pointer rather
than as a pointer to a null character. In certain contexts, these null
pointers instead of strings are valid. Within RTL code, strings are most
commonly found inside symbol_ref expressions, but they appear in
other contexts in the RTL expressions that make up machine descriptions.
A vector contains an arbitrary number of pointers to expressions. The number of elements in the vector is explicitly present in the vector. The written form of a vector consists of square brackets (`[...]') surrounding the elements, in sequence and with whitespace separating them. Vectors of length zero are not created; null pointers are used instead.
Expressions are classified by expression codes (also called RTX
codes). The expression code is a name defined in `rtl.def', which is
also (in upper case) a C enumeration constant. The possible expression
codes and their meanings are machine-independent. The code of an RTX can
be extracted with the macro GET_CODE (x) and altered with
PUT_CODE (x, newcode).
The expression code determines how many operands the expression contains,
and what kinds of objects they are. In RTL, unlike Lisp, you cannot tell
by looking at an operand what kind of object it is. Instead, you must know
from its context--from the expression code of the containing expression.
For example, in an expression of code subreg, the first operand is
to be regarded as an expression and the second operand as an integer. In
an expression of code plus, there are two operands, both of which
are to be regarded as expressions. In a symbol_ref expression,
there is one operand, which is to be regarded as a string.
Expressions are written as parentheses containing the name of the expression type, its flags and machine mode if any, and then the operands of the expression (separated by spaces).
Expression code names in the `md' file are written in lower case,
but when they appear in C code they are written in upper case. In this
manual, they are shown as follows: const_int.
In a few contexts a null pointer is valid where an expression is normally
wanted. The written form of this is (nil).
For each expression type `rtl.def' specifies the number of
contained objects and their kinds, with four possibilities: `e' for
expression (actually a pointer to an expression), `i' for integer,
`w' for wide integer, `s' for string, and `E' for vector
of expressions. The sequence of letters for an expression code is
called its format. Thus, the format of subreg is
`ei'.
A few other format characters are used occasionally:
u
n
note insn.
S
V
0
There are macros to get the number of operands, the format, and the class of an expression code:
GET_RTX_LENGTH (code)
GET_RTX_FORMAT (code)
GET_RTX_CLASS (code)
o
reg or
mem. subreg is not in this class.
<
NE, EQ, LE, LT, GE, GT,
LEU, LTU, GEU, GTU.
1
neg.
c
NE
and EQ (which have class `<').
2
MINUS.
b
ZERO_EXTRACT or
SIGN_EXTRACT.
3
IF_THEN_ELSE.
i
INSN, JUMP_INSN, and
CALL_INSN).
m
MATCH_DUP.
x
Operands of expressions are accessed using the macros XEXP,
XINT, XWINT and XSTR. Each of these macros takes
two arguments: an expression-pointer (RTX) and an operand number
(counting from zero). Thus,
XEXP (x, 2)
accesses operand 2 of expression x, as an expression.
XINT (x, 2)
accesses the same operand as an integer. XSTR, used in the same
fashion, would access it as a string.
Any operand can be accessed as an integer, as an expression or as a string. You must choose the correct method of access for the kind of value actually stored in the operand. You would do this based on the expression code of the containing expression. That is also how you would know how many operands there are.
For example, if x is a subreg expression, you know that it has
two operands which can be correctly accessed as XEXP (x, 0)
and XINT (x, 1). If you did XINT (x, 0), you
would get the address of the expression operand but cast as an integer;
that might occasionally be useful, but it would be cleaner to write
(int) XEXP (x, 0). XEXP (x, 1) would also
compile without error, and would return the second, integer operand cast as
an expression pointer, which would probably result in a crash when
accessed. Nothing stops you from writing XEXP (x, 28) either,
but this will access memory past the end of the expression with
unpredictable results.
Access to operands which are vectors is more complicated. You can use the
macro XVEC to get the vector-pointer itself, or the macros
XVECEXP and XVECLEN to access the elements and length of a
vector.
XVEC (exp, idx)
XVECLEN (exp, idx)
int.
XVECEXP (exp, idx, eltnum)
XVECLEN (exp, idx).
All the macros defined in this section expand into lvalues and therefore can be used to assign the operands, lengths and vector elements as well as to access them.
RTL expressions contain several flags (one-bit bitfields) that are used in certain types of expression. Most often they are accessed with the following macros:
MEM_VOLATILE_P (x)
mem expressions, nonzero for volatile memory references.
Stored in the volatil field and printed as `/v'.
MEM_IN_STRUCT_P (x)
mem expressions, nonzero for reference to an entire
structure, union or array, or to a component of one. Zero for
references to a scalar variable or through a pointer to a scalar.
Stored in the in_struct field and printed as `/s'.
REG_LOOP_TEST_P
reg expressions, nonzero if this register's entire life is
contained in the exit test code for some loop. Stored in the
in_struct field and printed as `/s'.
REG_USERVAR_P (x)
reg, nonzero if it corresponds to a variable present in
the user's source code. Zero for temporaries generated internally by
the compiler. Stored in the volatil field and printed as
`/v'.
REG_FUNCTION_VALUE_P (x)
reg if it is the place in which this function's
value is going to be returned. (This happens only in a hard
register.) Stored in the integrated field and printed as
`/i'.
The same hard register may be used also for collecting the values of
functions called by this one, but REG_FUNCTION_VALUE_P is zero
in this kind of use.
SUBREG_PROMOTED_VAR_P
subreg if it was made when accessing an object that
was promoted to a wider mode in accord with the PROMOTED_MODE machine
description macro (see section Storage Layout). In this case, the mode of
the subreg is the declared mode of the object and the mode of
SUBREG_REG is the mode of the register that holds the object.
Promoted variables are always either sign- or zero-extended to the wider
mode on every assignment. Stored in the in_struct field and
printed as `/s'.
SUBREG_PROMOTED_UNSIGNED_P
subreg that has SUBREG_PROMOTED_VAR_P nonzero
if the object being referenced is kept zero-extended and zero if it
is kept sign-extended. Stored in the unchanging field and
printed as `/u'.
RTX_UNCHANGING_P (x)
reg or mem if the value is not changed.
(This flag is not set for memory references via pointers to constants.
Such pointers only guarantee that the object will not be changed
explicitly by the current function. The object might be changed by
other functions or by aliasing.) Stored in the
unchanging field and printed as `/u'.
RTX_INTEGRATED_P (insn)
integrated field and printed as `/i'. This
may be deleted; nothing currently depends on it.
SYMBOL_REF_USED (x)
symbol_ref, indicates that x has been used. This is
normally only used to ensure that x is only declared external
once. Stored in the used field.
SYMBOL_REF_FLAG (x)
symbol_ref, this is used as a flag for machine-specific purposes.
Stored in the volatil field and printed as `/v'.
LABEL_OUTSIDE_LOOP_P
label_ref expressions, nonzero if this is a reference to a
label that is outside the innermost loop containing the reference to the
label. Stored in the in_struct field and printed as `/s'.
INSN_DELETED_P (insn)
volatil field and printed as `/v'.
INSN_ANNULLED_BRANCH_P (insn)
insn in the delay slot of a branch insn, indicates that an
annulling branch should be used. See the discussion under
sequence below. Stored in the unchanging field and printed
as `/u'.
INSN_FROM_TARGET_P (insn)
insn in a delay slot of a branch, indicates that the insn
is from the target of the branch. If the branch insn has
INSN_ANNULLED_BRANCH_P set, this insn should only be executed if
the branch is taken. For annulled branches with this bit clear, the
insn should be executed only if the branch is not taken. Stored in the
in_struct field and printed as `/s'.
CONSTANT_POOL_ADDRESS_P (x)
symbol_ref if it refers to part of the current
function's "constants pool". These are addresses close to the
beginning of the function, and GNU CC assumes they can be addressed
directly (perhaps with the help of base registers). Stored in the
unchanging field and printed as `/u'.
CONST_CALL_P (x)
call_insn, indicates that the insn represents a call to a const
function. Stored in the unchanging field and printed as `/u'.
LABEL_PRESERVE_P (x)
code_label, indicates that the label can never be deleted.
Labels referenced by a non-local goto will have this bit set. Stored
in the in_struct field and printed as `/s'.
SCHED_GROUP_P (insn)
use insns before a call_insn may
not be separated from the call_insn. Stored in the in_struct
field and printed as `/s'.
These are the fields which the above macros refer to:
used
symbol_ref, it indicates that an external declaration for
the symbol has already been written.
In a reg, it is used by the leaf register renumbering code to ensure
that each register is only renumbered once.
volatil
mem, symbol_ref and reg
expressions and in insns. In RTL dump files, it is printed as
`/v'.
In a mem expression, it is 1 if the memory reference is volatile.
Volatile memory references may not be deleted, reordered or combined.
In a symbol_ref expression, it is used for machine-specific
purposes.
In a reg expression, it is 1 if the value is a user-level variable.
0 indicates an internal compiler temporary.
In an insn, 1 means the insn has been deleted.
in_struct
mem expressions, it is 1 if the memory datum referred to is
all or part of a structure or array; 0 if it is (or might be) a scalar
variable. A reference through a C pointer has 0 because the pointer
might point to a scalar variable. This information allows the compiler
to determine something about possible cases of aliasing.
In an insn in the delay slot of a branch, 1 means that this insn is from
the target of the branch.
During instruction scheduling, in an insn, 1 means that this insn must be
scheduled as part of a group together with the previous insn.
In reg expressions, it is 1 if the register has its entire life
contained within the test expression of some loop.
In subreg expressions, 1 means that the subreg is accessing
an object that has had its mode promoted from a wider mode.
In label_ref expressions, 1 means that the referenced label is
outside the innermost loop containing the insn in which the label_ref
was found.
In code_label expressions, it is 1 if the label may never be deleted.
This is used for labels which are the target of non-local gotos.
In an RTL dump, this flag is represented as `/s'.
unchanging
reg and mem expressions, 1 means
that the value of the expression never changes.
In subreg expressions, it is 1 if the subreg references an
unsigned object whose mode has been promoted to a wider mode.
In an insn, 1 means that this is an annulling branch.
In a symbol_ref expression, 1 means that this symbol addresses
something in the per-function constants pool.
In a call_insn, 1 means that this instruction is a call to a
const function.
In an RTL dump, this flag is represented as `/u'.
integrated
reg expression, this flag indicates the register
containing the value to be returned by the current function. On
machines that pass parameters in registers, the same register number
may be used for parameters as well, but this flag is not set on such
uses.
A machine mode describes a size of data object and the representation used
for it. In the C code, machine modes are represented by an enumeration
type, enum machine_mode, defined in `machmode.def'. Each RTL
expression has room for a machine mode and so do certain kinds of tree
expressions (declarations and types, to be precise).
In debugging dumps and machine descriptions, the machine mode of an RTL
expression is written after the expression code with a colon to separate
them. The letters `mode' which appear at the end of each machine mode
name are omitted. For example, (reg:SI 38) is a reg
expression with machine mode SImode. If the mode is
VOIDmode, it is not written at all.
Here is a table of machine modes. The term "byte" below refers to an
object of BITS_PER_UNIT bits (see section Storage Layout).
QImode
HImode
PSImode
SImode
PDImode
DImode
TImode
SFmode
DFmode
XFmode
TFmode
CCmode
cc0 (see see section Condition Code Status).
BLKmode
BLKmode will not appear in RTL.
VOIDmode
const_int have mode
VOIDmode because they can be taken to have whatever mode the context
requires. In debugging dumps of RTL, VOIDmode is expressed by
the absence of any mode.
SCmode, DCmode, XCmode, TCmode
SFmode,
DFmode, XFmode, and TFmode, respectively.
CQImode, CHImode, CSImode, CDImode, CTImode, COImode
QImode, HImode,
SImode, DImode, TImode, and OImode,
respectively.
The machine description defines Pmode as a C macro which expands
into the machine mode used for addresses. Normally this is the mode
whose size is BITS_PER_WORD, SImode on 32-bit machines.
The only modes which a machine description must support are
QImode, and the modes corresponding to BITS_PER_WORD,
FLOAT_TYPE_SIZE and DOUBLE_TYPE_SIZE.
The compiler will attempt to use DImode for 8-byte structures and
unions, but this can be prevented by overriding the definition of
MAX_FIXED_MODE_SIZE. Alternatively, you can have the compiler
use TImode for 16-byte structures and unions. Likewise, you can
arrange for the C type short int to avoid using HImode.
Very few explicit references to machine modes remain in the compiler and
these few references will soon be removed. Instead, the machine modes
are divided into mode classes. These are represented by the enumeration
type enum mode_class defined in `machmode.h'. The possible
mode classes are:
MODE_INT
QImode, HImode,
SImode, DImode, and TImode.
MODE_PARTIAL_INT
PSImode and PDImode.
MODE_FLOAT
SFmode, DFmode,
XFmode and TFmode.
MODE_COMPLEX_INT
MODE_COMPLEX_FLOAT
SCmode,
DCmode, XCmode, and TCmode.
MODE_FUNCTION
MODE_CC
CCmode plus
any modes listed in the EXTRA_CC_MODES macro. See section Defining Jump Instruction Patterns,
also see section Condition Code Status.
MODE_RANDOM
VOIDmode and BLKmode are in
MODE_RANDOM.
Here are some C macros that relate to machine modes:
GET_MODE (x)
PUT_MODE (x, newmode)
NUM_MACHINE_MODES
GET_MODE_NAME (m)
GET_MODE_CLASS (m)
GET_MODE_WIDER_MODE (m)
GET_MODE_WIDER_MODE (QImode) returns HImode.
GET_MODE_SIZE (m)
GET_MODE_BITSIZE (m)
GET_MODE_MASK (m)
HOST_BITS_PER_INT.
GET_MODE_ALIGNMENT (m))
GET_MODE_UNIT_SIZE (m)
GET_MODE_SIZE except in the case of complex
modes. For them, the unit size is the size of the real or imaginary
part.
GET_MODE_NUNITS (m)
GET_MODE_SIZE divided by GET_MODE_UNIT_SIZE.
GET_CLASS_NARROWEST_MODE (c)
The global variables byte_mode and word_mode contain modes
whose classes are MODE_INT and whose bitsizes are either
BITS_PER_UNIT or BITS_PER_WORD, respectively. On 32-bit
machines, these are QImode and SImode, respectively.
The simplest RTL expressions are those that represent constant values.
(const_int i)
INTVAL as in
INTVAL (exp), which is equivalent to XWINT (exp, 0).
There is only one expression object for the integer value zero; it is
the value of the variable const0_rtx. Likewise, the only
expression for integer value one is found in const1_rtx, the only
expression for integer value two is found in const2_rtx, and the
only expression for integer value negative one is found in
constm1_rtx. Any attempt to create an expression of code
const_int and value zero, one, two or negative one will return
const0_rtx, const1_rtx, const2_rtx or
constm1_rtx as appropriate.
Similarly, there is only one object for the integer whose value is
STORE_FLAG_VALUE. It is found in const_true_rtx. If
STORE_FLAG_VALUE is one, const_true_rtx and
const1_rtx will point to the same object. If
STORE_FLAG_VALUE is -1, const_true_rtx and
constm1_rtx will point to the same object.
(const_double:m addr i0 i1 ...)
HOST_BITS_PER_WIDE_INT
bits but small enough to fit within twice that number of bits (GNU CC
does not provide a mechanism to represent even larger constants). In
the latter case, m will be VOIDmode.
addr is used to contain the mem expression that corresponds
to the location in memory that at which the constant can be found. If
it has not been allocated a memory location, but is on the chain of all
const_double expressions in this compilation (maintained using an
undisplayed field), addr contains const0_rtx. If it is not
on the chain, addr contains cc0_rtx. addr is
customarily accessed with the macro CONST_DOUBLE_MEM and the
chain field via CONST_DOUBLE_CHAIN.
If m is VOIDmode, the bits of the value are stored in
i0 and i1. i0 is customarily accessed with the macro
CONST_DOUBLE_LOW and i1 with CONST_DOUBLE_HIGH.
If the constant is floating point (regardless of its precision), then
the number of integers used to store the value depends on the size of
REAL_VALUE_TYPE (see section Cross Compilation and Floating Point). The integers
represent a floating point number, but not precisely in the target
machine's or host machine's floating point format. To convert them to
the precise bit pattern used by the target machine, use the macro
REAL_VALUE_TO_TARGET_DOUBLE and friends (see section Output of Data).
The macro CONST0_RTX (mode) refers to an expression with
value 0 in mode mode. If mode mode is of mode class
MODE_INT, it returns const0_rtx. Otherwise, it returns a
CONST_DOUBLE expression in mode mode. Similarly, the macro
CONST1_RTX (mode) refers to an expression with value 1 in
mode mode and similarly for CONST2_RTX.
(const_string str)
(symbol_ref:mode symbol)
symbol_ref contains a mode, which is usually Pmode.
Usually that is the only mode for which a symbol is directly valid.
(label_ref label)
code_label that appears
in the instruction sequence to identify the place where the label
should go.
The reason for using a distinct expression type for code label
references is so that jump optimization can distinguish them.
(const:m exp)
const_int, symbol_ref and
label_ref expressions) combined with plus and
minus. However, not all combinations are valid, since the
assembler cannot do arbitrary arithmetic on relocatable symbols.
m should be Pmode.
(high:m exp)
symbol_ref. The number of bits is machine-dependent and is
normally the number of bits specified in an instruction that initializes
the high order bits of a register. It is used with lo_sum to
represent the typical two-instruction sequence used in RISC machines to
reference a global memory location.
m should be Pmode.
Here are the RTL expression types for describing access to machine registers and to main memory.
(reg:m n)
FIRST_PSEUDO_REGISTER), this stands for a reference to machine
register number n: a hard register. For larger values of
n, it stands for a temporary value or pseudo register.
The compiler's strategy is to generate code assuming an unlimited
number of such pseudo registers, and later convert them into hard
registers or into memory references.
m is the machine mode of the reference. It is necessary because
machines can generally refer to each register in more than one mode.
For example, a register may contain a full word but there may be
instructions to refer to it as a half word or as a single byte, as
well as instructions to refer to it as a floating point number of
various precisions.
Even for a register that the machine can access in only one mode,
the mode must always be specified.
The symbol FIRST_PSEUDO_REGISTER is defined by the machine
description, since the number of hard registers on the machine is an
invariant characteristic of the machine. Note, however, that not
all of the machine registers must be general registers. All the
machine registers that can be used for storage of data are given
hard register numbers, even those that can be used only in certain
instructions or can hold only certain types of data.
A hard register may be accessed in various modes throughout one
function, but each pseudo register is given a natural mode
and is accessed only in that mode. When it is necessary to describe
an access to a pseudo register using a nonnatural mode, a subreg
expression is used.
A reg expression with a machine mode that specifies more than
one word of data may actually stand for several consecutive registers.
If in addition the register number specifies a hardware register, then
it actually represents several consecutive hardware registers starting
with the specified one.
Each pseudo register number used in a function's RTL code is
represented by a unique reg expression.
Some pseudo register numbers, those within the range of
FIRST_VIRTUAL_REGISTER to LAST_VIRTUAL_REGISTER only
appear during the RTL generation phase and are eliminated before the
optimization phases. These represent locations in the stack frame that
cannot be determined until RTL generation for the function has been
completed. The following virtual register numbers are defined:
VIRTUAL_INCOMING_ARGS_REGNUM
ARG_POINTER_REGNUM and the
value of FIRST_PARM_OFFSET.
VIRTUAL_STACK_VARS_REGNUM
FRAME_GROWS_DOWNWARD is defined, this points to immediately
above the first variable on the stack. Otherwise, it points to the
first variable on the stack.
VIRTUAL_STACK_VARS_REGNUM is replaced with the sum of the
register given by FRAME_POINTER_REGNUM and the value
STARTING_FRAME_OFFSET.
VIRTUAL_STACK_DYNAMIC_REGNUM
STACK_POINTER_REGNUM and the value STACK_DYNAMIC_OFFSET.
VIRTUAL_OUTGOING_ARGS_REGNUM
STACK_POINTER_REGNUM).
This virtual register is replaced by the sum of the register given by
STACK_POINTER_REGNUM and the value STACK_POINTER_OFFSET.
(subreg:m reg wordnum)
subreg expressions are used to refer to a register in a machine
mode other than its natural one, or to refer to one register of
a multi-word reg that actually refers to several registers.
Each pseudo-register has a natural mode. If it is necessary to
operate on it in a different mode--for example, to perform a fullword
move instruction on a pseudo-register that contains a single
byte--the pseudo-register must be enclosed in a subreg. In
such a case, wordnum is zero.
Usually m is at least as narrow as the mode of reg, in which
case it is restricting consideration to only the bits of reg that
are in m.
Sometimes m is wider than the mode of reg. These
subreg expressions are often called paradoxical. They are
used in cases where we want to refer to an object in a wider mode but do
not care what value the additional bits have. The reload pass ensures
that paradoxical references are only made to hard registers.
The other use of subreg is to extract the individual registers of
a multi-register value. Machine modes such as DImode and
TImode can indicate values longer than a word, values which
usually require two or more consecutive registers. To access one of the
registers, use a subreg with mode SImode and a
wordnum that says which register.
Storing in a non-paradoxical subreg has undefined results for
bits belonging to the same word as the subreg. This laxity makes
it easier to generate efficient code for such instructions. To
represent an instruction that preserves all the bits outside of those in
the subreg, use strict_low_part around the subreg.
The compilation parameter WORDS_BIG_ENDIAN, if set to 1, says
that word number zero is the most significant part; otherwise, it is
the least significant part.
Between the combiner pass and the reload pass, it is possible to have a
paradoxical subreg which contains a mem instead of a
reg as its first operand. After the reload pass, it is also
possible to have a non-paradoxical subreg which contains a
mem; this usually occurs when the mem is a stack slot
which replaced a pseudo register.
Note that it is not valid to access a DFmode value in SFmode
using a subreg. On some machines the most significant part of a
DFmode value does not have the same format as a single-precision
floating value.
It is also not valid to access a single word of a multi-word value in a
hard register when less registers can hold the value than would be
expected from its size. For example, some 32-bit machines have
floating-point registers that can hold an entire DFmode value.
If register 10 were such a register (subreg:SI (reg:DF 10) 1)
would be invalid because there is no way to convert that reference to
a single machine register. The reload pass prevents subreg
expressions such as these from being formed.
The first operand of a subreg expression is customarily accessed
with the SUBREG_REG macro and the second operand is customarily
accessed with the SUBREG_WORD macro.
(scratch:m)
reg by either the local register allocator or
the reload pass.
scratch is usually present inside a clobber operation
(see section Side Effect Expressions).
(cc0)
(cc0) may be validly used in only two
contexts: as the destination of an assignment (in test and compare
instructions) and in comparison operators comparing against zero
(const_int with value zero; that is to say, const0_rtx).
(cc0) may be validly used in only two
contexts: as the destination of an assignment (in test and compare
instructions) where the source is a comparison operator, and as the
first operand of if_then_else (in a conditional branch).
cc0; it is the
value of the variable cc0_rtx. Any attempt to create an
expression of code cc0 will return cc0_rtx.
Instructions can set the condition code implicitly. On many machines,
nearly all instructions set the condition code based on the value that
they compute or store. It is not necessary to record these actions
explicitly in the RTL because the machine description includes a
prescription for recognizing the instructions that do so (by means of
the macro NOTICE_UPDATE_CC). See section Condition Code Status. Only
instructions whose sole purpose is to set the condition code, and
instructions that use the condition code, need mention (cc0).
On some machines, the condition code register is given a register number
and a reg is used instead of (cc0). This is usually the
preferable approach if only a small subset of instructions modify the
condition code. Other machines store condition codes in general
registers; in such cases a pseudo register should be used.
Some machines, such as the Sparc and RS/6000, have two sets of
arithmetic instructions, one that sets and one that does not set the
condition code. This is best handled by normally generating the
instruction that does not set the condition code, and making a pattern
that both performs the arithmetic and sets the condition code register
(which would not be (cc0) in this case). For examples, search
for `addcc' and `andcc' in `sparc.md'.
(pc)
(pc) may be validly used only in
certain specific contexts in jump instructions.
There is only one expression object of code pc; it is the value
of the variable pc_rtx. Any attempt to create an expression of
code pc will return pc_rtx.
All instructions that do not jump alter the program counter implicitly
by incrementing it, but there is no need to mention this in the RTL.
(mem:m addr)
Unless otherwise specified, all the operands of arithmetic expressions
must be valid for mode m. An operand is valid for mode m
if it has mode m, or if it is a const_int or
const_double and m is a mode of class MODE_INT.
For commutative binary operations, constants should be placed in the second operand.
(plus:m x y)
(lo_sum:m x y)
plus, except that it represents that sum of x and the
low-order bits of y. The number of low order bits is
machine-dependent but is normally the number of bits in a Pmode
item minus the number of bits set by the high code
(see section Constant Expression Types).
m should be Pmode.
(minus:m x y)
plus but represents subtraction.
(compare:m x y)
(cc0)
is used, it is VOIDmode. Otherwise it is some mode in class
MODE_CC, often CCmode. See section Condition Code Status.
Normally, x and y must have the same mode. Otherwise,
compare is valid only if the mode of x is in class
MODE_INT and y is a const_int or
const_double with mode VOIDmode. The mode of x
determines what mode the comparison is to be done in; thus it must not
be VOIDmode.
If one of the operands is a constant, it should be placed in the
second operand and the comparison code adjusted as appropriate.
A compare specifying two VOIDmode constants is not valid
since there is no way to know in what mode the comparison is to be
performed; the comparison must either be folded during the compilation
or the first operand must be loaded into a register while its mode is
still known.
(neg:m x)
(mult:m x y)
(mult:m (sign_extend:m x) (sign_extend:m y))where m is wider than the modes of x and y, which need not be the same. Write patterns for unsigned widening multiplication similarly using
zero_extend.
(div:m x y)
truncate and sign_extend as in,
(truncate:m1 (div:m2 x (sign_extend:m2 y)))
(udiv:m x y)
div but represents unsigned division.
(mod:m x y)
(umod:m x y)
div and udiv but represent the remainder instead of
the quotient.
(smin:m x y)
(smax:m x y)
smin) or larger (for smax) of
x and y, interpreted as signed integers in mode m.
(umin:m x y)
(umax:m x y)
smin and smax, but the values are interpreted as unsigned
integers.
(not:m x)
(and:m x y)
(ior:m x y)
(xor:m x y)
(ashift:m x c)
VOIDmode; which
mode is determined by the mode called for in the machine description
entry for the left-shift instruction. For example, on the Vax, the mode
of c is QImode regardless of m.
(lshiftrt:m x c)
(ashiftrt:m x c)
ashift but for right shift. Unlike the case for left shift,
these two operations are distinct.
(rotate:m x c)
(rotatert:m x c)
rotate.
(abs:m x)
(sqrt:m x)
(ffs:m x)
Comparison operators test a relation on two operands and are considered
to represent a machine-dependent nonzero value described by, but not
necessarily equal to, STORE_FLAG_VALUE (see section Miscellaneous Parameters)
if the relation holds, or zero if it does not. The mode of the
comparison operation is independent of the mode of the data being
compared. If the comparison operation is being tested (e.g., the first
operand of an if_then_else), the mode must be VOIDmode.
If the comparison operation is producing data to be stored in some
variable, the mode must be in class MODE_INT. All comparison
operations producing data must use the same mode, which is
machine-specific.
There are two ways that comparison operations may be used. The
comparison operators may be used to compare the condition codes
(cc0) against zero, as in (eq (cc0) (const_int 0)). Such
a construct actually refers to the result of the preceding instruction
in which the condition codes were set. The instructing setting the
condition code must be adjacent to the instruction using the condition
code; only note insns may separate them.
Alternatively, a comparison operation may directly compare two data objects. The mode of the comparison is determined by the operands; they must both be valid for a common machine mode. A comparison with both operands constant would be invalid as the machine mode could not be deduced from it, but such a comparison should never exist in RTL due to constant folding.
In the example above, if (cc0) were last set to
(compare x y), the comparison operation is
identical to (eq x y). Usually only one style
of comparisons is supported on a particular machine, but the combine
pass will try to merge the operations to produce the eq shown
in case it exists in the context of the particular insn involved.
Inequality comparisons come in two flavors, signed and unsigned. Thus,
there are distinct expression codes gt and gtu for signed and
unsigned greater-than. These can produce different results for the same
pair of integer values: for example, 1 is signed greater-than -1 but not
unsigned greater-than, because -1 when regarded as unsigned is actually
0xffffffff which is greater than 1.
The signed comparisons are also used for floating point values. Floating point comparisons are distinguished by the machine modes of the operands.
(eq:m x y)
(ne:m x y)
(gt:m x y)
(gtu:m x y)
gt but does unsigned comparison, on fixed-point numbers only.
(lt:m x y)
(ltu:m x y)
gt and gtu but test for "less than".
(ge:m x y)
(geu:m x y)
gt and gtu but test for "greater than or equal".
(le:m x y)
(leu:m x y)
gt and gtu but test for "less than or equal".
(if_then_else cond then else)
if_then_else expressions are valid only
to express conditional jumps.
(cond [test1 value1 test2 value2 ...] default)
if_then_else, but more general. Each of test1,
test2, ... is performed in turn. The result of this expression is
the value corresponding to the first non-zero test, or default if
none of the tests are non-zero expressions.
This is currently not valid for instruction patterns and is supported only
for insn attributes. See section Instruction Attributes.
Special expression codes exist to represent bitfield instructions. These types of expressions are lvalues in RTL; they may appear on the left side of an assignment, indicating insertion of a value into the specified bit field.
(sign_extract:m loc size pos)
BITS_BIG_ENDIAN says which end of the memory unit
pos counts from.
If loc is in memory, its mode must be a single-byte integer mode.
If loc is in a register, the mode to use is specified by the
operand of the insv or extv pattern
(see section Standard Pattern Names For Generation) and is usually a full-word integer mode.
The mode of pos is machine-specific and is also specified
in the insv or extv pattern.
The mode m is the same as the mode that would be used for
loc if it were a register.
(zero_extract:m loc size pos)
sign_extract but refers to an unsigned or zero-extended
bit field. The same sequence of bits are extracted, but they
are filled to an entire word with zeros instead of by sign-extension.
All conversions between machine modes must be represented by
explicit conversion operations. For example, an expression
which is the sum of a byte and a full word cannot be written as
(plus:SI (reg:QI 34) (reg:SI 80)) because the plus
operation requires two operands of the same machine mode.
Therefore, the byte-sized operand is enclosed in a conversion
operation, as in
(plus:SI (sign_extend:SI (reg:QI 34)) (reg:SI 80))
The conversion operation is not a mere placeholder, because there may be more than one way of converting from a given starting mode to the desired final mode. The conversion operation code says how to do it.
For all conversion operations, x must not be VOIDmode
because the mode in which to do the conversion would not be known.
The conversion must either be done at compile-time or x
must be placed into a register.
(sign_extend:m x)
(zero_extend:m x)
(float_extend:m x)
(truncate:m x)
(float_truncate:m x)
(float:m x)
(unsigned_float:m x)
(fix:m x)
(unsigned_fix:m x)
(fix:m x)
Declaration expression codes do not represent arithmetic operations but rather state assertions about their operands.
(strict_low_part (subreg:m (reg:n r) 0))
set expression. In addition, the operand of this expression
must be a non-paradoxical subreg expression.
The presence of strict_low_part says that the part of the
register which is meaningful in mode n, but is not part of
mode m, is not to be altered. Normally, an assignment to such
a subreg is allowed to have undefined effects on the rest of the
register when m is less than a word.
The expression codes described so far represent values, not actions. But machine instructions never produce values; they are meaningful only for their side effects on the state of the machine. Special expression codes are used to represent side effects.
The body of an instruction is always one of these side effect codes; the codes described above, which represent values, appear only as the operands of these.
(set lval x)
reg (or
subreg or strict_low_part), mem, pc or
cc0.
If lval is a reg, subreg or mem, it has a
machine mode; then x must be valid for that mode.
If lval is a reg whose machine mode is less than the full
width of the register, then it means that the part of the register
specified by the machine mode is given the specified value and the
rest of the register receives an undefined value. Likewise, if
lval is a subreg whose machine mode is narrower than
the mode of the register, the rest of the register can be changed in
an undefined way.
If lval is a strict_low_part of a subreg, then the
part of the register specified by the machine mode of the
subreg is given the value x and the rest of the register
is not changed.
If lval is (cc0), it has no machine mode, and x may
be either a compare expression or a value that may have any mode.
The latter case represents a "test" instruction. The expression
(set (cc0) (reg:m n)) is equivalent to
(set (cc0) (compare (reg:m n) (const_int 0))).
Use the former expression to save space during the compilation.
If lval is (pc), we have a jump instruction, and the
possibilities for x are very limited. It may be a
label_ref expression (unconditional jump). It may be an
if_then_else (conditional jump), in which case either the
second or the third operand must be (pc) (for the case which
does not jump) and the other of the two must be a label_ref
(for the case which does jump). x may also be a mem or
(plus:SI (pc) y), where y may be a reg or a
mem; these unusual patterns are used to represent jumps through
branch tables.
If lval is neither (cc0) nor (pc), the mode of
lval must not be VOIDmode and the mode of x must be
valid for the mode of lval.
lval is customarily accessed with the SET_DEST macro and
x with the SET_SRC macro.
(return)
return expression code is never used.
Inside an if_then_else expression, represents the value to be
placed in pc to return to the caller.
Note that an insn pattern of (return) is logically equivalent to
(set (pc) (return)), but the latter form is never used.
(call function nargs)
mem expression
whose address is the address of the function to be called.
nargs is an expression which can be used for two purposes: on
some machines it represents the number of bytes of stack argument; on
others, it represents the number of argument registers.
Each machine has a standard machine mode which function must
have. The machine description defines macro FUNCTION_MODE to
expand into the requisite mode name. The purpose of this mode is to
specify what kind of addressing is allowed, on machines where the
allowed kinds of addressing depend on the machine mode being
addressed.
(clobber x)
reg,
scratch or mem expression.
One place this is used is in string instructions that store standard
values into particular hard registers. It may not be worth the
trouble to describe the values that are stored, but it is essential to
inform the compiler that the registers will be altered, lest it
attempt to keep data in them across the string instruction.
If x is (mem:BLK (const_int 0)), it means that all memory
locations must be presumed clobbered.
Note that the machine description classifies certain hard registers as
"call-clobbered". All function call instructions are assumed by
default to clobber these registers, so there is no need to use
clobber expressions to indicate this fact. Also, each function
call is assumed to have the potential to alter any memory location,
unless the function is declared const.
If the last group of expressions in a parallel are each a
clobber expression whose arguments are reg or
match_scratch (see section RTL Template) expressions, the combiner
phase can add the appropriate clobber expressions to an insn it
has constructed when doing so will cause a pattern to be matched.
This feature can be used, for example, on a machine that whose multiply
and add instructions don't use an MQ register but which has an
add-accumulate instruction that does clobber the MQ register. Similarly,
a combined instruction might require a temporary register while the
constituent instructions might not.
When a clobber expression for a register appears inside a
parallel with other side effects, the register allocator
guarantees that the register is unoccupied both before and after that
insn. However, the reload phase may allocate a register used for one of
the inputs unless the `&' constraint is specified for the selected
alternative (see section Constraint Modifier Characters). You can clobber either a specific hard
register, a pseudo register, or a scratch expression; in the
latter two cases, GNU CC will allocate a hard register that is available
there for use as a temporary.
For instructions that require a temporary register, you should use
scratch instead of a pseudo-register because this will allow the
combiner phase to add the clobber when required. You do this by
coding (clobber (match_scratch ...)). If you do
clobber a pseudo register, use one which appears nowhere else--generate
a new one each time. Otherwise, you may confuse CSE.
There is one other known use for clobbering a pseudo register in a
parallel: when one of the input operands of the insn is also
clobbered by the insn. In this case, using the same pseudo register in
the clobber and elsewhere in the insn produces the expected results.
(use x)
reg expression.
During the delayed branch scheduling phase, x may be an insn.
This indicates that x previously was located at this place in the
code and its data dependencies need to be taken into account. These
use insns will be deleted before the delayed branch scheduling
phase exits.
(parallel [x0 x1 ...])
parallel is a
vector of expressions. x0, x1 and so on are individual
side effect expressions--expressions of code set, call,
return, clobber or use.
"In parallel" means that first all the values used in the individual
side-effects are computed, and second all the actual side-effects are
performed. For example,
(parallel [(set (reg:SI 1) (mem:SI (reg:SI 1)))
(set (mem:SI (reg:SI 1)) (reg:SI 1))])
says unambiguously that the values of hard register 1 and the memory
location addressed by it are interchanged. In both places where
(reg:SI 1) appears as a memory address it refers to the value
in register 1 before the execution of the insn.
It follows that it is incorrect to use parallel and
expect the result of one set to be available for the next one.
For example, people sometimes attempt to represent a jump-if-zero
instruction this way:
(parallel [(set (cc0) (reg:SI 34))
(set (pc) (if_then_else
(eq (cc0) (const_int 0))
(label_ref ...)
(pc)))])
But this is incorrect, because it says that the jump condition depends
on the condition code value before this instruction, not on the
new value that is set by this instruction.
Peephole optimization, which takes place together with final assembly
code output, can produce insns whose patterns consist of a parallel
whose elements are the operands needed to output the resulting
assembler code--often reg, mem or constant expressions.
This would not be well-formed RTL at any other stage in compilation,
but it is ok then because no further optimization remains to be done.
However, the definition of the macro NOTICE_UPDATE_CC, if
any, must deal with such insns if you define any peephole optimizations.
(sequence [insns ...])
insn, jump_insn, call_insn,
code_label, barrier or note.
A sequence RTX is never placed in an actual insn during RTL
generation. It represents the sequence of insns that result from a
define_expand before those insns are passed to
emit_insn to insert them in the chain of insns. When actually
inserted, the individual sub-insns are separated out and the
sequence is forgotten.
After delay-slot scheduling is completed, an insn and all the insns that
reside in its delay slots are grouped together into a sequence.
The insn requiring the delay slot is the first insn in the vector;
subsequent insns are to be placed in the delay slot.
INSN_ANNULLED_BRANCH_P is set on an insn in a delay slot to
indicate that a branch insn should be used that will conditionally annul
the effect of the insns in the delay slots. In such a case,
INSN_FROM_TARGET_P indicates that the insn is from the target of
the branch and should be executed only if the branch is taken; otherwise
the insn should be executed only if the branch is not taken.
See section Delay Slot Scheduling.
These expression codes appear in place of a side effect, as the body of an insn, though strictly speaking they do not always describe side effects as such:
(asm_input s)
(unspec [operands ...] index)
(unspec_volatile [operands ...] index)
unspec_volatile is used for volatile operations and operations
that may trap; unspec is used for other operations.
These codes may appear inside a pattern of an
insn, inside a parallel, or inside an expression.
(addr_vec:m [lr0 lr1 ...])
label_ref expressions. The mode m specifies
how much space is given to each address; normally m would be
Pmode.
(addr_diff_vec:m base [lr0 lr1 ...])
label_ref
expressions and so is base. The mode m specifies how much
space is given to each address-difference.Four special side-effect expression codes appear as memory addresses.
(pre_dec:m x)
reg or mem, but most
machines allow only a reg. m must be the machine mode
for pointers on the machine in use. The amount x is decremented
by is the length in bytes of the machine mode of the containing memory
reference of which this expression serves as the address. Here is an
example of its use:
(mem:DF (pre_dec:SI (reg:SI 39)))This says to decrement pseudo register 39 by the length of a
DFmode
value and use the result to address a DFmode value.
(pre_inc:m x)
(post_dec:m x)
pre_dec but a different
value. The value represented here is the value x has before
being decremented.
(post_inc:m x)
These embedded side effect expressions must be used with care. Instruction patterns may not use them. Until the `flow' pass of the compiler, they may occur only to represent pushes onto the stack. The `flow' pass finds cases where registers are incremented or decremented in one instruction and used as an address shortly before or after; these cases are then transformed to use pre- or post-increment or -decrement.
If a register used as the operand of these expressions is used in another address in an insn, the original value of the register is used. Uses of the register outside of an address are not permitted within the same insn as a use in an embedded side effect expression because such insns behave differently on different machines and hence must be treated as ambiguous and disallowed.
An instruction that can be represented with an embedded side effect
could also be represented using parallel containing an additional
set to describe how the address register is altered. This is not
done because machines that allow these operations at all typically
allow them wherever a memory address is called for. Describing them as
additional parallel stores would require doubling the number of entries
in the machine description.
The RTX code asm_operands represents a value produced by a
user-specified assembler instruction. It is used to represent
an asm statement with arguments. An asm statement with
a single output operand, like this:
asm ("foo %1,%2,%0" : "=a" (outputvar) : "g" (x + y), "di" (*z));
is represented using a single asm_operands RTX which represents
the value that is stored in outputvar:
(set rtx-for-outputvar
(asm_operands "foo %1,%2,%0" "a" 0
[rtx-for-addition-result rtx-for-*z]
[(asm_input:m1 "g")
(asm_input:m2 "di")]))
Here the operands of the asm_operands RTX are the assembler
template string, the output-operand's constraint, the index-number of the
output operand among the output operands specified, a vector of input
operand RTX's, and a vector of input-operand modes and constraints. The
mode m1 is the mode of the sum x+y; m2 is that of
*z.
When an asm statement has multiple output values, its insn has
several such set RTX's inside of a parallel. Each set
contains a asm_operands; all of these share the same assembler
template and vectors, but each contains the constraint for the respective
output operand. They are also distinguished by the output-operand index
number, which is 0, 1, ... for successive output operands.
The RTL representation of the code for a function is a doubly-linked
chain of objects called insns. Insns are expressions with
special codes that are used for no other purpose. Some insns are
actual instructions; others represent dispatch tables for switch
statements; others represent labels to jump to or various sorts of
declarative information.
In addition to its own specific data, each insn must have a unique
id-number that distinguishes it from all other insns in the current
function (after delayed branch scheduling, copies of an insn with the
same id-number may be present in multiple places in a function, but
these copies will always be identical and will only appear inside a
sequence), and chain pointers to the preceding and following
insns. These three fields occupy the same position in every insn,
independent of the expression code of the insn. They could be accessed
with XEXP and XINT, but instead three special macros are
always used:
INSN_UID (i)
PREV_INSN (i)
NEXT_INSN (i)
The first insn in the chain is obtained by calling get_insns; the
last insn is the result of calling get_last_insn. Within the
chain delimited by these insns, the NEXT_INSN and
PREV_INSN pointers must always correspond: if insn is not
the first insn,
NEXT_INSN (PREV_INSN (insn)) == insn
is always true and if insn is not the last insn,
PREV_INSN (NEXT_INSN (insn)) == insn
is always true.
After delay slot scheduling, some of the insns in the chain might be
sequence expressions, which contain a vector of insns. The value
of NEXT_INSN in all but the last of these insns is the next insn
in the vector; the value of NEXT_INSN of the last insn in the vector
is the same as the value of NEXT_INSN for the sequence in
which it is contained. Similar rules apply for PREV_INSN.
This means that the above invariants are not necessarily true for insns
inside sequence expressions. Specifically, if insn is the
first insn in a sequence, NEXT_INSN (PREV_INSN (insn))
is the insn containing the sequence expression, as is the value
of PREV_INSN (NEXT_INSN (insn)) is insn is the last
insn in the sequence expression. You can use these expressions
to find the containing sequence expression.
Every insn has one of the following six expression codes:
insn
insn is used for instructions that do not jump
and do not do function calls. sequence expressions are always
contained in insns with code insn even if one of those insns
should jump or do function calls.
Insns with code insn have four additional fields beyond the three
mandatory ones listed above. These four are described in a table below.
jump_insn
jump_insn is used for instructions that may
jump (or, more generally, may contain label_ref expressions). If
there is an instruction to return from the current function, it is
recorded as a jump_insn.
jump_insn insns have the same extra fields as insn insns,
accessed in the same way and in addition contain a field
JUMP_LABEL which is defined once jump optimization has completed.
For simple conditional and unconditional jumps, this field contains the
code_label to which this insn will (possibly conditionally)
branch. In a more complex jump, JUMP_LABEL records one of the
labels that the insn refers to; the only way to find the others
is to scan the entire body of the insn.
Return insns count as jumps, but since they do not refer to any labels,
they have zero in the JUMP_LABEL field.
call_insn
call_insn is used for instructions that may do
function calls. It is important to distinguish these instructions because
they imply that certain registers and memory locations may be altered
unpredictably.
call_insn insns have the same extra fields as insn insns,
accessed in the same way and in addition contain a field
CALL_INSN_FUNCTION_USAGE, which contains a list (chain of
expr_list expressions) containing use and clobber
expressions that denote hard registers used or clobbered by the called
function. A register specified in a clobber in this list is
modified after the execution of the call_insn, while a
register in a clobber in the body of the call_insn is
clobbered before the insn completes execution. clobber
expressions in this list augment registers specified in
CALL_USED_REGISTERS (see section Basic Characteristics of Registers).
code_label
code_label insn represents a label that a jump insn can jump
to. It contains two special fields of data in addition to the three
standard ones. CODE_LABEL_NUMBER is used to hold the label
number, a number that identifies this label uniquely among all the
labels in the compilation (not just in the current function).
Ultimately, the label is represented in the assembler output as an
assembler label, usually of the form `Ln' where n is
the label number.
When a code_label appears in an RTL expression, it normally
appears within a label_ref which represents the address of
the label, as a number.
The field LABEL_NUSES is only defined once the jump optimization
phase is completed and contains the number of times this label is
referenced in the current function.
barrier
volatile functions, which do not return (e.g., exit).
They contain no information beyond the three standard fields.
note
note insns are used to represent additional debugging and
declarative information. They contain two nonstandard fields, an
integer which is accessed with the macro NOTE_LINE_NUMBER and a
string accessed with NOTE_SOURCE_FILE.
If NOTE_LINE_NUMBER is positive, the note represents the
position of a source line and NOTE_SOURCE_FILE is the source file name
that the line came from. These notes control generation of line
number data in the assembler output.
Otherwise, NOTE_LINE_NUMBER is not really a line number but a
code with one of the following values (and NOTE_SOURCE_FILE
must contain a null pointer):
NOTE_INSN_DELETED
NOTE_INSN_BLOCK_BEG
NOTE_INSN_BLOCK_END
NOTE_INSN_LOOP_BEG
NOTE_INSN_LOOP_END
while or for loop. They enable the loop optimizer
to find loops quickly.
NOTE_INSN_LOOP_CONT
continue statements jump to.
NOTE_INSN_LOOP_VTOP
NOTE_INSN_FUNCTION_END
return statements jump to (on machine where a single instruction
does not suffice for returning). This note may be deleted by jump
optimization.
NOTE_INSN_SETJMP
setjmp or a related function.
The machine mode of an insn is normally VOIDmode, but some
phases use the mode for various purposes; for example, the reload pass
sets it to HImode if the insn needs reloading but not register
elimination and QImode if both are required. The common
subexpression elimination pass sets the mode of an insn to QImode
when it is the first insn in a block that has already been processed.
Here is a table of the extra fields of insn, jump_insn
and call_insn insns:
PATTERN (i)
set, call, use,
clobber, return, asm_input, asm_output,
addr_vec, addr_diff_vec, trap_if, unspec,
unspec_volatile, parallel, or sequence. If it is a parallel,
each element of the parallel must be one these codes, except that
parallel expressions cannot be nested and addr_vec and
addr_diff_vec are not permitted inside a parallel expression.
INSN_CODE (i)
use, clobber,
asm_input, addr_vec or addr_diff_vec expression.
Matching is also never attempted on insns that result from an asm
statement. These contain at least one asm_operands expression.
The function asm_noperands returns a non-negative value for
such insns.
In the debugging output, this field is printed as a number followed by
a symbolic representation that locates the pattern in the `md'
file as some small positive or negative offset from a named pattern.
LOG_LINKS (i)
insn_list expressions) giving information about
dependencies between instructions within a basic block. Neither a jump
nor a label may come between the related insns.
REG_NOTES (i)
expr_list and insn_list expressions)
giving miscellaneous information about the insn. It is often information
pertaining to the registers used in this insn.
The LOG_LINKS field of an insn is a chain of insn_list
expressions. Each of these has two operands: the first is an insn,
and the second is another insn_list expression (the next one in
the chain). The last insn_list in the chain has a null pointer
as second operand. The significant thing about the chain is which
insns appear in it (as first operands of insn_list
expressions). Their order is not significant.
This list is originally set up by the flow analysis pass; it is a null
pointer until then. Flow only adds links for those data dependencies
which can be used for instruction combination. For each insn, the flow
analysis pass adds a link to insns which store into registers values
that are used for the first time in this insn. The instruction
scheduling pass adds extra links so that every dependence will be
represented. Links represent data dependencies, antidependencies and
output dependencies; the machine mode of the link distinguishes these
three types: antidependencies have mode REG_DEP_ANTI, output
dependencies have mode REG_DEP_OUTPUT, and data dependencies have
mode VOIDmode.
The REG_NOTES field of an insn is a chain similar to the
LOG_LINKS field but it includes expr_list expressions in
addition to insn_list expressions. There are several kinds
of register notes, which are distinguished by the machine mode, which
in a register note is really understood as being an enum reg_note.
The first operand op of the note is data whose meaning depends on
the kind of note.
The macro REG_NOTE_KIND (x) returns the kind of
register note. Its counterpart, the macro PUT_REG_NOTE_KIND
(x, newkind) sets the register note type of x to be
newkind.
Register notes are of three classes: They may say something about an
input to an insn, they may say something about an output of an insn, or
they may create a linkage between two insns. There are also a set
of values that are only used in LOG_LINKS.
These register notes annotate inputs to an insn:
REG_DEAD
REG_DEAD note would be redundant and is
usually not present until after the reload pass, but no code relies on
this fact.
REG_INC
post_inc, pre_inc,
post_dec or pre_dec expression.
REG_NONNEG
REG_NONNEG note is added to insns only if the machine
description has a `decrement_and_branch_until_zero' pattern.
REG_NO_CONFLICT
clobber insn specifying a multi-word pseudo register (which will
be the output of the block), a group of insns that each set one word of
the value and have the REG_NO_CONFLICT note attached, and a final
insn that copies the output to itself with an attached REG_EQUAL
note giving the expression being computed. This block is encapsulated
with REG_LIBCALL and REG_RETVAL notes on the first and
last insns, respectively.
REG_LABEL
code_label, but is not a
jump_insn. The presence of this note allows jump optimization to
be aware that op is, in fact, being used.
The following notes describe attributes of outputs of an insn:
REG_EQUIV
REG_EQUAL
set is a strict_low_part expression,
the note refers to the register that is contained in SUBREG_REG
of the subreg expression.
For REG_EQUIV, the register is equivalent to op throughout
the entire function, and could validly be replaced in all its
occurrences by op. ("Validly" here refers to the data flow of
the program; simple replacement may make some insns invalid.) For
example, when a constant is loaded into a register that is never
assigned any other value, this kind of note is used.
When a parameter is copied into a pseudo-register at entry to a function,
a note of this kind records that the register is equivalent to the stack
slot where the parameter was passed. Although in this case the register
may be set by other insns, it is still valid to replace the register
by the stack slot throughout the function.
In the case of REG_EQUAL, the register that is set by this insn
will be equal to op at run time at the end of this insn but not
necessarily elsewhere in the function. In this case, op
is typically an arithmetic expression. For example, when a sequence of
insns such as a library call is used to perform an arithmetic operation,
this kind of note is attached to the insn that produces or copies the
final value.
These two notes are used in different ways by the compiler passes.
REG_EQUAL is used by passes prior to register allocation (such as
common subexpression elimination and loop optimization) to tell them how
to think of that value. REG_EQUIV notes are used by register
allocation to indicate that there is an available substitute expression
(either a constant or a mem expression for the location of a
parameter on the stack) that may be used in place of a register if
insufficient registers are available.
Except for stack homes for parameters, which are indicated by a
REG_EQUIV note and are not useful to the early optimization
passes and pseudo registers that are equivalent to a memory location
throughout there entire life, which is not detected until later in
the compilation, all equivalences are initially indicated by an attached
REG_EQUAL note. In the early stages of register allocation, a
REG_EQUAL note is changed into a REG_EQUIV note if
op is a constant and the insn represents the only set of its
destination register.
Thus, compiler passes prior to register allocation need only check for
REG_EQUAL notes and passes subsequent to register allocation
need only check for REG_EQUIV notes.
REG_UNUSED
REG_DEAD note, which
indicates that the value in an input will not be used subsequently.
These two notes are independent; both may be present for the same
register.
REG_WAS_0
note;
its absence implies nothing.
These notes describe linkages between insns. They occur in pairs: one insn has one of a pair of notes that points to a second insn, which has the inverse note pointing back to the first insn.
REG_RETVAL
REG_EQUAL note will also usually be attached to this insn to
provide the expression being computed by the sequence.
REG_LIBCALL
REG_RETVAL: it is placed on the first
insn of a multi-insn sequence, and it points to the last one.
REG_CC_SETTER
REG_CC_USER
cc0, the insns which set and use cc0
set and use cc0 are adjacent. However, when branch delay slot
filling is done, this may no longer be true. In this case a
REG_CC_USER note will be placed on the insn setting cc0 to
point to the insn using cc0 and a REG_CC_SETTER note will
be placed on the insn using cc0 to point to the insn setting
cc0.
These values are only used in the LOG_LINKS field, and indicate
the type of dependency that each link represents. Links which indicate
a data dependence (a read after write dependence) do not use any code,
they simply have mode VOIDmode, and are printed without any
descriptive text.
REG_DEP_ANTI
REG_DEP_OUTPUT
For convenience, the machine mode in an insn_list or
expr_list is printed using these symbolic codes in debugging dumps.
The only difference between the expression codes insn_list and
expr_list is that the first operand of an insn_list is
assumed to be an insn and is printed in debugging dumps as the insn's
unique id; the first operand of an expr_list is printed in the
ordinary way as an expression.
Insns that call subroutines have the RTL expression code call_insn.
These insns must satisfy special rules, and their bodies must use a special
RTL expression code, call.
A call expression has two operands, as follows:
(call (mem:fm addr) nbytes)
Here nbytes is an operand that represents the number of bytes of
argument data being passed to the subroutine, fm is a machine mode
(which must equal as the definition of the FUNCTION_MODE macro in
the machine description) and addr represents the address of the
subroutine.
For a subroutine that returns no value, the call expression as
shown above is the entire body of the insn, except that the insn might
also contain use or clobber expressions.
For a subroutine that returns a value whose mode is not BLKmode,
the value is returned in a hard register. If this register's number is
r, then the body of the call insn looks like this:
(set (reg:m r)
(call (mem:fm addr) nbytes))
This RTL expression makes it clear (to the optimizer passes) that the appropriate register receives a useful value in this insn.
When a subroutine returns a BLKmode value, it is handled by
passing to the subroutine the address of a place to store the value.
So the call insn itself does not "return" any value, and it has the
same RTL form as a call that returns nothing.
On some machines, the call instruction itself clobbers some register,
for example to contain the return address. call_insn insns
on these machines should have a body which is a parallel
that contains both the call expression and clobber
expressions that indicate which registers are destroyed. Similarly,
if the call instruction requires some register other than the stack
pointer that is not explicitly mentioned it its RTL, a use
subexpression should mention that register.
Functions that are called are assumed to modify all registers listed in
the configuration macro CALL_USED_REGISTERS (see section Basic Characteristics of Registers) and, with the exception of const functions and library
calls, to modify all of memory.
Insns containing just use expressions directly precede the
call_insn insn to indicate which registers contain inputs to the
function. Similarly, if registers other than those in
CALL_USED_REGISTERS are clobbered by the called function, insns
containing a single clobber follow immediately after the call to
indicate which registers.
The compiler assumes that certain kinds of RTL expressions are unique; there do not exist two distinct objects representing the same value. In other cases, it makes an opposite assumption: that no RTL expression object of a certain kind appears in more than one place in the containing structure.
These assumptions refer to a single function; except for the RTL objects that describe global variables and external functions, and a few standard objects such as small integer constants, no RTL objects are common to two functions.
reg object to represent it,
and therefore only a single machine mode.
symbol_ref object
referring to it.
const_int expression with value 0, only
one with value 1, and only one with value -1.
Some other integer values are also stored uniquely.
pc expression.
cc0 expression.
const_double expression with value 0 for
each floating point mode. Likewise for values 1 and 2.
label_ref or scratch appears in more than one place in
the RTL structure; in other words, it is safe to do a tree-walk of all
the insns in the function and assume that each time a label_ref
or scratch is seen it is distinct from all others that are seen.
mem object is normally created for each static
variable or stack slot, so these objects are frequently shared in all
the places they appear. However, separate but equal objects for these
variables are occasionally made.
asm statement has multiple output operands, a
distinct asm_operands expression is made for each output operand.
However, these all share the vector which contains the sequence of input
operands. This sharing is used later on to test whether two
asm_operands expressions come from the same statement, so all
optimizations must carefully preserve the sharing if they copy the
vector at all.
unshare_all_rtl in `emit-rtl.c',
after which the above rules are guaranteed to be followed.
copy_rtx_if_shared, which is a subroutine of
unshare_all_rtl.
To read an RTL object from a file, call read_rtx. It takes one
argument, a stdio stream, and returns a single RTL object.
Reading RTL from a file is very slow. This is not currently a problem since reading RTL occurs only as part of building the compiler.
People frequently have the idea of using RTL stored as text in a file as an interface between a language front end and the bulk of GNU CC. This idea is not feasible.
GNU CC was designed to use RTL internally only. Correct RTL for a given program is very dependent on the particular target machine. And the RTL does not contain all the information about the program.
The proper way to interface GNU CC to a new language front end is with the "tree" data structure. There is no manual for this data structure, but it is described in the files `tree.h' and `tree.def'.
# in template
* in template
-lgcc, use with -nodefaultlibs
-lgcc, use with -nostdlib
-nodefaultlibs and unresolved references
-nostdlib and unresolved references
abs and attributes
absm2 instruction pattern
ACCUMULATE_OUTGOING_ARGS and stack frames
addm3 instruction pattern
addr_diff_vec, length of
addr_vec, length of
allocate_stack instruction pattern
and and attributes
and, canonicalization of
andm3 instruction pattern
ARG_POINTER_REGNUM and virtual registers
ashift and attributes
ashiftrt and attributes
ashlm3 instruction pattern
ashrm3 instruction pattern
asm_operands, RTL sharing
asm_operands, usage
bcond instruction pattern
bcopy, implicit usage
BITS_BIG_ENDIAN, effect on sign_extract
BLKmode, and function return values
bzero, implicit usage
call instruction pattern
call usage
call_insn and `/u'
call_pop instruction pattern
call_value instruction pattern
call_value_pop instruction pattern
casesi instruction pattern
cc0, RTL sharing
cmpm instruction pattern
cmpstrm instruction pattern
code_label and `/i'
compare, canonicalization of
cond and attributes
const_double, RTL sharing
const_int and attribute tests
const_int and attributes
const_int, RTL sharing
const_string and attributes
define_insn example
div and attributes
divm3 instruction pattern
divmodm4 instruction pattern
EDOM, implicit usage
ENCODE_SECTION_INFO and address validation
ENCODE_SECTION_INFO usage
eq and attributes
errno, implicit usage
extendmn instruction pattern
extv instruction pattern
extzv instruction pattern
ffsm2 instruction pattern
FIRST_PARM_OFFSET and virtual registers
fix_truncmn2 instruction pattern
fixmn2 instruction pattern
fixuns_truncmn2 instruction pattern
fixunsmn2 instruction pattern
float as function value type
floatmn2 instruction pattern
floatunsmn2 instruction pattern
FRAME_GROWS_DOWNWARD and virtual registers
FRAME_POINTER_REGNUM and virtual registers
fscanf, and constant strings
ftruncm2 instruction pattern
FUNCTION_EPILOGUE and trampolines
FUNCTION_PROLOGUE and trampolines
ge and attributes
genflags, crash on Sun 4
geu and attributes
gprof
gt and attributes
gtu and attributes
HImode, in insn
if_then_else and attributes
if_then_else usage
in_struct, in code_label
in_struct, in insn, in_struct, in insn
in_struct, in label_ref
in_struct, in mem
in_struct, in reg
in_struct, in subreg
indirect_jump instruction pattern
insn and `/i'
insn and `/s'
insn and `/u'
insv instruction pattern
integrated, in insn
integrated, in reg
ior and attributes
ior, canonicalization of
iorm3 instruction pattern
set
label_ref and `/s'
label_ref, RTL sharing
le and attributes
leu and attributes
load_multiple instruction pattern
longjmp and automatic variables
longjmp incompatibilities
longjmp warnings
lshiftrt and attributes
lshrm3 instruction pattern
lt and attributes
main and the exit status
match_dup and attributes
match_operand and attributes
maxm3 instruction pattern
mem and `/s'
mem and `/u'
mem and `/v'
mem, RTL sharing
memcpy, implicit usage
memset, implicit usage
minm3 instruction pattern
minus and attributes
minus, canonicalization of
mktemp, and constant strings
mod and attributes
modm3 instruction pattern
movm instruction pattern
movmodecc instruction pattern
movstrictm instruction pattern
movstrm instruction pattern
mulhisi3 instruction pattern
mulm3 instruction pattern
mulqihi3 instruction pattern
mulsidi3 instruction pattern
mult and attributes
mult, canonicalization of
MUST_PASS_IN_STACK, and FUNCTION_ARG
ne and attributes
neg and attributes
neg, canonicalization of
negm2 instruction pattern
nop instruction pattern
not and attributes
not, canonicalization of
one_cmplm2 instruction pattern
pc and attributes
pc, RTL sharing
plus and attributes
plus, canonicalization of
prof
PUSH_ROUNDING, interaction with STACK_BOUNDARY
QImode, in insn
reg and `/i'
reg and `/s'
reg and `/u'
reg and `/v'
reg, RTL sharing
REG_PARM_STACK_SPACE, and FUNCTION_ARG
reload_in instruction pattern
reload_out instruction pattern
restore_stack_block instruction pattern
restore_stack_function instruction pattern
restore_stack_nonlocal instruction pattern
return instruction pattern
main
rotlm3 instruction pattern
rotrm3 instruction pattern
save_stack_block instruction pattern
save_stack_function instruction pattern
save_stack_nonlocal instruction pattern
scanf, and constant strings
scond instruction pattern
scratch, RTL sharing
setjmp incompatibilities
sign_extract, canonicalization of
smulm3_highpart instruction pattern
sqrtm2 instruction pattern
sscanf, and constant strings
STACK_DYNAMIC_OFFSET and virtual registers
STACK_POINTER_OFFSET and virtual registers
STACK_POINTER_REGNUM and virtual registers
STARTING_FRAME_OFFSET and virtual registers
strlenm instruction pattern
subm3 instruction pattern
subreg and `/s'
subreg and `/u'
subreg, special reload handling
subreg, in strict_low_part
symbol_ref and `/u'
symbol_ref and `/v'
symbol_ref, RTL sharing
SYMBOL_REF_FLAG, in ENCODE_SECTION_INFO
tablejump instruction pattern
tcov
truncmn instruction pattern
tstm instruction pattern
udivm3 instruction pattern
udivmodm4 instruction pattern
umaxm3 instruction pattern
uminm3 instruction pattern
umodm3 instruction pattern
umulhisi3 instruction pattern
umulm3_highpart instruction pattern
umulqihi3 instruction pattern
umulsidi3 instruction pattern
unchanging, in call_insn
unchanging, in insn
unchanging, in subreg
unchanging, in symbol_ref
unchanging, in reg and mem
-nodefaultlibs
-nostdlib
untyped_call instruction pattern
untyped_return instruction pattern
used, in symbol_ref
volatil, in insn
volatil, in mem
volatil, in reg
volatil, in symbol_ref
WORDS_BIG_ENDIAN, effect on subreg
xor, canonicalization of
xorm3 instruction pattern
zero_extendmn instruction pattern
zero_extract, canonicalization of
This document was generated on 25 September 1997 using the texi2html translator version 1.51a.