Programming tools
Download
1 / 39

Programming Tools - PowerPoint PPT Presentation


  • 278 Views
  • Updated On :

Programming Tools. Compilers and Linking, make, Debuggers, Source Code Management, man. Man Pages. Almost all UNIX-like OS are documented in so-called manual pages Or man pages, for short Looked up using the man tool Try $ man man Path to man pages is given by the shell variable MANPATH.

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Programming Tools' - LionelDale


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
Programming tools l.jpg

Programming Tools

Compilers and Linking, make, Debuggers, Source Code Management, man

CME212 – Introduction to Large-Scale Computing in Engineering

High Performance Computing and Programming


Man pages l.jpg
Man Pages

  • Almost all UNIX-like OS are documented in so-called manual pages

    • Or man pages, for short

  • Looked up using the man tool

    • Try $ man man

  • Path to man pages is given by the shell variable MANPATH

CME212 – Introduction to Large-Scale Computing in Engineering

High Performance Computing and Programming


Man pages sections l.jpg
Man Pages, Sections

CME212 – Introduction to Large-Scale Computing in Engineering

High Performance Computing and Programming


Man pages4 l.jpg
Man Pages

  • Man pages are divided into chapters

    • NAME (search phrase)

    • SYNOPSIS (short description, function prototypes)

    • DESCRIPTION (details)

    • OPTIONS (command line options)

    • ENVIRONMENT VARIABLES

    • EXIT STATUS

    • FILES (relevant configuration files)

    • SEE ALSO (related commands)

    • NOTES (release notes, bugs, quirks)

CME212 – Introduction to Large-Scale Computing in Engineering

High Performance Computing and Programming


Man tools l.jpg
Man Tools

  • By default man pages are shown using the more or less tool

    • $ man less

    • To trigger search press “/” and then a phrase

    • “/” + “SEE ALSO”

  • Raw format of man pages is device independent

    • You can generate ASCII, PS, DVI

    • Format: troff/nroff or groff (GNU variants)

CME212 – Introduction to Large-Scale Computing in Engineering

High Performance Computing and Programming


Man tools cont d l.jpg
Man Tools, cont’d

  • You can search the man database using the commands whatis and apropos

    • $ whatis malloc

    • $ apropos compression

    • $ apropos errno

  • Some interesting pages/commands

    • $ man intro (try all man sections)

    • $ tkman (graphical man browser)

CME212 – Introduction to Large-Scale Computing in Engineering

High Performance Computing and Programming


The compilation process l.jpg
The Compilation Process

  • The parser is language dependent, follows a grammar.

    • Checks your syntax

    • Called the front end of a compiler

  • The compiler works with an intermediate form, built from the parser output, which it operates on to produce assembly code

    • This form is language-independent

  • This involves register allocations, data layouts and code optimization (compiler course)

    • Back end

CME212 – Introduction to Large-Scale Computing in Engineering

High Performance Computing and Programming


Some compiler options l.jpg
Some Compiler Options

  • $ gcc -c

    • Just compile, don’t link

  • $ gcc -E

    • Just preprocess, print out source

  • $ gcc -S

    • Produce assembly code

  • $ gcc -o <file>

    • Save result into <file>

  • $ gcc -I<path>

    • Add <path> to search for include files

  • $ gcc -D<symbol>

    • Define the macro symbol <symbol>

    • Equivalent to #define <symbol>

CME212 – Introduction to Large-Scale Computing in Engineering

High Performance Computing and Programming


Documentation on gcc l.jpg
Documentation on gcc

  • $ man gcc

  • http://gcc.gnu.org/onlinedocs/gcc-4.0.3/gcc/

  • Typical manual topics

    • Introduction

    • Programming Languages Supported by GCC

    • Language Standards Supported by GCC

    • GCC Command Options

    • C Implementation-defined behavior

    • Extensions to the C Language Family

CME212 – Introduction to Large-Scale Computing in Engineering

High Performance Computing and Programming


The link editor ld l.jpg
The Link Editor (ld)

  • The compiler produces machine code and a table of names (symbol table) of variables and procedures

    • This is called an object file (.o)

  • The link editor (or linker) takes several object files and merges them, by associating the symbols with machine code addresses

    • Performs relocation

    • Works with position-independent code (PIC)

CME212 – Introduction to Large-Scale Computing in Engineering

High Performance Computing and Programming


Symbol table example l.jpg

#include <stdio.h>

#include <math.h>

int im_a_global;

int main(void) {

double pi;

pi = 4.0*atan(1.0);

printf(“Pi is %lf\n”,pi);

return 0;

}

$ gcc –c pi.c

$ nm pi.o

00000004 C im_a_global

00000000 T main

U printf

$ gcc –o pi pi.o

$ ./pi

Pi is 3.141593

Symbol Table Example

Undefined symbol

Automatic variables are not exported to the linker

CME212 – Introduction to Large-Scale Computing in Engineering

High Performance Computing and Programming


Executable files l.jpg
Executable Files

  • The link editor produces an executable file which is compatible with the program loader

    • Format: ELF (Executable and Linking Format)

  • When a program is executed, the program loader copies the sections of the executable file into the virtual address space and execution can begin

CME212 – Introduction to Large-Scale Computing in Engineering

High Performance Computing and Programming


Executable files example l.jpg

$ gcc –o pi pi.c

$ nm ./pi

08049508 D _DYNAMIC

080495dc D _GLOBAL_OFFSET_TABLE_

08048470 T __i686.get_pc_thunk.bx

080494f4 A __init_array_end

080494f4 A __init_array_start

08048420 T __libc_csu_fini

080483c0 T __libc_csu_init

U __libc_start_main@@GLIBC_2.0

080495fc A _edata

08049604 A _end

080484b4 T _fini

080484d0 R _fp_hw

08048284 T _init

080482d0 T _start

08049600 B im_a_global

08048374 T main

080495f8 d p.4385

U printf@@GLIBC_2.0

This output is truncated and formatted. Some elements have been taken away

#include <stdio.h>

#include <math.h>

int im_a_global;

int main(void) {

double pi;

pi = 4.0*atan(1.0);

printf(“Pi is %lf\n”,pi);

return 0;

}

Executable Files, Example

The compiler inserts some loading code into the executable

Undefined symbols are left to the runtime linker

CME212 – Introduction to Large-Scale Computing in Engineering

High Performance Computing and Programming


Libraries l.jpg
Libraries

  • It is very common to use a library of object files instead of explicitly stating every object file to use when linking

    • Libraries can be either static or dynamic

  • In static libraries (.a), the object files are copied into the executable file

  • In dynamic libraries (.so, .dll), only the symbols are associated and the linking takes place at runtime by the runtime linker

    • Most dynamic libraries can also be shared between many programs to save memory

CME212 – Introduction to Large-Scale Computing in Engineering

High Performance Computing and Programming


Creating static libraries l.jpg
Creating Static Libraries

  • A static library is put together by the ar command

  • Static libraries are sometimes referred to as an archive (.a)

  • When using libraries the ”lib” part of the name is removed at link time

    $ gcc -c triangle.c

    $ ar cru libtriangle.a triangle.o

    $ gcc -c program.c

    $ gcc -o program program.o -L<path> -ltriangle

CME212 – Introduction to Large-Scale Computing in Engineering

High Performance Computing and Programming


Creating a dynamic library l.jpg
Creating a Dynamic Library

  • Dynamic shared libraries are created by the compiler where each object file should be compiled with -fPIC.

    $ gcc -c -fPIC triangle.c

    $ gcc -shared -fPIC -Wl,-soname,libtriangle.so -o libtriangle.so triangle.o

    $ gcc -c program.c

    $ gcc -o program program.o -L<PATH> -ltriangle

CME212 – Introduction to Large-Scale Computing in Engineering

High Performance Computing and Programming


Sun compiler l.jpg
Sun Compiler

  • The Sun compiler cc takes the same flags as gcc except for shared libraries

    • -fPIC is -KPIC

    • -shared is -G

  • Sun compiler more optimized for Sun’s hardware

    • junior.stanford.edu, tree.stanford.edu, CEES

  • More information

    • http://docs.sun.com

    • $ cc -flags

    • /opt/SUNWspro/docs/index.html

  • CME212 – Introduction to Large-Scale Computing in Engineering

    High Performance Computing and Programming


    Checking dependencies l.jpg

    #include <stdio.h>

    #include <math.h>

    int im_a_global;

    int main(void) {

    double pi;

    pi = 4.0*atan(1.0);

    printf(“Pi is %lf\n”,pi);

    return 0;

    }

    $ gcc –o pi pi.c

    $ ldd ./pi.o

    libm.so.6 => /lib/tls/libm.so.6 (0xb7f05000)

    libc.so.6 => /lib/tls/libc.so.6 (0xb7dcf000)

    /lib/ld-linux.so.2 => /lib/ld-linux.so.2 (0xb7f2c000)

    Checking Dependencies

    Lists libraries to be loaded at runtime. “ld-linux.so.2” is the runtime linker.

    $ man ld

    $ man ld.so

    CME212 – Introduction to Large-Scale Computing in Engineering

    High Performance Computing and Programming


    Linking and loading solaris l.jpg
    Linking and Loading, Solaris

    • ldd(1), lists dependencies of executable files or shared objects

    • dump(1), elfdump(1) dumps parts of an object file

    • nm(1), GNU program that lists symbols from object files

    • truss(1), traces system calls

    • sotruss(1), traces shared library calls

    • pstack PID, dumps the stack frames of a running process, see proc(1)

    • pldd PID, lists loaded dynamical libraries

    CME212 – Introduction to Large-Scale Computing in Engineering

    High Performance Computing and Programming


    Linking and loading linux l.jpg
    Linking and Loading, Linux

    • ldd(1), lists dependencies of executable files or shared objects

    • objdump(1) dumps parts of an object file or executable

    • readelf(1) dumps parts of executable files

    • nm(1), GNU program that lists symbols from object files

    • strace(1), traces system calls

    • ltrace(1), traces shared library calls

    CME212 – Introduction to Large-Scale Computing in Engineering

    High Performance Computing and Programming


    Strace pi l.jpg

    execve("./pi", ["./pi"], [/* 29 vars */]) = 0

    uname({sys="Linux", node="cardinal2.Stanford.EDU", ...}) = 0

    old_mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0xb7fc2000

    open("/etc/ld.so.preload", O_RDONLY) = -1 ENOENT (No such file or directory)

    open("/etc/ld.so.cache", O_RDONLY) = 3

    fstat64(3, {st_mode=S_IFREG|0644, st_size=15207, ...}) = 0

    old_mmap(NULL, 15207, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7fbe000

    close(3) = 0

    open("/lib/tls/libm.so.6", O_RDONLY) = 3

    read(3, "\177ELF\1\1\1\0\0\0\0\0\0\0\0\0\3\0\3\0\1\0\0\00005\0\000"..., 512) = 512

    fstat64(3, {st_mode=S_IFREG|0644, st_size=134496, ...}) = 0

    old_mmap(NULL, 136976, PROT_READ|PROT_EXEC, MAP_PRIVATE, 3, 0) = 0xb7f9c000

    old_mmap(0xb7fbd000, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED, 3, 0x20000) = 0xb7fbd000

    close(3) = 0

    open("/lib/tls/libc.so.6", O_RDONLY) = 3

    read(3, "\177ELF\1\1\1\0\0\0\0\0\0\0\0\0\3\0\3\0\1\0\0\0`Z\1\000"..., 512) = 512

    fstat64(3, {st_mode=S_IFREG|0755, st_size=1254660, ...}) = 0

    old_mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0xb7f9b000

    old_mmap(NULL, 1264972, PROT_READ|PROT_EXEC, MAP_PRIVATE, 3, 0) = 0xb7e66000

    old_mmap(0xb7f90000, 36864, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED, 3, 0x129000) = 0xb7f90000

    old_mmap(0xb7f99000, 7500, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) = 0xb7f99000

    close(3) = 0

    set_thread_area({entry_number:-1 -> 6, base_addr:0xb7f9b820, limit:1048575, seg_32bit:1, contents:0, read_exec_only:0, limit_in_pages:1, seg_not_present:0, useable:1}) = 0

    munmap(0xb7fbe000, 15207) = 0

    fstat64(1, {st_mode=S_IFCHR|0720, st_rdev=makedev(136, 7), ...}) = 0

    mmap2(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0xb7fc1000

    write(1, "Pi is 3.141593\n", 15Pi is 3.141593

    ) = 15

    munmap(0xb7fc1000, 4096) = 0

    exit_group(0) = ?

    $ strace ./pi

    Math library is loaded

    Stdio library

    CME212 – Introduction to Large-Scale Computing in Engineering

    High Performance Computing and Programming


    Make maintenance tool l.jpg
    make, Maintenance Tool

    • make is usually used to compile and link programs consisting of several files

    • A program often uses, or depends on, several other modules or libraries

    • A Makefile specifies the dependencies between the program and the modules

    • If a file changes, make recompiles only those files which depend on the changed file

    CME212 – Introduction to Large-Scale Computing in Engineering

    High Performance Computing and Programming


    Make concepts l.jpg
    make, Concepts

    • target: A file that depends on other files

    • dependencies: A list of files that a target depends on

    • rule: How to build a target

    prog: module1.o prog.o

    gcc -o prog module1.o prog.o

    prog.o: prog.c module1.o

    gcc -c prog.c

    module1.o: module1.c module1.h

    gcc -c module1.c

    <TAB>

    CME212 – Introduction to Large-Scale Computing in Engineering

    High Performance Computing and Programming


    Make advanced usage l.jpg
    make, Advanced Usage

    • $* - base name of current target (no extension)

    • $@ - full name of current target

    • $< - name of a dependency file

    • $? - the list of dependencies newer than target

    • The makedepend command goes through source files and determines dependencies for you, see man makedepend

      depend:

      makedepend prog.c

    CME212 – Introduction to Large-Scale Computing in Engineering

    High Performance Computing and Programming


    Make example l.jpg
    make, Example

    CFLAGS = -g -Wall

    CC = gcc

    LIBS = -lm

    INCLUDES =

    OBJS = a.o b.o c.o

    SRCS = a.c b.c c.c prog1.c prog2.c

    HDRS = abc.h

    all: prog1 prog2

    # The variable $@ has the value of the target. In this case $@ = prog1

    prog1: prog1.o ${OBJS}

    ${CC} ${CFLAGS} ${INCLUDES} -o $@ prog1.o ${OBJS} ${LIBS}

    prog2: prog2.o ${OBJS}

    ${CC} ${CFLAGS} -o $@ prog2.o ${OBJS} ${LIBS}

    .c.o:

    ${CC} ${CFLAGS} ${INCLUDES} -c $<

    MACROS

    CME212 – Introduction to Large-Scale Computing in Engineering

    High Performance Computing and Programming


    Make example cont d l.jpg
    make, Example cont’d

    depend:

    makedepend ${SRCS}

    clean:

    rm *.o core *~

    tar:

    tar cf code.tar Makefile *.c *.h testfile1

    print:

    more Makefile $(HDRS) $(SRCS) | enscript -2r -p listing.ps

    # DO NOT DELETE THIS LINE -- make depend depends on it

    CME212 – Introduction to Large-Scale Computing in Engineering

    High Performance Computing and Programming


    Source code management l.jpg
    Source Code Management

    • A lot of people can work on the same code

    • Store all your code in a safe repository

    • Check out a version, which gives a local copy of the requested source code

    • Check in alterations (commit), to submit your modified code

      • Versioning is done automatically with comments

    • Resolve inconsistensies at check in, by merging the codes (often done manually)

    • Several tools:

      • CVS (most common), PRCS, RCS, SCCS, Subversion

    CME212 – Introduction to Large-Scale Computing in Engineering

    High Performance Computing and Programming


    Using rcs l.jpg
    Using RCS

    • RCS puts the history files into a directory called RCS

      • Local repository

    • History files end with the suffix ,v

      $ man rcsintro

      $ co myprog.c

      $ ci myprog.c

      $ rcsdiff myprog.c

    • The “Tools” menu in GNU emacs provides a nice interface to RCS

    CME212 – Introduction to Large-Scale Computing in Engineering

    High Performance Computing and Programming


    More on rcs l.jpg
    More on RCS

    • RCS can annotate your source using the “$id$” tag

    • RCS inputs version data

    • More details are given using the “$Log$” variable

    • You can go back using co with the –r flag to specify a revision to checkout

    CME212 – Introduction to Large-Scale Computing in Engineering

    High Performance Computing and Programming


    Team projects l.jpg
    Team Projects

    • For projects involving multiple developers at different locations we need more sophisticated tools

      • Access control

      • Security/encryption

      • Handling conflicts

    • Two major tools used in the open source community

      • CVS

      • Subversion

    CME212 – Introduction to Large-Scale Computing in Engineering

    High Performance Computing and Programming


    Basic svn usage l.jpg
    Basic SVN Usage

    • Create your filesystem layout locally

    • Use svn import to copy this structure to the repository

      $ svn import https://wilkinson.stanford.edu/svn/cme212/henlof/ -m “Initial import”

    • Use svn checkout and svn commit to reflect changes in your local filesystem to the repository

    CME212 – Introduction to Large-Scale Computing in Engineering

    High Performance Computing and Programming


    Typical svn repository layout l.jpg
    Typical SVN Repository Layout

    • https://wilkinson.stanford.edu/svn/cme212/SUNetID/

    project1/

    trunk/

    tags/

    branches/

    “trunk” stores the current active branch

    “branches” store experimental releases

    “tags” are finished products

    project2/

    trunk/

    tags/

    branches/

    project3/

    trunk/

    tags/

    branches/

    CME212 – Introduction to Large-Scale Computing in Engineering

    High Performance Computing and Programming


    Debuggers l.jpg
    Debuggers

    • A debugger helps you find causes of errors in your code

    • Executes your code like an interpreter

      • You can step through your program

      • Set breakpoints

      • Print and set variables

      • Catch run-time exceptions

    • Two standard debuggers

      • gdb (GNU)

      • dbx

    CME212 – Introduction to Large-Scale Computing in Engineering

    High Performance Computing and Programming


    Compiling for debugging l.jpg
    Compiling for Debugging

    • To be able to refer to names and symbols in your source code it must be stored in the executable file

      • Standard flag -g

    • Without -g you can only debug using virtual addresses

    CME212 – Introduction to Large-Scale Computing in Engineering

    High Performance Computing and Programming


    Debug information with g l.jpg

    #include <stdio.h>

    #include <math.h>

    int im_a_global;

    int main(void) {

    double pi;

    pi = 4.0*atan(1.0);

    printf(“Pi is %lf\n”,pi);

    return 0;

    }

    $ gcc –c –g pi.c

    $ readelf -w pi.o

    <1><104>: Abbrev Number: 4 (DW_TAG_subprogram)

    DW_AT_sibling : <12e>

    DW_AT_external : 1

    DW_AT_name : main

    DW_AT_decl_file : 1

    DW_AT_decl_line : 6

    DW_AT_prototyped : 1

    DW_AT_type : <ad>

    DW_AT_low_pc : 0

    DW_AT_high_pc : 0x3f

    DW_AT_frame_base : 1 byte block: 55 (DW_OP_reg5)

    <2><120>: Abbrev Number: 5 (DW_TAG_variable)

    DW_AT_name : pi

    DW_AT_decl_file : 1

    DW_AT_decl_line : 8

    DW_AT_type : <fa>

    DW_AT_location : 2 byte block: 75 78 (DW_OP_breg5: -8)

    <1><12e>: Abbrev Number: 6 (DW_TAG_variable)

    DW_AT_name : im_a_global

    DW_AT_decl_file : 1

    DW_AT_decl_line : 4

    DW_AT_type : <ad>

    DW_AT_external : 1

    DW_AT_location : 5 byte block: 3 0 0 0 0 (DW_OP_addr: 0)

    Debug Information with -g

    CME212 – Introduction to Large-Scale Computing in Engineering

    High Performance Computing and Programming


    Using gdb l.jpg
    Using gdb

    $ gdb ./pi

    (gdb) break main

    Breakpoint 1 at 0x8048380: file pi.c, line 10.

    (gdb) run

    Starting program: /afs/ir.stanford.edu/users/h/e/henlof/test/trunk/pi

    Breakpoint 1, main (argc=1 ,..) at debug_me.c:19

    (gdb) print pi

    $2 = 4.8542713620543657e-270

    (gdb) next

    11 printf("Pi is %lf\n",pi);

    (gdb) print pi

    $3 = 3.1415926535897931

    (gdb) list

    6 int main(void) {

    7

    8 double pi;

    9

    10 pi = 4.0*atan(1.0);

    11 printf("Pi is %lf\n",pi);

    12

    13 return 0;

    14 }

    (gdb) where

    #0 main () at pi.c:11

    CME212 – Introduction to Large-Scale Computing in Engineering

    High Performance Computing and Programming


    Some gdb commands l.jpg
    Some gdb Commands

    CME212 – Introduction to Large-Scale Computing in Engineering

    High Performance Computing and Programming


    More on gdb l.jpg
    More on gdb

    • Type help in the gdb prompt

      • help breakpoints, help running

    • gdb can also debug core dumps and attach to already-running processes that you own

    • There is a graphical interface to gdb called the “Dynamic Data Debugger” ddd

      • $ ddd ./a.out

      • Allows you to visualize data and breakpoints

    CME212 – Introduction to Large-Scale Computing in Engineering

    High Performance Computing and Programming


    Core files l.jpg
    Core Files

    • The OS can be configured to dump the virtual address space of a process to a core file

    • Typically this happens at a fatal error

      • core dumped

    • This file can be used to debug your progam post-mortem

      • Especially useful if debug symbols are present

    CME212 – Introduction to Large-Scale Computing in Engineering

    High Performance Computing and Programming