ARM 64-bit Assembly Language with Raspberry Pi

Explore the basic computer system design, detailing cpu, memory, system bus, and the roles of control unit. Grasp bits, lsb, msb, and bytes organize data.

Explore Arm v8 processor modes, focusing on aarch64: 64-bit registers x0–x30, pstate, stack pointer, program counter, and 32-bit instructions, with sequential execution and branch options.

Explore how computers use decimal, binary, and hexadecimal number systems in assembly language, with conversions between bases and representation in registers and memory using 0b and 0x prefixes.

Explore how computers interpret bits as numbers: unsigned 0 to 2 to the power n minus 1, signed using a sign bit and two's complement, converting binary, decimal, and hexadecimal.

Explore representing characters with ASCII, a 7-bit encoding using one byte per character, convert strings to ASCII codes in decimal or hexadecimal, and use null-terminated strings.

Install a 64-bit raspberry pi os with the raspberry pi imager, write it to an sd card, boot the pi, and set up gcc, ddd, and vscode for arm assembly.

Prepare the source file, apply preprocessing directives, assemble to an object file, then link with external modules such as C library code to create an executable, while handling errors.

Explore the arm 64-bit program structure, including data and text sections, comments, and labels. Learn how instructions become machine code and how to assemble and run with gcc.

Learn debugging ARM 64-bit assembly on Raspberry Pi by stepping through code, setting breakpoints, and inspecting registers and memory to understand how the counter variable is loaded and manipulated.

Define variables in the data section with name, size, and initial value, using quad for 8-byte storage. Use byte, half word, or word directives and observe memory in the debugger.

Learn how to define numeric constants with equ, use symbolic names like buffer size for 500, verify values in a debugger, and understand redefinition with equiv for safer, scalable code.

Arm 64-bit load and store architecture, transferring data between memory and registers using various addressing modes and signed and unsigned loads of byte, halfword, word, and quad data.

Learn how to use the ARM 64-bit store instruction to copy data into memory. Identify destination addresses in registers and verify results with memory inspection.

Explore logical shift left in ARM 64-bit assembly, noting how bits shift, zeros fill the low bits, and high bits discard, with immediate or register shift amounts.

Learn shift right instructions in ARM64, including logical and arithmetic shifts, how they discard the bits, fill the high bits, and relate to multiplying or dividing by powers of two.

Arm 64-bit assembly language with Raspberry Pi teaches rotate right and rotate left, highlighting wraparound behavior and how to emulate rotate left using rotate right with registers or immediates.

Learn how to move data between registers and load 64-bit values with move, move with zero, and move with keep. Understand 16-bit immediate limits, and 16/32/48 shift positions.

Learn how the ARM 64-bit negate instruction reverses a value’s sign, with examples using registers and optional shifts, including zero behavior and immediate operands.

Explore add and subtract instructions in arm 64-bit assembly, using two sources and a destination, with immediate or register operands, including shifts and sign-extension for correct results.

Load variables into registers, negate A, add to B, compute (C minus D) times 2, then subtract to store the final value in value.

Explore the pstate flags in ARM 64-bit assembly, including overflow, carry, zero, and negative flags, and learn how arithmetic and logical operations set and affect these conditional status flags.

Learn how the carry flag signals unsigned overflow in ARM 64-bit adds and subtracts, using the s suffix to update it, and verify results in the debugger.

This lecture explains the overflow flag that signals signed overflow beyond the 64-bit range (-2^63 to 2^63-1) and demonstrates add, subtract, left shift, and negate examples.

Learn how the zero flag signals a zero result in ARM 64-bit operations, as subtracting 5 from x0 sets it and adding 10 to x2 clears it.

Explore the negative flag in arm 64-bit assembly, learning how signed operations set or clear the flag based on positive, negative, or zero results, with practical examples.

Apply the and instruction to perform bitwise operations in ARM 64-bit assembly using binary values and registers, and analyze sample bit pairs to see when the result equals one.

Explore the orr instruction, a bitwise or between two registers, with the format or, dest, src1, operand2, and the result is 0 only if both bits are 0.

Demonstrate and or instructions to mask and modify bits in registers, clearing bit 2 and 7 and setting bit 2 and 6 with debugger steps.

Learn how the bit clear instruction in ARM assembly clears bits where operand2 is 1, and see examples clearing bits 2 and 7 as well as 4 and 5.

Learn the eor instruction and xor operation on bits, using syntax eor destination, source1, operand2, and see how xor with 0 leaves values unchanged while xor with 1 inverts bits.

Explore the not instruction in arm 64-bit assembly, inverting every bit in a 64-bit register and using move with not and left-shifted immediates to produce the maximum signed value.