CMPSC 311 Test 2 Build Processing

Question 1

semantics, machines

Answer 1

Why do we build programs: to turn program —– from human-readable text into something —- understand

Question 2

compilers, interpretors

Answer 2

why use language —- instead of ——-? It depends

Question 3

compiling, linking, gcc, Id

Answer 3

there are two phases of building a program, — and —–

—– is used to build the program

—- can be used to link the program (or gcc)

Question 4

gcc [options]

Answer 4

You will run a command to compile: ——————-

Question 5

-c

Answer 5

—– tells the compiler to just generate object files

Question 6

-Wall

Answer 6

—- tells the compiler to show all warnings

Question 7

-g

Answer 7

—– tells the compiler to generate debug information

Question 8

-o

Answer 8

— —— write output to a file

Question 9

gcc hello.c -c -Wall -g -o hello.c

Answer 9

compiling hello.c syntax

Question 10

gcc [options]

Answer 10

command to link sytnax: ——-

Question 11

-l

Answer 11

—– link with a library

Question 12

-g

Answer 12

tells the compiler to generate debug information

Question 13

-o

Answer 13

write output to files

Question 14

gcc hello.o goodbye.o -g -lmyexample -o hello

Answer 14

linking program syntax

Question 15

library

Answer 15

A —— is a collection of related code and functions that are linked against a C program

Question 16

exports, symbols

Answer 16

the library —- ——-

Question 17

unresolved symbols

Answer 17

Your program object code has ——– ——

Question 18

linker, program

Answer 18

the —- pulls chunks of the library. containing those symbols and places them into the ———

Question 19

resolved

Answer 19

the program is done linking when all the pieces are —–

Question 20

static

Answer 20

It is called —— linking because this is done at link time

Question 21

statically linked, archive, linker, code

Answer 21

A —– —– library produces object code that is inserted into program at link time.

You are building an —- of the library which the —- uses to search for and transfer —- into your program

Question 22

ar rcs lib .a

Answer 22

static library syntax

Question 23

lib???.a

Answer 23

library naming: with very few exceptions all static libraries are named ———

Question 24

name, file

Answer 24

You link against the —– of the library, not against the name of the —- in which the library exists

Question 25

R

Answer 25

—- replace existing code with the objects passed

Question 26

C

Answer 26

—- create the library if needed

Question 27

S

Answer 27

—– create an index for relocatable code

Question 28

dynamic library

Answer 28

A —– —- is a collection of related code and functions that are —- at runtime

Question 29

exports, symbols

Answer 29

The library —– —–

Question 30

unresolved symbols

Answer 30

Your program object code has —– ——

Question 31

loader

Answer 31

the —- pulls chunks of the library containing those symbols and places them in the process

Question 32

started, execution

Answer 32

The symbols are resolved when the process is —— or later during ——-

Question 33

any time

Answer 33

it is called dynamic library, because it can be done at —– —–

Question 34

execution, loadable, launch

Answer 34

a dynamically linked library produces object code that is inserted into program at —— time.

You are building a —- version of the library which the loader uses to —— the application

Question 35

gcc -shared -o libmyexample.so a.o b.o c.o d.o

Answer 35

dynamic library syntax

Question 36

position-independent code (PIC)

Answer 36

Important: all object files to be placed in library must have been compiled to —— ——- ——

Question 37

predefined, memory, jumps, execution

Answer 37

PIC is not dependent on any being located at any —– location in ——

eg, uses relative —–, so does not matter where it is loaded at —– time

Question 38

.so

Answer 38

Naming dynamic library with PIC is same as before?? only with —– extension ???? CHECK SLIDE 11

Question 39

gcc a.c -fpic -c -Wall -g -o a.o

Answer 39

dynamic library PIC syntax

Question 40

preprocessor, compile

Answer 40

The ——– processes input source code files for commands that setup the —— environment specific to that execution

Question 41

#

Answer 41

The programmer uses —- directives to indicate what he wants that program to do. Like in —include.

there are more…

Question 42

include

Answer 42

the —- directive tells the compiler to include data from some other data file

Question 43

include “foo.h”

Answer 43

——- ——: this tells the compiler to look in the local (used for application programming)

Question 44

include

Answer 44

——- —- : tells the compiler to look at the default directories and any provided by the command line

Question 45

gcc -I, <>

Answer 45

the —— —- option:

tells the compiler to look in a specific director for include files (that are using the approach)

generally speaking, systems programming uses the —- approach to have better control over what is being included from where

Question 46

define

Answer 46

the ——- directive allows the user to create a definition symbol that gets search/replaced throughout

Question 47

constant, arrays

Answer 47

The #define is commonly used to define a constant that might be changed in the future eg the size of —–

Question 48

undef

Answer 48

the —– directive undoes binding

Question 49

define

Answer 49

—— can also be used to create simple functions called macros

Question 50

macros, overheads

Answer 50

—— are not called as normal functions, but are replaced during preprocessing

thus no function call —— such as stack operations

Question 51

if, #ifdef, #ifndef

Answer 51

You can conditionally compile parts of a program, using the —–, —–, and —– directives

Question 52

make

Answer 52

the — utility is a utility for binding complex systems/program

Question 53

out of date, dependencies, project files

Answer 53

the make utility:

figure out which parts of system are —– —- —-

figure out what the —— are between objects

issue command to create the intermediate and final —— ——

Question 54

make

Answer 54

Note: being a good systems programmer requires mastering the —– utility

Question 55

Makefile

Answer 55

Each system you want to build has one (or more) files defining how to build, called the ——

Question 56

build, way, relate

Answer 56

a Makefile defines the things to —–, the —- to build them, and the way they —–

Question 57

Target

Answer 57

Makefile:

—- a thing to build

Question 58

Prerequisites

Answer 58

Makefile:

—– things that the target depends on

Question 59

dependencies

Answer 59

Makefile:

—– between files eg a.o depends on a.c

Question 60

variables

Answer 60

Makefile:

—– dat that defines elements of interest to the build

Question 61

rules

Answer 61

Makefile:

—- are statements of targets, prerequisites and commands

Question 62

rule

Answer 62

Also known as production, a —- defines how a particular item is built.

Question 63

target: preq1, preq2, preq3..
command1
command2

(NOTE: commands must be tabbed over)

Answer 63

rule syntax

Question 64

target, prereq(1|2|3), commands

Answer 64

rule syntax:

• — is the thing to be built
• —- are things needed to make the target
• — are the UNIX commands to run to make target

Question 65

commands, target, prerequisites

Answer 65

Makefile rules:

Key idea: run the —- to build the —- when any of the noted —– are out of date

Question 66

make

Answer 66

To run make, just type —- at the UNIX prompt.

Question 67

Makefile, targets, dependency graph

Answer 67

running make:

It will open the —- and build any — that are out of date. thus it will look at the ——- —–.

Question 68

variables

Answer 68

Makefile —- allow you to replace some repetitive (and changing text) with others

Question 69

CC=gcc
LINK=gcc
CFLAGS=-c -Wall -I

Answer 69

some standard Makefile variables include

Question 70

special

Answer 70

Make supports a range of —– variables that are used while evaluating each rule (called built-ins)

Question 71

$@, $^, $

Answer 71

three of the most popular make built-ins

• — is the current rule target
• — is the prerequisite list
• — is the first prerequisite

Question 72

builds

Answer 72

Built-ins are used to make —— cleaner

Question 73

suffix rule

Answer 73

A —- —- defines a default way to generate a target from a type of prerequisites.

Question 74

dependency,

Answer 74

suffix rule: You only need to define the —- and not the commands for those files.

Question 75

types, productions

Answer 75

Defining suffix rule:

Step 1: define the file —– to be in suffix rules

Step 2: define the default ——-

Question 76

builds

Answer 76

You will begin to develop a set of patterns for makefiles that you will use repeatedly over time on the different (and increasingly complex) builds. We will explore the use of these over the course of this semester.