Computer Organization and Assembly Language Programming

Chenxi Wang and Muhammad Rashed’s Computer Organization and Assembly Language Programming connects the behavior of high-level programs with ARMv7 instructions, registers, and memory. Its sixteen chapters build from number representation to executable control flow, data layout, floating-point operations, and memory performance. The important progression is from reading individual instructions to explaining how an entire procedure changes machine state. Examples use a particular teaching architecture; learners should distinguish that model from claims about every processor. This guide follows the 2026 first edition published by Mavs Open Press.

Chapter-by-chapter summaries

1. Introduction to CSE2312

The opening chapter positions computer organization between software abstractions and the hardware that executes them. Assembly is useful because it exposes the operations hidden by a compiler: moving values, computing addresses, testing conditions, and transferring control. Understanding those operations helps explain both correctness and performance. Begin a concept map linking source code, machine instructions, the processor, and memory. The goal is not to memorize mnemonics in isolation but to see how an algorithm becomes a sequence of state changes.

2. The Number Systems

Binary, octal, decimal, and hexadecimal represent values using different place weights. The chapter distinguishes unsigned representations from signed representations, with two’s complement providing the working basis for negative integers. A bit pattern alone does not identify its interpretation: width and signedness matter. Write both the unsigned and signed readings of the same fixed-width pattern. This makes later arithmetic errors easier to diagnose because an unexpected decimal answer may reflect an interpretation problem rather than an incorrect binary operation.

3. Conversion of Number Systems

Conversions are developed through positional weights and repeated division. Hexadecimal groups bits conveniently, making it a practical notation for addresses and register contents. The essential skill is explaining why a conversion works, then checking it in the reverse direction. Preserve leading zeros when a problem specifies a register width; they may matter to later interpretation even when they do not change an unsigned value. A useful exercise is to convert one value by two methods and identify the intermediate checks that establish agreement.

4. ALU Operations

The arithmetic logic unit carries out arithmetic and logical transformations on bit patterns. Addition and subtraction connect to two’s complement, while AND, OR, and related operations support masks that inspect or alter selected bits. The distinction between logical operations and ordinary numerical comparison is central. Trace a mask across every bit rather than guessing from the decimal values. Explain which bits must stay unchanged and which must change; that specification provides a clear way to judge whether the chosen operation is correct.

5. Flags and Shift Operations

Status flags record properties of arithmetic results, including zero, negative, carry, and signed overflow. Carry and overflow answer different questions because unsigned range and signed range differ. Shifts and rotations then move bits in ways that support scaling, extraction, and manipulation. Arithmetic right shift preserves sign information in the teaching model, whereas logical right shift introduces zeros. For each example, track the original width, discarded bits, resulting value, and relevant flags. Avoid treating every shift as exact multiplication or division without checking representation and lost information.

6. Assembly Syntax

The instruction format combines an operation, optional conditions and flag behavior, destination, and operands. ADD, ADC, MOV, subtraction variants, comparisons, multiplication, and related forms demonstrate how small syntactic differences change machine behavior. The chapter’s condition suffixes depend on earlier flag results, so reading an instruction requires context. Annotate a short sequence with register values before and after each line. Then change only the flag-setting suffix or a condition and explain why the resulting execution differs, even though much of the instruction text remains identical.

7. Data in Memory and the Load-Store Architecture

Registers and memory are separate parts of the programming model. Load and store instructions transfer values of particular sizes, while byte addressing and endianness determine where the constituent bytes appear. The chapter introduces pointer arithmetic and addressing modes as tools for locating data. Draw memory as numbered byte cells and place a multibyte value into them before executing a load. Keep three things distinct: the address, the bytes stored there, and the value reconstructed from those bytes. This distinction prevents a large class of assembly tracing mistakes.

8. Branch Instructions, Procedure Calling, and Assembly Implementation

Branches turn a sequential instruction stream into decisions, loops, and calls. A comparison supplies flag information; a conditional branch uses that information to select the next instruction. Procedure calls introduce a return location and a need to coordinate caller and callee behavior. The worked implementations connect these mechanisms to recognizable programming tasks, including bit-oriented loops. Translate a small loop into a flowchart before assembly, then identify its initialization, condition, body, and update. Verify that all paths reach the intended exit and preserve required state.

9. Stack

The stack provides organized temporary storage for procedure execution. PUSH and POP, the stack pointer, link register, and program counter must be tracked together to understand saved values and return control. Nested calls expose why a return address cannot simply be left unprotected in a register that another call may overwrite. Draw stack contents after each operation, recording both addresses and values. At procedure exit, compare the restored state with the calling contract. A program can calculate the right local answer and still fail if its stack or saved registers are left inconsistent.

10. String in Memory and Assembly Implementation

Character data is represented through byte values, and the chapter uses ASCII-based, null-terminated strings to show how those bytes form a sequence. Assembly must explicitly advance through memory and test for the terminating zero. The character representing the digit zero differs from the zero byte that ends a string. Trace a traversal using a table of addresses, loaded bytes, and branch outcomes. Explain how the loop detects completion without confusing the terminator with printable text, and identify which assumptions depend on this particular string representation.

11. Array of Integers in Memory and Assembly Implementation

Integer arrays extend the traversal pattern, but element size changes the stride between addresses. A 32-bit element occupies four bytes, while a 16-bit element occupies two; array indices and byte offsets therefore cannot be interchanged. Post-indexed addressing combines access with pointer advancement and helps express compact loops. Before tracing code, write the address formula for the chosen type and compute several consecutive element locations. Use those locations to check both the loop’s data access and its termination, especially when comparing element counts with byte counts.

12. Binary Decoding and Encoding: Floating-Point and Decimal

The chapter moves beyond integer representations to fractional binary values and floating-point encoding. Positional weights on both sides of the binary point establish the groundwork for interpreting sign, exponent, and significand. A decimal value that seems simple may not have a finite binary representation, making precision and rounding part of the representation rather than incidental display issues. Decode a pattern into its components before calculating its value. Contrast numerical conversion with copying an unchanged bit pattern; the two operations answer different questions and prepare for the VFP chapter.

13. Data Alignment: Packed and Unpacked

Data layout determines the offsets of fields and the padding between them. Packed structures prioritize compact storage, while aligned layouts may reserve unused bytes to fit the architecture’s access requirements and performance model. The chapter links these layout decisions to assembly addressing. Draw two versions of the same record and label every field and padding byte. Then calculate the address of a field in an array of those records. This reveals why a correct field offset is insufficient if the programmer has also assumed the wrong total record size.

14. VFP Instructions and Assembly Implementation

The floating-point register bank and VLDR, VSTR, VMOV, and VCVT separate loading, storing, moving, and numerical conversion. Single- and double-precision registers overlap in the described organization, so modifying one view can affect another. Moving integer-looking bits into a floating-point register does not by itself convert their numerical meaning. Build an operation table specifying source representation, destination representation, and whether the value or only the bits should be preserved. Follow that table through a mixed integer and floating-point example to expose accidental reinterpretations.

15. Clock Cycle and Pipeline in ARM

Clock period and frequency provide a time scale, while the simplified fetch-decode-execute pipeline explains overlapping instruction work. Pipelining can improve throughput without making every individual instruction complete in a single stage. Branches and dependencies complicate the ideal schedule. Draw a cycle chart with one row per instruction and identify startup, overlap, and disruption. Treat the chapter’s timing figures as teaching examples, then distinguish latency, throughput, and clock rate. Those distinctions prevent the misleading assumption that a higher frequency alone completely determines program speed.

16. RAM, Cache, and Memory Virtualization

The final chapter explains why a fast processor can still wait for memory. Temporal and spatial locality make a smaller, faster cache useful; virtual memory adds a separate layer that maps program-visible addresses to physical storage. Cache and virtual memory solve related but different problems and should not be conflated. Compare sequential array access with scattered access using the same number of arithmetic operations. Explain which references may benefit from locality and where address translation enters the path. The conclusion connects earlier instruction tracing to the larger system that makes execution possible.

Study instructions

1. Create a machine-state notebook with separate columns for registers, flags, memory addresses, memory contents, and the next instruction. Update only what an instruction actually changes.
2. Practise signed and unsigned interpretations before conditional branches. For each comparison, state which interpretation the condition assumes.
3. Translate a short C-style string or array loop into pseudocode, then assembly; trace an empty input, a one-element input, and a normal input.
4. Draw the stack for a nested call and check that entry and exit agree on saved registers, return information, and stack position.
5. Finish with a performance explanation that separates instruction count, pipeline behavior, data locality, and memory latency. Use the textbook’s machine model when checking examples.

Questions for reflection

• Why can the same arithmetic result set carry without signed overflow, or signed overflow without carry?
• How does confusing an index with a byte offset change an integer-array traversal?
• What is the difference between moving a floating-point bit pattern and converting a numerical value?
• Why does a pipelined processor still need caches and a virtual-memory system?

Sources and coverage

This original study guide follows all main chapters of the source edition linked below. Summaries explain the central concepts and their connections; practice tasks and reflection questions are editorial study aids. Consult the complete text for worked examples, figures, exercises, and references. Read the source edition.