What is responsible for ensuring all symbols are known/defined?

Is it the C preprocessor, compiler, or linkage editor?


The answer you are looking for is... the compiler it depends. Sometimes it's the compiler, sometimes it's the linker, and sometimes it doesn't happen until the program is loaded.

The preprocessor:

handles directives for source file inclusion (#include), macro definitions (#define), and conditional inclusion (#if). ... The language of preprocessor directives is agnostic to the grammar of C, so the C preprocessor can also be used independently to process other kinds of text files.

The linker:

takes one or more objects generated by a compiler and combines them into a single executable program. ...

Computer programs typically comprise several parts or modules; all these parts/modules need not be contained within a single object file, and in such case refer to each other by means of symbols. Typically, an object file can contain three kinds of symbols:

  • defined symbols, which allow it to be called by other modules,
  • undefined symbols, which call the other modules where these symbols are defined, and
  • local symbols, used internally within the object file to facilitate relocation.

When a program comprises multiple object files, the linker combines these files into a unified executable program, resolving the symbols as it goes along.

In environments which allow dynamic linking, it is possible that

executable code still contains undefined symbols, plus a list of objects or libraries that will provide definitions for these.

To tell you the truth, it is programmer.

The programmer must make sure everything is defined somewhere. The programmer is RESPONSIBLE for doing so.

Various tools will complain along the way if they notice anything missing:

The compiler will notice certain things missing, and will error out if it can realize that something's not there.

The linker will error out if it can't fix up a reference that's not in a library somewhere.

At run time there is a loader that pulls the relevant shared libraries into the process's memory space. The loader is the last thing that gets a crack at fixing up symbols before the program gets to run any code, and it will throw errors if it can't find a shared library/dll, or if the interface for the library that was used at link-time doesn't match up correctly with the available library.

None of these tools is RESPONSIBLE for making sure everything is defined. They are just the things that will notice if things are NOT defined, and will be the ones throwing the error message.

  • For symbols with internal linkage or no linkage: the compiler.
  • For symbols with external linkage: the linker, either the "traditional" one, or the runtime linker.

Note that the dynamic/runtime linker may choose to do its job lazily, resolving symbols only when they are used (e.g: when a function is called for the first time).

Need Your Help

(Reverse?) Tree Enumeration

.net vb.net recursion

I'm working on this app to gather some file/folder usage data. The goal is to have my object know the size of its files and children folders; at every point in the tree.