Scribd
Upload
44 views

Digital Computer Systems Lecture 4

This document summarizes a lecture on high-level languages. It discusses why high-level languages are used, their main characteristics, and common features such as variables, data types, control structures, subroutines, I/O, and application programming interfaces. The typical phases of a compiler are described, including lexical analysis, syntactic analysis, semantic analysis, code generation, and optimization. MIPS assembly language is given as an example target language.

Uploaded by

SRA893
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
44 views

Digital Computer Systems Lecture 4

This document summarizes a lecture on high-level languages. It discusses why high-level languages are used, their main characteristics, and common features such as variables, data types, control structures, subroutines, I/O, and application programming interfaces. The typical phases of a compiler are described, including lexical analysis, syntactic analysis, semantic analysis, code generation, and optimization. MIPS assembly language is given as an example target language.

Uploaded by

SRA893
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 20

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

You might also like