| 1 | \chapter{Introduction} \label{introduction}
|
|---|
| 2 | Computer programming languages provide humans a means to instruct computers to
|
|---|
| 3 | perform a particular task. New programming languages are
|
|---|
| 4 | invented to simplify the task, or provide additional features, enhance
|
|---|
| 5 | performance, and improve developer productivity.
|
|---|
| 6 |
|
|---|
| 7 | A crucial companion tool to a programming language is a debugger. A debugger is a productivity tool to aid developers in testing
|
|---|
| 8 | and finding bugs in a program. By definition, a debugger executes
|
|---|
| 9 | any program written in one of a supported set of languages and allows developers
|
|---|
| 10 | to stop, monitor and examine state in the program for further investigation.
|
|---|
| 11 |
|
|---|
| 12 | Specifically, this report talks about how to add GNU Debugger (GDB) support for the
|
|---|
| 13 | concurrent programming-languages \uC and \CFA.
|
|---|
| 14 | Both languages provide an $M$:$N$ concurrency model, where $M$ user-level threads
|
|---|
| 15 | execute on $N$ kernel-level threads.
|
|---|
| 16 | Often debuggers either do not know about concurrency or only provide a simple
|
|---|
| 17 | understanding of concurrency provided by the operating system (kernel threads).
|
|---|
| 18 | For \CFA, new hooks are also added to allow GDB to understand that
|
|---|
| 19 | \CFA is a new source language that requires invocation of a demangler for
|
|---|
| 20 | variable and function names.
|
|---|
| 21 |
|
|---|
| 22 | Because \uC is a translator, all the code written in \uC is eventually
|
|---|
| 23 | compiled down to \CC code. This transformation gives \uC an advantage with
|
|---|
| 24 | GDB because GDB already understands \CC. However, since \uC introduced new objects
|
|---|
| 25 | and high-level execution constructs into the language, GDB does not understand
|
|---|
| 26 | these objects or the runtime environment. One objective of this
|
|---|
| 27 | project is to write new GDB extensions to understand concurrency among tasks, a new high-level execution construct that is discussed more in Chapter \ref{uC}.
|
|---|
| 28 |
|
|---|
| 29 | Additionally, if a programming language provides overloading functionality,
|
|---|
| 30 | which allows functions or variables in the same scope with the
|
|---|
| 31 | same identifier, then each of these entities must be assigned a unique name, otherwise,
|
|---|
| 32 | there are name collisions.
|
|---|
| 33 |
|
|---|
| 34 | However, uniquely numbering (naming) overloads is impossible with separate
|
|---|
| 35 | compilation, because the compiler does not have access to all translation
|
|---|
| 36 | units. Therefore, it is necessary to adopt a scheme related to the overloading
|
|---|
| 37 | mechanism for unique naming. For example, if a language uses the number and
|
|---|
| 38 | types of function parameters to disambiguate function names, than the number
|
|---|
| 39 | and parameter types are encoded into the name:
|
|---|
| 40 | \begin{lstlisting}[basicstyle=\normalfont\tt]
|
|---|
| 41 | void f( int i, double d, char c ); // f_3_i_d_c
|
|---|
| 42 | void f( int i, char c ); // f_2_i_c
|
|---|
| 43 | \end{lstlisting}
|
|---|
| 44 | Here, the mangled names for \lstinline@f@ contain the number of parameters and a code for
|
|---|
| 45 | each parameter type. For a complex type-system, the type codes become
|
|---|
| 46 | correspondingly complex, e.g., a generic structure. These names are now unique
|
|---|
| 47 | across all translation units.
|
|---|
| 48 |
|
|---|
| 49 | Unfortunately, a debugger only has access to the mangled names in a compiled
|
|---|
| 50 | translation units, versus the unmangled names in the program. Therefore, the
|
|---|
| 51 | debugger can only look up mangled names versus original program names, which
|
|---|
| 52 | makes debugging extremely difficult for programmers. To solve this program, the
|
|---|
| 53 | language must provide the debugger with a "demangled" so it can convert
|
|---|
| 54 | mangled names back to program names, and correspondingly retrieve the type of
|
|---|
| 55 | the name~\cite{Reference9}.
|
|---|
| 56 |
|
|---|
| 57 | \CFA, a new language being developed at the University of Waterloo, has
|
|---|
| 58 | overloading, so names resolved by the debugger are mangled names. Therefore,
|
|---|
| 59 | another objective of this project is to add a \CFA demangler to GDB.
|
|---|
| 60 |
|
|---|
| 61 | % Name mangling is a technique used in compilers to resolve this
|
|---|
| 62 | % problem. This technique provides a mechanism to encode additional information in the
|
|---|
| 63 | % name of a function, or a variable to supply more semantic information from
|
|---|
| 64 | % compiler to debugger \cite{Reference9}. \CFA, a new language being developed at the University of
|
|---|
| 65 | % Waterloo, has overloading, so names resolved from
|
|---|
| 66 | % the debugger are mangled names. As with early versions of \CC, it is not user-friendly to debug a program using
|
|---|
| 67 | % mangled names. Therefore, another objective of this project is to add a \CFA demangler in GDB.
|
|---|
