Course Outline

Active Outline

General Information

Course ID (CB01A and CB01B): CISD21JA
Course Title (CB02): Introduction to x86 Processor Assembly Language and Computer Architecture
Effective Term: Fall 2021
Course Description: This course is an introduction to the syntax and semantics of the x86 processor assembly language, standard instruction set, selected macros and directives, and x86 architecture.
Course Family: Not Applicable

Course Justification

This course is the beginning course for a two-course series in Assembly Language Programming. It is a required transfer course for some of the CSUs and UCs, and is transferable to all CSUs and UCs. The course is also a required course for the Systems Programming Degree and Certificate of Achievement Advanced.

Foothill Equivalency

Does the course have a Foothill equivalent?: No
Foothill Course ID

Formerly Statement

Course Development Options

Basic Skill Status (CB08)

Course is not a basic skills course.

Grade Options

Letter Grade
Pass/No Pass

Repeat Limit

Transferability & Gen. Ed. Options

Transferability: Transferable to both UC and CSU

De Anza GE	Area(s)	Status	Details
2G4M	DA and 4-yr GE Math Ag	Approved

C-ID	Area(s)	Status	Details
COMP	Computer Science	Approved	C-ID COMP 142

Units and Hours

Summary

Minimum Credit Units: 4.5
Maximum Credit Units: 4.5

Weekly Student Hours

Type	In Class	Out of Class
Lecture Hours	4.0	8.0
Laboratory Hours	1.5	0.0

Course Student Hours

Course Duration (Weeks): 12.0
Hours per unit divisor: 36.0

Course In-Class (Contact) Hours

Lecture: 48.0
Laboratory: 18.0
Total: 66.0

Course Out-of-Class Hours

Lecture: 96.0
Laboratory: 0.0
NA: 0.0
Total: 96.0

Prerequisite(s)

CIS D022B or CIS D22BH or CIS D026A or CIS D035A or CIS D036B or CIS D041A

Corequisite(s)

Advisory(ies)

Limitation(s) on Enrollment

Entrance Skill(s)

General Course Statement(s)

Methods of Instruction

Lecture and visual aids

Discussion of assigned reading

Discussion and problem solving performed in class

Quiz and examination review performed in class

Homework and extended projects

Laboratory discussion sessions and quizzes that evaluate the proceedings weekly laboratory exercises

Collaborative learning and small group exercises

Assignments

Reading from textbook and lecture notes
Homework assignments to practice deducing outcomes of given assembly instructions, investigate architectural components of the x86 microprocessors, and evaluate and convert numeric data representation
At least 5 - 7 programming assignments in x86 assembly code that implement one or more of the following concepts:
1. x86 architectural components memory and registers, and using different x86 data representation
2. Macros and procedures, and with direct and indirect memory access
3. Branching instructions to support control structures
4. Arithmetic implementation and data representation
5. Bitwise instructions

Methods of Evaluation

Evaluation of programming assignments for completeness, correctness, and efficiency of x86 assembly code and design
Evaluation of homework assignments for completeness and correctness of x86 assembly code analysis, debugging, and development, and for correctness of evaluating data representation in theory and in memory
One or more written midterm exams that includes programming problems to determine proficiency in analyzing and debugging assembly code, and multiple choice theory questions to determine proficiency on evaluating data representation and architectural components
Comprehensive written final exam to determine proficiency in evaluating, analyzing, and debugging code, and multiple choice theory questions to determine proficiency in evaluating data representation and architectural components

Essential Student Materials/Essential College Facilities

Essential Student Materials:

None.

Essential College Facilities:

Computer lab with x86 based computers running the Windows Operating System and MASM Assembler

Examples of Primary Texts and References

Author	Title	Publisher	Date/Edition	ISBN
Irvine, Kip. "Assembly Language for x86 Computers," 8th Edition. ISBN: 978-0135381656, Prentice-Hall, 2019

Examples of Supporting Texts and References

Author	Title	Publisher
Intel 64 and IA-32 Architectures Software Developer's Manuals. http://developer.intel.com/products/processor/manuals/index.htm

Learning Outcomes and Objectives

Course Objectives

Evaluate architectural components
Investigate computer data representation and convert from one numeric representation to another
Deduce hardware values resulting from a given machine instruction
Write assembly programs for x86 processors
Write simple macros
Evaluate efficiencies in programming

CSLOs

Investigate architectural components and design of microprocessors as well as evaluate and formulate computer and numeric data representation.
Design, code, document, analyze, debug, and test introductory level assembly programs for the x86 family of processors.

Outline

Evaluate architectural components
1. CPU
2. Memory
3. Registers
4. Flags set by hardware
5. Relationship to high level language software and to the operating system software
6. Instruction categories
7. Addressing modes
  1. Immediate
  2. Register
  3. Memory
Investigate computer data representation and convert from one numeric representation to another
1. Binary
2. Hexadecimal
3. Conversions between numeric representations
4. Character
5. Strings
Deduce hardware values resulting from a given machine instruction
1. Syntax
2. Data transfer instructions
3. Binary integer arithmetic
4. Conditional branching
  1. Hardware level
  2. Extended mnemonics
  3. Unconditional Jump
  4. Conditional Jump
5. Array access
6. String processing instructions
7. Bit-Level instructions
8. Run time stack instructions
9. Instructions for higher-level models
  1. 16-bit instructions and usage
  2. 32-bit instructions and usage
Write assembly programs for x86 processors
1. Syntax
2. Variables and constants
  1. Declarations
  2. Redefinition
  3. Conversion between types
3. Subroutine call and return
  1. Parameter passing
  2. Save and restore conventions
  3. Local variables
4. Copying instructions
5. Binary integer arithmetic
6. Conditional branching
  1. Hardware level
  2. Extended mnemonics
  3. If and If...Else...
7. Looping
  1. While construct
  2. For construct
  3. Repeat construct
8. Array access
  1. Direct addressing
  2. Indirect addressing
9. String processing instructions
10. Bit-Level instructions
11. Run time stack instructions
12. Added instructions for higher level models
  1. 16-bit instruction usage
  2. 32-bit instruction usage
Write simple macros
1. Parameter use
2. Prototype statements
3. Local variables
Evaluate efficiencies in programming
1. Speed
2. Memory
3. Maintenance
4. Productivity

Lab Topics

Modify and assemble sample programs using MASM; link object code with other library object code; use the debugger to step through instructions and watch memory and register content; explore different memory models; evaluate boolean operations
Define data of different data types; work with data representation in binary, octal, decimal, hexadecimal; save data in memory vs. registers; define constants; data transfer instructions
Code arithmetic instructions; observe flags that are set; interpret the result based on the flags; differentiate between signed and unsigned data
Call library procedures to implement basic data IO; define and call macros to simplify code for IO and basic operations
Write conditional jump, loop, unconditional jump, compare instructions to implement high level language constructs such as for loop, while loop, if statement
Write bit-wise instructions for boolean operation and test bits and use the result for conditional processing; use bit-wise operation for shift and rotate of signed and unsigned data
Code data related operators and directives to work with arrays and structures; use indirect addressing modes: direct offset addressing, register indirect addressing, base index addressing, and base index with displacement addressing to access different types of data structures
Write stack instructions to manage the run time stack for procedure calls; set the base pointer to the stack frame to access data on the run time stack; set up the stack frame during the procedure call; clean up the stack frame during the procedure return
Write procedures that pass parameters through registers and through the stack; implement procedures that pass data by address; implement re-entrant procedures
Write string instructions to manipulate arrays of different types of data