including assembly language routines in c

[Robert Cloud]

Is it possible to include assembly language routines in
C if I'm using a compiler which has an assembler such as gcc? could I
include them in a main function or would I have to write a seperate
function? what kind of privilege level would be required to execute
a program with assembly in it? how would I denote that the following
code is assembly and thus shouldn't be checked for syntax errors?

------------------------------
Robert Cloud
http://www.dpo.uab.edu/~rcloud
rc****@uab.edu

[jacob navia]

Walter Roberson wrote:

In article <g5**********@a ioe.org>, jacob navia <ja***@nospam.o rgwrote:

>Do not forget that C is translated
directly into assembly in most cases.

What is "most cases" ??

It's been a couple of decades since I used a C compiler that translated
directly into assembly. My experience since then has been with
compilers that translate into a language-independant intermediate code
representation, the results of which were optimized. Assembly was
generated after that stage for some of the (older) compilers but
optimized intermediate code directly to object code is what I see these
days.

Working with manipulated C as an intermediate form is rather clumsy,
and by the time you have reached assembly you have lost a lot of
the opportunities for intra-procedural optimization, so an
intermediate form is common, especially in companies that make
multiple compilers, the more so if the compilers can be targetted
to multiple architectures. For example gcc goes through GENERIC and
GIMPLE on its way to RTL (Register Transfer Language).

Of course, with "directly" I mean that the *result* of the compilation
is a stream of opcodes, and not an interpreter, even if C interpreters
exist (that is why I said in most cases and not always)

--
jacob navia
jacob at jacob point remcomp point fr
logiciels/informatique
http://www.cs.virginia.edu/~lcc-win32

[Ian Collins]

CBFalconer wrote:

>
However, the point of this answer is to correct your clock. Your
message was dated 2008-07-20 22:18 +0200 and was received here on
2008-07-18 before 0600 -0400. I suspect you have am/pm misset.

He did that an hour before you posted, so why bother?

--
Ian Collins.

[Chris Torek]

>Robert Cloud wrote:

>Is it possible to include assembly language routines in
C ...
how would I denote that the following
code is assembly and thus shouldn't be checked for syntax errors?

In article <g5**********@a ioe.orgjacob navia <ja***@nospam.o rg>
wrote (in part, and in reply to the second part):

>Use the asm() pseudo instruction in the C code. But beware... it is
not very easy because you will want to avoid destroying the assembler
code that the compiler generates, so you can't just add instructions
like that withing a function, unless you save all the registers
and restore them later before leaving.

If you use asm() at all, you will depend heavily on the
specific compiler.

If you choose to depend on GCC, what Jacob says here is not quite
correct, because gcc's asm() construct includes communication
between the programmer and the compiler as to what machine registers
and other features are modified by the inline assembly.

For instance, if you are inserting inline assembly on the Glorko
GX-47, you might write:

asm volatile("frob %1,%2,%0" : "=B"(result ) :
"g"(arg1), "I"(arg2) : "L");

to tell gcc:

- the instruction must not be moved or combined;
- the output must be in one of the "B" registers;
- arg1 can be in any register or memory ("g"eneral);
- arg2 must fit in an "I"ntermedi ate instruction field; and
- the "L"aziness register is clobbered by a "frob".

The B and L codes are specific to the Glorko machines, of course.
The letter B means something else on similar machines, and L is
not even valid. So be sure you do not attempt to use this on a
Frobozz series, which also has a frob instruction, but does not
have a laziness register.

(The above is meant as an illustrative example of just what you
are getting into when you start inserting inline assembly. Be
*very* sure this is a good idea before you attempt it.)
--
In-Real-Life: Chris Torek, Wind River Systems
Salt Lake City, UT, USA (40°39.22'N, 111°50.29'W) [phone]
email: gmail (figure it out) http://web.torek.net/torek/index.html

[Flash Gordon]

jacob navia wrote, On 20/07/08 00:01:

Walter Roberson wrote:

>In article <g5**********@a ioe.org>, jacob navia <ja***@nospam.o rg>
wrote:

>>Do not forget that C is translated
directly into assembly in most cases.

What is "most cases" ??

<snip>

>representation , the results of which were optimized. Assembly was
generated after that stage for some of the (older) compilers but
optimized intermediate code directly to object code is what I see these
days.

<snip>

Of course, with "directly" I mean that the *result* of the compilation
is a stream of opcodes, and not an interpreter, even if C interpreters
exist (that is why I said in most cases and not always)

Having read and written assembler and also debugged at machine code
level (without the benefit of a disassembler) I can say with a fair
degree of certainty that assembly is *not* a stream of opcodes, it is a
language (or several languages) in text with its own syntax, often
macros and definitely things that don't make it in to the machine-code.

This may seem like nit-picking, but since the OP wanted to integrate
assembly and C it is not. C and assembly are different languages that
are *both* normally used to produce object files containing machine-code
and data (which is not normally used as opcodes). Assembly language
often has a lot more features than machine-code but by its very nature
you can in assembly write code that uses the same calling conventions of
whatever C compiler you happen to be using.
--
Flash Gordon