EE 344

Digital Computer Systems

Lecture 4: High-Level Language

Why HLL?
Shield programmers from detailed
machine-level specifications (hence
higher productivity)
Portability
Easy to upgrade (e.g. CC++->C#)

Main Characteristics
Usually translated by compilers

Except scripting languages (Perl, JavaScript, )

What an HLL programmer sees, depends

on the language at hand
Mostly data structures and operations
on those structures
Each data structure has a certain type
which determines
its characteristics
the operations that can be performed on it

Features Common to most HLL

Variables and Constants

Arithmetic/logic operators and assignment
Conditional statements and loops
Subroutines, procedures, or functions
IO streams and files
Application Programming Interface (API)

Variables and Constants

Allows the programmer to refer to data values symbolically by name

Type (for the compiler to allocate memory space)

Scope (when and where the variable is active)

storage class (determines the period the variable exists)

Data structure: array and structures

Declaration and initialization

Signed and unsigned integers

Floating points
Character
pointer

Global
local

Automatic (is the default for variables declared inside a block)

Static
dynamic

Control Structures
What distinguishes a computer from a
calculator
Used for making decisions and loops

Subroutines
Why do we need them?
Economy: decrease program size
Modularity: facilitate the programming

Functions and Procedures

Subroutine nesting and recursion
Libraries

IO Streams and Files

Program accepts external inputs, in
order to solve different instances of
the problem
The results must go somewhere
Programmers do not concern themselves
with any specific IO device
Files: opened, accessed, and closed

API (Application Programming

Interface)
Set of commands from the application
to the operating system
Simplifies the job of the application
programmer
Three classes of API commands:
IO Management
Memory Management
Process Management

How API Works

Different Paradigms
Imperative/Procedural (e.g. C)
a list of operations to do in order

Object Oriented (e.g. C++, Java)

groups of communicating bubbles

Functional (e.g. LISP)

Based on recursion

Logical (e.g. Prolog)

Based on symbolic logic

Compiler

Qualities of a Good Compiler

Correct: the meaning of sentences must be preserved
Robust: wrong input is the common case
compilers and interpreters cant just crash on wrong input
they need to diagnose all kinds of errors safely and reliably

Efficient: resource usage should be minimal in two

ways
the process of compilation or interpretation itself is
efficient
the generated code is efficient when interpreted

Usable: integrate with environment, accurate

feedback

work well with other tools (editors, linkers, debuggers, . . . )

descriptive error messages, relating accurately to source

Anatomy of a Compiler

Typical Phases of a Compiler

Lexical analysis
Syntactic analysis
Semantic analysis
Code generation (high/intermediate
level)
Optimization
Code generation (object file or machine
code)

X = 3.14 * (9.0 +Y)

X = 3.14 * (9.0 +Y)

<ID,x>, EQ, <FLOAT,3.14>, STAR, LPAR, <FLOAT,9.0>, PLUS, <ID,y>, RPAR

X = 3.14 * (9.0 +Y)

10

X = 3.14 * (9.0 +Y)

11

Is X and Y of compatible type?

Is this type compatible with the constants?

12

13

Example

14

Example: Lexical Analysis

Example

15

Example: Syntactic Analysis

Example

16

Example: Semantic Analysis

Example: IR (intermediate
representation)

17

Example: IR optimization
IR

Optimized IR

Example: Assembly Language

Generation

18

MIPS Instruction Set

Used as an example throughout the text book
Stanford MIPS commercialized by MIPS Technologies
(www.mips.com)
A discussion of MIPS can be found on Wikipedia
(http://en.wikipedia.org/wiki/MIPS_architecture)
Decent share of embedded core market
Applications in consumer electronics, network/storage
equipment, cameras, printers,
Typical of many modern ISAs
See MIPS Reference Data tear-out card from your textbook,
and Appendixes B and E on the course web page

19

See You in the Assembly

Language Level!

20