Lab - 1: Exploring 6502 Assembly

Exploring 6502 Assembly: A Journey into Low-Level Programming 

Introduction

Assembly language has always been both fascinating and challenging for programmers. Unlike high-level languages where abstractions make coding easier, assembly requires a deep understanding of how the CPU processes instructions. In this lab, we explore the basics of 6502 Assembly Language through bitmap displays, code modifications, performance enhancements, and using the 6502 Emulator. This experience is the first step towards learning more complex architectures such as x86_64 and AArch64.

Setting Up the 6502 Emulator

The first step in this lab was setting up the 6502 Emulator, which is available at http://6502.cdot.systems. Since the emulator does not save progress automatically, I followed the recommended practice of periodically saving my work. Using Git for version control proved to be an efficient way to manage my code changes and experiments.

Understanding the Bitmap Code

]The provided bitmap code fills the emulator’s display with a solid yellow color. Here’s the breakdown of how it works:

This loop iterates through the display memory, coloring each pixel yellow.

Performance Analysis

Execution Time Calculation

Given a 1 MHz clock speed, I calculated how long it takes for the program to execute:

  • The main loop executes 256 times per page.

  • Since there are six pages to fill, the loop runs 256 × 6 = 1536 times.

  • Each iteration consists of five key instructions (STA, INY, BNE, INC, LDX, and CPX), each with different cycle counts.

  • Summing up the cycles for each iteration and multiplying by 1536 gives the total execution time.

After careful calculations, the execution time was determined to be ~24.576 milliseconds.


Overall, the execution time calculation

  • Clock Speed: 1 MHz
  • Cycle Time: 0.000001 seconds (1 µs)
  • Execution Time: 24,408 cycles × 0.000001 s = 24.408 ms

Memory Usage Calculation

The memory footprint of the software consists of:
  • Program instructions (a few dozen bytes)
  • Pointer variables ($40 and $41)
  • Screen memory of 1.5 KB ($0200 to $0600)
The application works well even on older 8-bit platforms due to its minimal memory footprint.

 Optimizing Performance

I modified the loop to reduce unnecessary instructions and increase memory access to speed up performance. The optimized version runs almost twice as fast by using unrolled loops and STX/Y addressing for better pixel filling. The revised code is as follows:


This reduces instruction cycles and speeds up execution significantly.


We’ve taken our first steps into the fascinating world of 6502 assemblies, unravelling its core concepts and writing our very first program. But this is just the beginning! In the next post, we’ll dive deeper, modify our code, and experiment with new instructions to truly understand the power of low-level programming. Stay tuned—things are about to get even more exciting!

Comments

Post a Comment

Popular posts from this blog

Project Stage 3: Enhancing GCC Pass for Multiple Function Clone Handling: Progress Update

In my earlier work, I developed a basic GCC pass for identifying and comparing function clones. For this latest phase, I focused on improving the pass to handle programs containing multiple cloned functions. Additionally, I wanted to enhance code organization by consolidating data storage, replacing multiple parallel vectors and maps with a structured approach using a dedicated struct to store characteristics of clone variants. Implementation Process Phase 1: Code Revision for Multi-Function Support I modified the pass to properly handle programs with multiple cloned functions in x86 server environments. The updated code includes all critical support files. The revised implementation's core is a specialized pass that processes GIMPLE representation data. This pass systematically identifies resolver functions and creates appropriate tracking structures for each function being cloned. The implementation uses maps and vectors to store function characteristics, including basic block co...
Read more

Project Stage 1: Troubleshooting a bit - Coming soon

  Procedure for Troubleshooting Debugging using the following method: First Error Analysis: I carefully reviewed the error logs after my initial build attempt failed. Copy ./pass-instances.def:47:23: error: expected ';' at end of member declaration 47 | NEXT_PASS_WITH_ARG (pass_mypass, 1, 1) This suggested an issue with my pass registration syntax. Examining Pass Declaration Conventions: I ran the following to examine the passes that were already included in the GCC source code: Copy cd ~/git/gcc/gcc grep -r "NEXT_PASS" passes.def This showed that NEXT_PASS (pass_name, number) was the proper format instead of NEXT_PASS_WITH_ARG. Function name Pattern Analysis: I looked at various pass implementations to learn more about the name conventions: Copy cd ~/git/gcc/gcc find . -name "tree-*.cc" | xargs grep "make_pass_" This demonstrated to me that the pattern make_pass_X, where X is the pass name without the "pass_" prefix, is what GCC ...
Read more