CODEWITHSUNDEEP
gcc
user1746360
user1746360

Reputation: 1224

Can I know data type from variable name in GCC?

I want to know data type using variable name

My final goal is getting a function signature for making a function stub(skeleton code)

but GCC error message just notify only undefined function name

Can I see a symbol table? (for inferencing function signature)

for example, foo.c is like below

#include <stdio.h>

int main() {
    int n = 0;
    n = foo();
    return 0;
}

I want to make a function stub

so I want to know function foo has no parameter and returns an integer value

What should I do?

I think below:

  1. linker error message say function foo is undefined

  2. read line 5

    n = foo();

  3. inspect type of n using symbol table

is it right?

sorry for my bad english

please teach me inferencing a function signature

Upvotes: 1

Views: 134

Answers (4)

perreal
perreal

Reputation: 98118

Inject his code into your source file:

typedef struct { int a; char c; } badtype_t;
badtype_t badtype;

then replace the error line like this:

n = badtype; //foo();

or if you want the type foo returns:

badtype = foo();

then you will get some error like this:

incompatible types when initializing type ‘int’ using type ‘badtype_t’

and you can get the type int.

or if you want the type of foo itself:

foo * 2

then you will get some error like this:

invalid operands to binary * (have 'int (*)()' and 'int')

and you can get the type int (*)() (that is, function taking nothing and returning an int).

Upvotes: 2

abarnert
abarnert

Reputation: 366133

So, you have some function named foo defined somewhere, and you want to know what its type is.

If you don't actually have a prototype for foo somewhere in your #included header files, this is easy:

  • If you're using C99, your code is invalid.
  • Otherwise, foo must take no arguments and return int, or your code is invalid.

And this isn't one of those "technically invalid, but it works on every platform" cases; it will break. For example, with gcc 4.2 for 64-bit x86 linux or Mac, if you do this:

double foo(double f) { return f*2; }

Then, without a header file, call it like this:

double f = foo(2.0);
printf("%f\n", f);

If compiled as C89, this will compile and link just fine (clang or gcc 4.8 will give you a warning; gcc 4.2 won't even do that by default), and run, and print out 2.0. At least on x86_64; on ARM7, you'll corrupt the stack, and segfault if you're lucky. (Of course it actually does double something—either your 2.0 or some random uninitialized value—but it can't return that to you; it's stashed it in an arbitrary floating-point register that the caller doesn't know to access.)

If it is in a header file, you can always search for it. emacs, graphical IDEs, etc. are very good at this. But you can use the compiler to help you out, in two ways.

First, just do this:

gcc -E main.c > main.i
less main.i

Now search for /foo, and you'll find it.

Or you can trick the compiler into giving you an error message, as in perreal's answer.

Upvotes: 0

abarnert
abarnert

Reputation: 366133

If you just want to see a symbol table, that's what nm is for.

For example, if you get an error linking foo.o and bar.o together, you can do this:

nm -a foo.o

That will show you all the symbols defined in module foo.

But I don't see why you think this would help. C symbols do not have any type information. There may be enough metadata to distinguish extern linkage, and/or to tell whether a symbol function or data, but that's it. There is no way to tell an int from a float, or a function taking two ints and returning a double from a function taking a char * and returning a different char *.

Upvotes: 0

CSJ
CSJ

Reputation: 3971

It seems ok, but this strategy will not be good enough. Using the left-hand side of an expression is not enough to determine the return-type of the function. In particular, there may be no left-hand side at all, simply: foo();. What then?

Upvotes: 0

Related Questions