Agent Work: Linking (readjcf)

Claude Opus 4.6 · COMP 321: Introduction to Computer Systems

COMP 321: Introduction to Computer Systems

Assignment 3: Linking

Overview

You will complete the implementation of the readjcf program, which reads the linkage information from a Java Class File (JCF). The goals of this assignment are as follows:

Improve your understanding of the x86-64 linking process.
Gain familiarity with objdump and readelf.
Gain an understanding of the similarities and differences between x86-64 ELF files and Java virtual machine class files.
Improve your understanding of data representation and I/O in C.

Programming Problem: readjcf

The compilation and execution of Java programs has both similarities and differences with respect to C programs. First, the javac compiler does not output x86-64 ELF files. It outputs files that are instead in the Java Class File (JCF) format. Second, the machine code within these files is not x86-64 machine code. It is machine code for a hypothetical computer called the Java Virtual Machine (JVM). Essentially, this machine code is executed by a very fast JVM simulator. Nonetheless, there are many conceptual similarities between the JCF and ELF file formats. In other words, to link together a Java program consisting of many classes, the JCF format must support many of the same features as the ELF file format. We learn about these similarities and differences through the implementation of the readjcf program.

First, we will explain the entire JCF format, then we will give a specification of the readjcf program that you will write. Although we need to describe the entire JCF format, the constant_pool, fields, and methods arrays are of particular interest for implementing the readjcf program.

Java Class File (JCF) Format:

The Java Class File (JCF) format is defined by the following pseudo-C structure. Note that in this definition, u1, u2, and u4 refer to an unsigned one-, two-, and four-byte quantity, respectively, and that all multibyte data is stored in big-endian format:

ClassFile {
    u4 magic;
    u2 minor_version;
    u2 major_version;
    u2 constant_pool_count;
    cp_info constant_pool[constant_pool_count-1];
    u2 access_flags;
    u2 this_class;
    u2 super_class;
    u2 interfaces_count;
    u2 interfaces[interfaces_count];
    u2 fields_count;
    field_info fields[fields_count];
    u2 methods_count;
    method_info methods[methods_count];
    u2 attributes_count;
    attribute_info attributes[attributes_count];
}

This structure is pseudo-C because the constant_pool, interfaces, fields, methods, and attributes arrays are variable sized, which is not allowed in C structures.

The magic field of a valid JCF must equal 0xCAFEBABE. The minor_version and major_version fields contain version information about the class.

The constant_pool section of the JCF is most similar to a combination of the .rodata section, symbol table, and relocation information of an ELF file. The constant_pool contains all of the class' constants, including strings, numbers, references, and the names and types of classes, interfaces, fields, and methods. The constant_pool array contains one less entry than the count because the zeroth entry of the array is omitted. In other words, the first constant in the pool has index one.

The access_flags field is a bit vector that specifies access permissions for the class. The this_class and super_class fields are indices into the constant pool that reference the names of the current class and the super class. The interfaces section contains an array of indices into the constant pool for all of the interfaces that the class implements. The fields and methods arrays contain information about every single field and method in the class. Lastly, the attributes array contains specific attributes about the class.

There are fourteen different types of constants in the constant pool: CONSTANT_Class, CONSTANT_Fieldref, CONSTANT_Methodref, CONSTANT_InterfaceMethodref, CONSTANT_String, CONSTANT_Integer, CONSTANT_Float, CONSTANT_Long, CONSTANT_Double, CONSTANT_NameAndType, CONSTANT_Utf8, CONSTANT_MethodHandle, CONSTANT_MethodType, and CONSTANT_InvokeDynamic.

The cp_info structures for all of these different constants all share the same general form:

cp_info {
    u1 tag;
    u1 info[];
}

The tag field indicates which type of constant the structure represents and, subsequently, the exact size of the info array.

The CONSTANT_Class constant contains the name of a class and is represented with the following structure:

CONSTANT_Class_info {
    u1 tag;
    u2 name_index;
}

The name_index field is a valid index into the constant_pool array. The element at that index corresponds to a CONSTANT_Utf8.

The CONSTANT_Fieldref, CONSTANT_Methodref, and CONSTANT_InterfaceMethodref constants indicate references made in the class to fields, methods, and interface methods, respectively. The following structure is used to represent all of these constants:

CONSTANT_{Field, Method, InterfaceMethod}ref_info {
    u1 tag;
    u2 class_index;
    u2 name_and_type_index;
}

The class_index and name_and_type_index fields indicate the class, name, and type of the field, method, or interface method being referenced. The fields are indices into the constant pool that correspond to CONSTANT_Class and CONSTANT_NameAndType constants, respectively.

The CONSTANT_String, CONSTANT_Integer, CONSTANT_Float, CONSTANT_Long, CONSTANT_Double, CONSTANT_MethodHandle, CONSTANT_MethodType, and CONSTANT_InvokeDynamic constants have the following structure definitions:

CONSTANT_String_info {
    u1 tag;
    u2 string_index;
}

CONSTANT_{Integer, Float}_info {
    u1 tag;
    u4 bytes;
}

CONSTANT_{Long, Double}_info {
    u1 tag;
    u4 high_bytes;
    u4 low_bytes;
}

CONSTANT_MethodHandle_info {
    u1 tag;
    u1 reference_kind;
    u2 reference_index;
}

CONSTANT_MethodType_info {
    u1 tag;
    u2 descriptor_index;
}

CONSTANT_InvokeDynamic_info {
    u1 tag;
    u2 bootstrap_method_attr_info;
    u2 name_and_type_index;
}

Although you must necessarily pay attention to the sizes of the various data types in the above structures, the actual meaning of some of these structures' data members can remain opaque to you throughout the assignment. For instance, in the case of CONSTANT_InvokeDynamic, the bootstrap_method_attr_info is an index into the attributes table of the JCF. However, since you are not required to do any special processing of JCF attributes in your program, you may ignore what this actually refers to.

The JCF format specifies that the CONSTANT_Long and CONSTANT_Double constants occupy two entries in the constant pool. The specification says that, "If a CONSTANT_Long_info or CONSTANT_Double_info structure is the item in the constant_pool table at index n, then the next usable item in the pool is located at index n + 2. The constant_pool index n + 1 must be valid but is considered unusable."

The CONSTANT_NameAndType constant represents the name and type of a field or method. It is defined by the following structure:

CONSTANT_NameAndType_info {
    u1 tag;
    u2 name_index;
    u2 descriptor_index;
}

The name_index and descriptor_index fields indicate the name and description string of the field, method, or interface method being referenced. The fields are indices into the constant pool that correspond to CONSTANT_Utf8 constants.

The CONSTANT_Utf8 constant represents a UTF-8 string that is not NUL-terminated. UTF-8 is a variable-width character encoding that can represent any character in the Unicode character set, which includes over 110,000 characters from 100 scripts. UTF-8 is the most common character encoding used on the web, in part because ASCII encoding is a subset of UTF-8 character encoding. The CONSTANT_Utf8 constant is defined by the following structure:

CONSTANT_Utf8_info {
    u1 tag;
    u2 length;
    u1 bytes[length];
}

The field_info and method_info structures both have the same definition:

{field, method}_info {
    u2 access_flags;
    u2 name_index;
    u2 descriptor_index;
    u2 attributes_count;
    attribute_info attributes[attributes_count];
}

The access_flags field is a bit vector that specifies access information about the field or method, including whether the method is public, protected, or private. The only flag that is necessary for this assignment is the ACC_PUBLIC flag. The name_index and descriptor_index are indices into the constant pool to a CONSTANT_Utf8 that contains the name and description string of the field or method, respectively. Finally, the structure contains an array of attributes.

The attribute_info structure is defined by the following pseudo-C structure:

attribute_info {
    u2 attribute_name_index;
    u4 attribute_length;
    u1 info[attribute_length];
}

There are many more specific types of attributes defined by the Java Class File format, but they all follow the format of the previous structure. For this assignment, we will be ignoring all attribute information, so we do not need to delve into the specific types of attributes.

readjcf Specification:

The readjcf program will read a single Java Class File and print out the class' dependencies and exports, as requested by flags. Additionally, the program will perform some basic verification of the JCF. The program accepts three command line flags: "-d", "-e", and "-v". The flags "-d" and "-e" indicate whether or not the program should print the class file's dependencies and exports, respectively. The flag "-v" enables extra print statements for debugging. If no flags are specified, then no dependencies or exports should be printed, but the class file should still be read and verified.

We provide a main routine that reads and parses the command line arguments appropriately. The usage of the program is as follows:

readjcf [-d] [-e] [-v] <input file>

We will not use the -v flag when testing your program. Moreover, we are not specifying what the output from the extra print statements should be. That is up to you.

For the purposes of the readjcf program, we define a dependency as any reference made in the class, including self-references. These references are made by the CONSTANT_Fieldref, CONSTANT_Methodref, and CONSTANT_InterfaceMethodref constants in the constant pool. We define an export as any field or method in the class that has the access flag ACC_PUBLIC set.

The dependencies and exports should be printed in the order that they are encountered in the JCF. Due to the format of the JCF, this means that all of the dependencies will be printed before the exports.

The output format for printing the dependencies and exports in the class file is exactly as follows:

Dependency - <class name>.<name> <descriptor>
Export - <name> <descriptor>

For a concrete example, the following is output from the reference solution:

Dependency - java/lang/Object.equals (Ljava/lang/Object;)Z
Dependency - java/lang/Object.hashCode ()I
Export - <init> (D)V
Export - toString ()Ljava/lang/String;
Export - equals (Ljava/lang/Object;)Z
Export - hashCode ()I

The program must also perform a simple form of verification of the JCF. Your readjcf program must verify the following:

The magic number is 0xCAFEBABE.
The class file is not truncated and does not contain extra bytes.
All indices into the constant pool that are followed while printing the dependencies and exports are valid and the constant at that index is of the expected type (according to its tag).

The verification should be performed as the file is processed. If at any time the file fails verification, the program should use the readjcf_error function to print an error message to stderr, then immediately quit.

We are providing you with a partially implemented program for reading these files. The provided program includes a main function that opens the input file and calls the rest of the processing functions in the correct order for the JCF format. You need to implement the following functions:

static int      print_jcf_constant(struct jcf_state *jcf,
                    uint16_t index, uint8_t expected_tag);
static int      process_jcf_header(struct jcf_state *jcf);
static int      process_jcf_constant_pool(struct jcf_state *jcf);
static void     destroy_jcf_constant_pool(struct jcf_constant_pool *pool);
static int      process_jcf_body(struct jcf_state *jcf);
static int      process_jcf_interfaces(struct jcf_state *jcf);
static int      process_jcf_attributes(struct jcf_state *jcf);

The print_jcf_constant function prints a constant from the constant pool to stdout. process_jcf_header reads the header (the magic, minor_version, and major_version fields) from the JCF. process_jcf_constant_pool reads and stores the constant pool, then prints out all of the class' dependencies, if requested. destroy_jcf_constant_pool deallocates all of the memory allocated to store the constant pool by process_jcf_constant_pool. process_jcf_body reads the body (the access_flags, this_class, and super_class fields) from the JCF. process_jcf_interfaces reads the interfaces count and the array of interfaces. process_jcf_attributes reads an attributes count, followed by an array of attributes.

Notes

All of the multibyte data in the JCF is stored in big-endian format, which means that the data must be byteswapped before it may be accessed. To byteswap 16-bit and 32-bit integers use the functions ntohs and ntohl, respectively.

The jcf_cp_utf8_info structure contains an array bytes of unspecified length as the last field of the structure. The compiler and the sizeof() operator do not include space for this array in the representation of the structure because it has an unknown number of elements. This causes the bytes field to occupy the bytes immediately after the structure. Thus, if you only allocate sizeof(struct jcf_cp_utf8_info) bytes, then the bytes field will occupy memory that is either not allocated or allocated for a different data object. In either case, this is problematic. If you instead allocate (sizeof(struct jcf_cp_utf8_info) + numbytes) bytes, you will have allocated memory for the bytes array. Specifically, the bytes array will be an array that is numbytes long.

The UTF-8 strings in the constant pool are not NUL-terminated. The standard I/O library functions will work properly on NUL-terminated UTF-8 strings. You will need to NUL-terminate the strings yourself.

The UTF-8 strings in the constant pool can be zero bytes long. The fread function will always return 0, an indication of error, when it is asked to read an element whose size equals 0.

The JCF_CONSTANT_Long and JCF_CONSTANT_Double constants contain 8 bytes worth of data after the tag and occupy two spots in the constant pool. This means that, for example, you encounter one of these constants at index 1, then the next constant is located at index 3.

The access_flags fields are bit vectors. Specific flags may be tested for by performing the boolean and of the field and the mask. For example, access_flags & ACC_PUBLIC will be true iff the ACC_PUBLIC flag is set.

We provide you with the implementation of process_jcf_fields and process_jcf_methods. These functions provide a good example as to how to implement the rest of the program.

The fread function can read structures from a file. This is the preferred way to read data in your program.

Files

Your workspace contains the following structure:

skeleton_code/
  7.6/              # Files for textbook problems (optional)
  7.9/              # Files for textbook problems (optional)
  readjcf/          # Main project directory
    readjcf.c       # Implement your solution here
    Makefile        # Build specification
  writeup.md        # Skeleton writeup file

The 7.6 and 7.9 directories contain files you may use if you want to explore the textbook problems, but the main implementation task is in the readjcf directory.

A reference solution readjcf_ref may be provided. Run this program to resolve any questions you have about how your program should behave. *Your program should emit output that is byte-for-byte identical to the reference solution for any combination of the flags "-d" and "-e".* You are not responsible for matching the exact output of the reference solution with the flag "-v". That said, attempting to match the output of the reference solution with the flag "-v" is a good way to develop and test your program in small steps.

Building Your Program

To build the program:

cd readjcf
make

This will compile your code and produce the readjcf executable.

Testing

Use the grade tool to run the automated test suite:

# From the workspace directory
bin/grade .

# Or specify the workspace path
bin/grade ./workspaces/agent_linking

The grade tool will compile your code and run all tests, showing which pass and fail. Focus on getting all tests to pass.

--- *COMP 321: Introduction to Computer Systems, Rice University, Spring 2024*

readjcf.c7.6 KB

/*
 * COMP 321 Project 3: Linking
 * 
 * This program reads a single Java Class File and prints out its
 * dependencies and exports, as requested by command-line flags.
 * 
 * <Put your name(s) and NetID(s) here>
 */

#include <netinet/in.h>

#include <assert.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#include "csapp.h"

// Define the magic number that must be the first four bytes of a valid JCF.
#define JCF_MAGIC	0xCAFEBABE

/* 
 * Define the header of the Java class file.
 * The __attribute__((packed)) after the structure definition tells the
 * compiler to not add any padding to the structure for alignment.  This
 * allows this structure to be read directly from a packed file.
 */
struct jcf_header {
	uint32_t	magic;
	uint16_t	minor_version;
	uint16_t	major_version;
} __attribute__((packed));

// Define the body of the Java class file.
struct jcf_body {
	uint16_t	access_flags;
	uint16_t	this_class;
	uint16_t	super_class;
} __attribute__((packed));

// Define an enumeration of the constant tags.
enum jcf_cp_tags {
	JCF_CONSTANT_Class = 7,
	JCF_CONSTANT_Fieldref = 9,
	JCF_CONSTANT_Methodref = 10,
	JCF_CONSTANT_InterfaceMethodref = 11,
	JCF_CONSTANT_String = 8,
	JCF_CONSTANT_Integer = 3,
	JCF_CONSTANT_Float = 4,
	JCF_CONSTANT_Long = 5,
	JCF_CONSTANT_Double = 6,
	JCF_CONSTANT_NameAndType = 12,
	JCF_CONSTANT_Utf8 = 1,
	JCF_CONSTANT_MethodHandle = 15,
	JCF_CONSTANT_MethodType = 16,
	JCF_CONSTANT_InvokeDynamic = 18
};

// Define an enumeration of the access flags.
enum jcf_access_flags {
	JCF_ACC_PUBLIC = 0x0001,
	JCF_ACC_PRIVATE = 0x0002,
	JCF_ACC_PROTECTED = 0x0004,
	JCF_ACC_STATIC = 0x0008,
	JCF_ACC_FINAL = 0x0010,
	JCF_ACC_SYNCHRONIZED = 0x0020,
	JCF_ACC_VOLATILE = 0x0040,
	JCF_ACC_TRANSIENT = 0x0080,
	JCF_ACC_NATIVE = 0x0100,
	JCF_ACC_INTERFACE = 0x0200,
	JCF_ACC_ABSTRACT = 0x0400,
	JCF_ACC_STRICT = 0x0800
};

/*
 * Define the generic constant pool info structure.
 * This structure should be thought of as an abstract class that never
 * should be allocated directly. 
 *
 * The zero length array "info" in this structure is a special design
 * pattern in C that allows for variable length structures.  This is
 * done by casting another structure to this general type or by
 * allocating (sizeof(struct foo) + array_len) bytes.  This causes
 * memory to be allocated for the array, which can then be accessed
 * normally.
 */
struct jcf_cp_info {
	uint8_t		tag;
	uint8_t		info[0];
} __attribute__((packed));

/* 
 * Define the generic constant pool info structure for all constants
 * that have a single u2.
 */
struct jcf_cp_info_1u2 {
	uint8_t		tag;
	uint16_t	u2;
} __attribute__((packed));

/* 
 * Define the generic constant pool info structure for all constants
 * that have two u2s.
 */
struct jcf_cp_info_2u2 {
	uint8_t		tag;
	struct {
		uint16_t	u2_1;
		uint16_t	u2_2;
	} __attribute__((packed)) body;
} __attribute__((packed));

/* 
 * Define the generic constant pool info structure for all constants
 * that have one u1 and one u2.
 */
struct jcf_cp_info_1u1_1u2 {
	uint8_t		tag;
	struct {
		uint8_t		u1;
		uint16_t	u2;
	} __attribute__((packed)) body;
} __attribute__((packed));

/* 
 * Define the generic constant pool info structure for all constants
 * that have a single u4.
 */
struct jcf_cp_info_1u4 {
	uint8_t		tag;
	uint32_t	u4;
} __attribute__((packed));

// Define the constant pool info for classes.
struct jcf_cp_class_info {
	uint8_t		tag;
	uint16_t	name_index;
} __attribute__((packed));

/*
 * Define the constant pool info for all reference constants.
 * These are any of the following constants: JCF_CONSTANT_Fieldref,
 * JCF_CONSTANT_Methodref, and JCF_CONSTANT_InterfaceMethodref.
 */
struct jcf_cp_ref_info {
	uint8_t		tag;
	uint16_t	class_index;
	uint16_t	name_and_type_index;
} __attribute__((packed));

// Define the constant pool info for name and type tuples.
struct jcf_cp_nameandtype_info {
	uint8_t		tag;
	uint16_t	name_index;
	uint16_t	descriptor_index;
} __attribute__((packed));

/*
 * Define the constant pool info for UTF8 strings.
 * 
 * This structure should be created by allocating
 * (sizeof(struct jcf_cp_utf8_info) + array_len) bytes.
 */
struct jcf_cp_utf8_info {
	uint8_t		tag;
	uint16_t	length;
	uint8_t		bytes[0];
} __attribute__((packed));

// Define a field info entry for the class.
struct jcf_field_info {
	uint16_t	access_flags;
	uint16_t	name_index;
	uint16_t	descriptor_index;
} __attribute__((packed));

// Define a method info entry for the class.
struct jcf_method_info {
	uint16_t	access_flags;
	uint16_t	name_index;
	uint16_t	descriptor_index;
} __attribute__((packed));

// Define a structure for holding the constant pool.
struct jcf_constant_pool {
	uint16_t	count;
	struct jcf_cp_info **pool;
};

// Define a structure for holding processing state.
struct jcf_state {
	FILE		*f;
	bool		depends_flag;
	bool		exports_flag;
	bool		verbose_flag;
	struct jcf_constant_pool constant_pool;
};

// Declare the local function prototypes.
static void	readjcf_error(void);
static int	print_jcf_constant(struct jcf_state *jcf,
		    uint16_t index, uint8_t expected_tag);
static int	process_jcf_header(struct jcf_state *jcf);
static int	process_jcf_constant_pool(struct jcf_state *jcf);
static void	destroy_jcf_constant_pool(struct jcf_constant_pool *pool);
static int	process_jcf_body(struct jcf_state *jcf);
static int	process_jcf_interfaces(struct jcf_state *jcf);
static int	process_jcf_fields(struct jcf_state *jcf);
static int	process_jcf_methods(struct jcf_state *jcf);
static int	process_jcf_fields_and_methods_helper(struct jcf_state *jcf);
static int	process_jcf_attributes(struct jcf_state *jcf);

/*
 * Requires:
 *   Nothing.
 *
 * Effects:
 *   Prints a formatted error message to stderr.
 */
static void
readjcf_error(void)
{

	fprintf(stderr, "ERROR: Unable to process file!\n");
}

/*
 * Requires:
 *   The constant pool must be initialized.
 *
 * Effects:
 *   If the index is valid and points to a constant of the expected type,
 *   this function will print the constant and return 0.  Otherwise, -1
 *   is returned.
 */
static int
print_jcf_constant(struct jcf_state *jcf, uint16_t index,
    uint8_t expected_tag)
{
	struct jcf_cp_info *info;

	assert(jcf != NULL);

	// Prevent an "uninitialized variable" warning.  REMOVE THIS STATEMENT!
	info = NULL;

	// Prevent "unused parameter" warnings.  REMOVE THESE STATEMENTS!
	(void)index;
	(void)expected_tag;

	// Verify the index.

	// Verify the tag.

	// Print the constant.
	switch (info->tag) {
	case JCF_CONSTANT_Class:
		// Print the class.
		break;
	case JCF_CONSTANT_Fieldref:
	case JCF_CONSTANT_Methodref:
	case JCF_CONSTANT_InterfaceMethodref:
		/* 
		 * Print the reference, with the Class and NameAndType
		 * separated by a '.'.
		 */
		break;
	case JCF_CONSTANT_NameAndType:
		// Print the name and type.
		break;
	case JCF_CONSTANT_Utf8:
		// Print the UTF8.
		break;
	default:
		// Ignore all other constants.
		break;
	}

	return (0);
}

/*
 * Requires:
 *   The "jcf" argument must be a valid struct jcf_state.  "jcf.f" must
 *   be a valid open file.
 *
 * Effects:
 *   Reads and verifies the Java class file header from file "jcf.f".
 *   Returns 0 on success and -1 on failure.
 */
static int
process_jcf_header(struct jcf_state *jcf)
{

	assert(jcf != NULL);

	// Read the header.

	// Verify the magic number.

	return (0);
}

/*
 * Requires:
 *   The "jcf" argument must be a valid struct jcf_state.  "jcf.f" must
 *   be a valid open file.  The JCF header must have already been read.
 *
 * Effects:
 *   Reads and stores the constant pool from the JCF.  Prints the
 *   dependencies if requested.  Returns 0 on success and -1 on failure.
 *   This function allocates memory that must be destroyed later, even if
 
... (truncated 11561 chars)

readjcf.c7.6 KB

/*
 * COMP 321 Project 3: Linking
 * 
 * This program reads a single Java Class File and prints out its
 * dependencies and exports, as requested by command-line flags.
 * 
 * <Put your name(s) and NetID(s) here>
 */

#include <netinet/in.h>

#include <assert.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#include "csapp.h"

// Define the magic number that must be the first four bytes of a valid JCF.
#define JCF_MAGIC	0xCAFEBABE

/* 
 * Define the header of the Java class file.
 * The __attribute__((packed)) after the structure definition tells the
 * compiler to not add any padding to the structure for alignment.  This
 * allows this structure to be read directly from a packed file.
 */
struct jcf_header {
	uint32_t	magic;
	uint16_t	minor_version;
	uint16_t	major_version;
} __attribute__((packed));

// Define the body of the Java class file.
struct jcf_body {
	uint16_t	access_flags;
	uint16_t	this_class;
	uint16_t	super_class;
} __attribute__((packed));

// Define an enumeration of the constant tags.
enum jcf_cp_tags {
	JCF_CONSTANT_Class = 7,
	JCF_CONSTANT_Fieldref = 9,
	JCF_CONSTANT_Methodref = 10,
	JCF_CONSTANT_InterfaceMethodref = 11,
	JCF_CONSTANT_String = 8,
	JCF_CONSTANT_Integer = 3,
	JCF_CONSTANT_Float = 4,
	JCF_CONSTANT_Long = 5,
	JCF_CONSTANT_Double = 6,
	JCF_CONSTANT_NameAndType = 12,
	JCF_CONSTANT_Utf8 = 1,
	JCF_CONSTANT_MethodHandle = 15,
	JCF_CONSTANT_MethodType = 16,
	JCF_CONSTANT_InvokeDynamic = 18
};

// Define an enumeration of the access flags.
enum jcf_access_flags {
	JCF_ACC_PUBLIC = 0x0001,
	JCF_ACC_PRIVATE = 0x0002,
	JCF_ACC_PROTECTED = 0x0004,
	JCF_ACC_STATIC = 0x0008,
	JCF_ACC_FINAL = 0x0010,
	JCF_ACC_SYNCHRONIZED = 0x0020,
	JCF_ACC_VOLATILE = 0x0040,
	JCF_ACC_TRANSIENT = 0x0080,
	JCF_ACC_NATIVE = 0x0100,
	JCF_ACC_INTERFACE = 0x0200,
	JCF_ACC_ABSTRACT = 0x0400,
	JCF_ACC_STRICT = 0x0800
};

/*
 * Define the generic constant pool info structure.
 * This structure should be thought of as an abstract class that never
 * should be allocated directly. 
 *
 * The zero length array "info" in this structure is a special design
 * pattern in C that allows for variable length structures.  This is
 * done by casting another structure to this general type or by
 * allocating (sizeof(struct foo) + array_len) bytes.  This causes
 * memory to be allocated for the array, which can then be accessed
 * normally.
 */
struct jcf_cp_info {
	uint8_t		tag;
	uint8_t		info[0];
} __attribute__((packed));

/* 
 * Define the generic constant pool info structure for all constants
 * that have a single u2.
 */
struct jcf_cp_info_1u2 {
	uint8_t		tag;
	uint16_t	u2;
} __attribute__((packed));

/* 
 * Define the generic constant pool info structure for all constants
 * that have two u2s.
 */
struct jcf_cp_info_2u2 {
	uint8_t		tag;
	struct {
		uint16_t	u2_1;
		uint16_t	u2_2;
	} __attribute__((packed)) body;
} __attribute__((packed));

/* 
 * Define the generic constant pool info structure for all constants
 * that have one u1 and one u2.
 */
struct jcf_cp_info_1u1_1u2 {
	uint8_t		tag;
	struct {
		uint8_t		u1;
		uint16_t	u2;
	} __attribute__((packed)) body;
} __attribute__((packed));

/* 
 * Define the generic constant pool info structure for all constants
 * that have a single u4.
 */
struct jcf_cp_info_1u4 {
	uint8_t		tag;
	uint32_t	u4;
} __attribute__((packed));

// Define the constant pool info for classes.
struct jcf_cp_class_info {
	uint8_t		tag;
	uint16_t	name_index;
} __attribute__((packed));

/*
 * Define the constant pool info for all reference constants.
 * These are any of the following constants: JCF_CONSTANT_Fieldref,
 * JCF_CONSTANT_Methodref, and JCF_CONSTANT_InterfaceMethodref.
 */
struct jcf_cp_ref_info {
	uint8_t		tag;
	uint16_t	class_index;
	uint16_t	name_and_type_index;
} __attribute__((packed));

// Define the constant pool info for name and type tuples.
struct jcf_cp_nameandtype_info {
	uint8_t		tag;
	uint16_t	name_index;
	uint16_t	descriptor_index;
} __attribute__((packed));

/*
 * Define the constant pool info for UTF8 strings.
 * 
 * This structure should be created by allocating
 * (sizeof(struct jcf_cp_utf8_info) + array_len) bytes.
 */
struct jcf_cp_utf8_info {
	uint8_t		tag;
	uint16_t	length;
	uint8_t		bytes[0];
} __attribute__((packed));

// Define a field info entry for the class.
struct jcf_field_info {
	uint16_t	access_flags;
	uint16_t	name_index;
	uint16_t	descriptor_index;
} __attribute__((packed));

// Define a method info entry for the class.
struct jcf_method_info {
	uint16_t	access_flags;
	uint16_t	name_index;
	uint16_t	descriptor_index;
} __attribute__((packed));

// Define a structure for holding the constant pool.
struct jcf_constant_pool {
	uint16_t	count;
	struct jcf_cp_info **pool;
};

// Define a structure for holding processing state.
struct jcf_state {
	FILE		*f;
	bool		depends_flag;
	bool		exports_flag;
	bool		verbose_flag;
	struct jcf_constant_pool constant_pool;
};

// Declare the local function prototypes.
static void	readjcf_error(void);
static int	print_jcf_constant(struct jcf_state *jcf,
		    uint16_t index, uint8_t expected_tag);
static int	process_jcf_header(struct jcf_state *jcf);
static int	process_jcf_constant_pool(struct jcf_state *jcf);
static void	destroy_jcf_constant_pool(struct jcf_constant_pool *pool);
static int	process_jcf_body(struct jcf_state *jcf);
static int	process_jcf_interfaces(struct jcf_state *jcf);
static int	process_jcf_fields(struct jcf_state *jcf);
static int	process_jcf_methods(struct jcf_state *jcf);
static int	process_jcf_fields_and_methods_helper(struct jcf_state *jcf);
static int	process_jcf_attributes(struct jcf_state *jcf);

/*
 * Requires:
 *   Nothing.
 *
 * Effects:
 *   Prints a formatted error message to stderr.
 */
static void
readjcf_error(void)
{

	fprintf(stderr, "ERROR: Unable to process file!\n");
}

/*
 * Requires:
 *   The constant pool must be initialized.
 *
 * Effects:
 *   If the index is valid and points to a constant of the expected type,
 *   this function will print the constant and return 0.  Otherwise, -1
 *   is returned.
 */
static int
print_jcf_constant(struct jcf_state *jcf, uint16_t index,
    uint8_t expected_tag)
{
	struct jcf_cp_info *info;

	assert(jcf != NULL);

	// Prevent an "uninitialized variable" warning.  REMOVE THIS STATEMENT!
	info = NULL;

	// Prevent "unused parameter" warnings.  REMOVE THESE STATEMENTS!
	(void)index;
	(void)expected_tag;

	// Verify the index.

	// Verify the tag.

	// Print the constant.
	switch (info->tag) {
	case JCF_CONSTANT_Class:
		// Print the class.
		break;
	case JCF_CONSTANT_Fieldref:
	case JCF_CONSTANT_Methodref:
	case JCF_CONSTANT_InterfaceMethodref:
		/* 
		 * Print the reference, with the Class and NameAndType
		 * separated by a '.'.
		 */
		break;
	case JCF_CONSTANT_NameAndType:
		// Print the name and type.
		break;
	case JCF_CONSTANT_Utf8:
		// Print the UTF8.
		break;
	default:
		// Ignore all other constants.
		break;
	}

	return (0);
}

/*
 * Requires:
 *   The "jcf" argument must be a valid struct jcf_state.  "jcf.f" must
 *   be a valid open file.
 *
 * Effects:
 *   Reads and verifies the Java class file header from file "jcf.f".
 *   Returns 0 on success and -1 on failure.
 */
static int
process_jcf_header(struct jcf_state *jcf)
{

	assert(jcf != NULL);

	// Read the header.

	// Verify the magic number.

	return (0);
}

/*
 * Requires:
 *   The "jcf" argument must be a valid struct jcf_state.  "jcf.f" must
 *   be a valid open file.  The JCF header must have already been read.
 *
 * Effects:
 *   Reads and stores the constant pool from the JCF.  Prints the
 *   dependencies if requested.  Returns 0 on success and -1 on failure.
 *   This function allocates memory that must be destroyed later, even if
 
... (truncated 11561 chars)

readjcf.c20.9 KB

/*
 * COMP 321 Project 3: Linking
 * 
 * This program reads a single Java Class File and prints out its
 * dependencies and exports, as requested by command-line flags.
 * 
 * <Put your name(s) and NetID(s) here>
 */

#include <netinet/in.h>

#include <assert.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#include "csapp.h"

// Define the magic number that must be the first four bytes of a valid JCF.
#define JCF_MAGIC	0xCAFEBABE

/* 
 * Define the header of the Java class file.
 * The __attribute__((packed)) after the structure definition tells the
 * compiler to not add any padding to the structure for alignment.  This
 * allows this structure to be read directly from a packed file.
 */
struct jcf_header {
	uint32_t	magic;
	uint16_t	minor_version;
	uint16_t	major_version;
} __attribute__((packed));

// Define the body of the Java class file.
struct jcf_body {
	uint16_t	access_flags;
	uint16_t	this_class;
	uint16_t	super_class;
} __attribute__((packed));

// Define an enumeration of the constant tags.
enum jcf_cp_tags {
	JCF_CONSTANT_Class = 7,
	JCF_CONSTANT_Fieldref = 9,
	JCF_CONSTANT_Methodref = 10,
	JCF_CONSTANT_InterfaceMethodref = 11,
	JCF_CONSTANT_String = 8,
	JCF_CONSTANT_Integer = 3,
	JCF_CONSTANT_Float = 4,
	JCF_CONSTANT_Long = 5,
	JCF_CONSTANT_Double = 6,
	JCF_CONSTANT_NameAndType = 12,
	JCF_CONSTANT_Utf8 = 1,
	JCF_CONSTANT_MethodHandle = 15,
	JCF_CONSTANT_MethodType = 16,
	JCF_CONSTANT_InvokeDynamic = 18
};

// Define an enumeration of the access flags.
enum jcf_access_flags {
	JCF_ACC_PUBLIC = 0x0001,
	JCF_ACC_PRIVATE = 0x0002,
	JCF_ACC_PROTECTED = 0x0004,
	JCF_ACC_STATIC = 0x0008,
	JCF_ACC_FINAL = 0x0010,
	JCF_ACC_SYNCHRONIZED = 0x0020,
	JCF_ACC_VOLATILE = 0x0040,
	JCF_ACC_TRANSIENT = 0x0080,
	JCF_ACC_NATIVE = 0x0100,
	JCF_ACC_INTERFACE = 0x0200,
	JCF_ACC_ABSTRACT = 0x0400,
	JCF_ACC_STRICT = 0x0800
};

/*
 * Define the generic constant pool info structure.
 * This structure should be thought of as an abstract class that never
 * should be allocated directly. 
 *
 * The zero length array "info" in this structure is a special design
 * pattern in C that allows for variable length structures.  This is
 * done by casting another structure to this general type or by
 * allocating (sizeof(struct foo) + array_len) bytes.  This causes
 * memory to be allocated for the array, which can then be accessed
 * normally.
 */
struct jcf_cp_info {
	uint8_t		tag;
	uint8_t		info[0];
} __attribute__((packed));

/* 
 * Define the generic constant pool info structure for all constants
 * that have a single u2.
 */
struct jcf_cp_info_1u2 {
	uint8_t		tag;
	uint16_t	u2;
} __attribute__((packed));

/* 
 * Define the generic constant pool info structure for all constants
 * that have two u2s.
 */
struct jcf_cp_info_2u2 {
	uint8_t		tag;
	struct {
		uint16_t	u2_1;
		uint16_t	u2_2;
	} __attribute__((packed)) body;
} __attribute__((packed));

/* 
 * Define the generic constant pool info structure for all constants
 * that have one u1 and one u2.
 */
struct jcf_cp_info_1u1_1u2 {
	uint8_t		tag;
	struct {
		uint8_t		u1;
		uint16_t	u2;
	} __attribute__((packed)) body;
} __attribute__((packed));

/* 
 * Define the generic constant pool info structure for all constants
 * that have a single u4.
 */
struct jcf_cp_info_1u4 {
	uint8_t		tag;
	uint32_t	u4;
} __attribute__((packed));

// Define the constant pool info for classes.
struct jcf_cp_class_info {
	uint8_t		tag;
	uint16_t	name_index;
} __attribute__((packed));

/*
 * Define the constant pool info for all reference constants.
 * These are any of the following constants: JCF_CONSTANT_Fieldref,
 * JCF_CONSTANT_Methodref, and JCF_CONSTANT_InterfaceMethodref.
 */
struct jcf_cp_ref_info {
	uint8_t		tag;
	uint16_t	class_index;
	uint16_t	name_and_type_index;
} __attribute__((packed));

// Define the constant pool info for name and type tuples.
struct jcf_cp_nameandtype_info {
	uint8_t		tag;
	uint16_t	name_index;
	uint16_t	descriptor_index;
} __attribute__((packed));

/*
 * Define the constant pool info for UTF8 strings.
 * 
 * This structure should be created by allocating
 * (sizeof(struct jcf_cp_utf8_info) + array_len) bytes.
 */
struct jcf_cp_utf8_info {
	uint8_t		tag;
	uint16_t	length;
	uint8_t		bytes[0];
} __attribute__((packed));

// Define a field info entry for the class.
struct jcf_field_info {
	uint16_t	access_flags;
	uint16_t	name_index;
	uint16_t	descriptor_index;
} __attribute__((packed));

// Define a method info entry for the class.
struct jcf_method_info {
	uint16_t	access_flags;
	uint16_t	name_index;
	uint16_t	descriptor_index;
} __attribute__((packed));

// Define a structure for holding the constant pool.
struct jcf_constant_pool {
	uint16_t	count;
	struct jcf_cp_info **pool;
};

// Define a structure for holding processing state.
struct jcf_state {
	FILE		*f;
	bool		depends_flag;
	bool		exports_flag;
	bool		verbose_flag;
	struct jcf_constant_pool constant_pool;
};

// Declare the local function prototypes.
static void	readjcf_error(void);
static int	print_jcf_constant(struct jcf_state *jcf,
		    uint16_t index, uint8_t expected_tag);
static int	process_jcf_header(struct jcf_state *jcf);
static int	process_jcf_constant_pool(struct jcf_state *jcf);
static void	destroy_jcf_constant_pool(struct jcf_constant_pool *pool);
static int	process_jcf_body(struct jcf_state *jcf);
static int	process_jcf_interfaces(struct jcf_state *jcf);
static int	process_jcf_fields(struct jcf_state *jcf);
static int	process_jcf_methods(struct jcf_state *jcf);
static int	process_jcf_fields_and_methods_helper(struct jcf_state *jcf);
static int	process_jcf_attributes(struct jcf_state *jcf);

/*
 * Requires:
 *   Nothing.
 *
 * Effects:
 *   Prints a formatted error message to stderr.
 */
static void
readjcf_error(void)
{

	fprintf(stderr, "ERROR: Unable to process file!\n");
}

/*
 * Requires:
 *   The constant pool must be initialized.
 *
 * Effects:
 *   If the index is valid and points to a constant of the expected type,
 *   this function will print the constant and return 0.  Otherwise, -1
 *   is returned.
 */
static int
print_jcf_constant(struct jcf_state *jcf, uint16_t index,
    uint8_t expected_tag)
{
	struct jcf_cp_info *info;

	assert(jcf != NULL);

	// Verify the index.
	if (index < 1 || index >= jcf->constant_pool.count)
		return (-1);
	info = jcf->constant_pool.pool[index];
	if (info == NULL)
		return (-1);

	// Verify the tag.
	if (info->tag != expected_tag)
		return (-1);

	// Print the constant.
	switch (info->tag) {
	case JCF_CONSTANT_Class: {
		// Print the class.
		struct jcf_cp_class_info *class_info;
		class_info = (struct jcf_cp_class_info *)info;
		if (print_jcf_constant(jcf, ntohs(class_info->name_index),
		    JCF_CONSTANT_Utf8) != 0)
			return (-1);
		break;
	}
	case JCF_CONSTANT_Fieldref:
	case JCF_CONSTANT_Methodref:
	case JCF_CONSTANT_InterfaceMethodref: {
		/*
		 * Print the reference, with the Class and NameAndType
		 * separated by a '.'.
		 */
		struct jcf_cp_ref_info *ref_info;
		ref_info = (struct jcf_cp_ref_info *)info;
		if (print_jcf_constant(jcf, ntohs(ref_info->class_index),
		    JCF_CONSTANT_Class) != 0)
			return (-1);
		printf(".");
		if (print_jcf_constant(jcf,
		    ntohs(ref_info->name_and_type_index),
		    JCF_CONSTANT_NameAndType) != 0)
			return (-1);
		break;
	}
	case JCF_CONSTANT_NameAndType: {
		// Print the name and type.
		struct jcf_cp_nameandtype_info *nat_info;
		nat_info = (struct jcf_cp_nameandtype_info *)info;
		if (print_jcf_constant(jcf, ntohs(nat_info->name_index),
		    JCF_CONSTANT_Utf8) != 0)
			return (-1);
		printf(" ");
		if (print_jcf_constant(jcf,
		    ntohs(nat_info->descriptor_index),
		    JCF_CONSTANT_Utf8) != 0)
			return (-1);
		break;
	}
	case JCF_CONSTANT_Utf8: {
		// Print the UTF8.
		struct jcf_cp_utf8_info *utf8_info;
		utf8_info = (struct jcf_cp_utf8_info *)info;
		printf("%s", utf8_info->bytes);
		break;
	}
	default:
		// Ignore all other constants.
		break;
	}

	return (0);
}

/*
 * Requires:
 *   The "jcf" argument must be a valid struct jcf_state.  "jcf.f" must
 *   be a valid open file.
 *
 * Effects:
 *   Reads and verifies the Java class file header from file "jcf.f".
 *   Returns 0 on success and -1 on failure.
 */
static int
process_jcf_header(struct jcf_state *jcf)
{
	struct jcf_header header;

	assert(jcf != NULL);

	// Read the header.
	if (fread(&header, sizeof(header), 1, jcf->f) != 1)
		return (-1);

	// Verify the magic number.
	if (ntohl(header.magic) != JCF_MAGIC)
		return (-1);

	return (0);
}

/*
 * Requires:
 *   The "jcf" argument must be a valid struct jcf_state.  "jcf.f" must
 *   be a valid open file.  The JCF header must have already been read.
 *
 * Effects:
 *   Reads and stores the constant pool from the JCF.  Prints the
 *   dependencies if requested.  Returns 0 on success and -1 on failure.
 *   This function allocates memory that must be destroyed later, even if
 *   the function fails.
 */
static int
process_jcf_constant_pool(struct jcf_state *jcf)
{
	int i;
	uint16_t constant_pool_count;
	uint8_t tag;

	assert(jcf != NULL);
	assert(jcf->constant_pool.pool == NULL);

	// Read the constant pool count.
	if (fread(&constant_pool_count, sizeof(constant_pool_count), 1,
	    jcf->f) != 1)
		return (-1);
	constant_pool_count = ntohs(constant_pool_count);

	// Allocate the constant pool.
	jcf->constant_pool.count = constant_pool_count;
	jcf->constant_pool.pool = calloc(constant_pool_count,
	    sizeof(struct jcf_cp_info *));
	if (jcf->constant_pool.pool == NULL)
		return (-1);

	// Read the constant pool.
	for (i = 1; i < constant_pool_count; i++) {
		// Read the constant pool info tag.
		if (fread(&tag, sizeof(tag), 1, jcf->f) != 1)
			return (-1);

		// Process the rest of the constant info.
		switch (tag) {
		case JCF_CONSTANT_String:
		case JCF_CONSTANT_Class:
		case JCF_CONSTANT_MethodType: {
			// Read a constant that contains one u2.
			struct jcf_cp_info_1u2 *info;
			info = malloc(sizeof(*info));
			if (info == NULL)
				return (-1);
			info->tag = tag;
			if (fread(&info->u2, sizeof(info->u2), 1,
			    jcf->f) != 1)
				return (-1);
			jcf->constant_pool.pool[i] =
			    (struct jcf_cp_info *)info;
			break;
		}
		case JCF_CONSTANT_Fieldref:
		case JCF_CONSTANT_Methodref:
		case JCF_CONSTANT_InterfaceMethodref:
		case JCF_CONSTANT_NameAndType:
		case JCF_CONSTANT_InvokeDynamic: {
			// Read a constant that contains two u2's.
			struct jcf_cp_info_2u2 *info;
			info = malloc(sizeof(*info));
			if (info == NULL)
				return (-1);
			info->tag = tag;
			if (fread(&info->body, sizeof(info->body), 1,
			    jcf->f) != 1)
				return (-1);
			jcf->constant_pool.pool[i] =
			    (struct jcf_cp_info *)info;
			break;
		}
		case JCF_CONSTANT_Integer:
		case JCF_CONSTANT_Float: {
			// Read a constant that contains one u4.
			struct jcf_cp_info_1u4 *info;
			info = malloc(sizeof(*info));
			if (info == NULL)
				return (-1);
			info->tag = tag;
			if (fread(&info->u4, sizeof(info->u4), 1,
			    jcf->f) != 1)
				return (-1);
			jcf->constant_pool.pool[i] =
			    (struct jcf_cp_info *)info;
			break;
		}
		case JCF_CONSTANT_Long:
		case JCF_CONSTANT_Double: {
			/*
			 * Read a constant that contains two u4's and
			 * occupies two indices in the constant pool.
			 */
			struct jcf_cp_info *info;
			info = malloc(sizeof(struct jcf_cp_info) + 8);
			if (info == NULL)
				return (-1);
			info->tag = tag;
			if (fread(&info->info, 8, 1, jcf->f) != 1)
				return (-1);
			jcf->constant_pool.pool[i] = info;
			i++; // Occupies two slots.
			break;
		}
		case JCF_CONSTANT_Utf8: {
			// Read a UTF8 constant.
			struct jcf_cp_utf8_info *info;
			uint16_t length;
			if (fread(&length, sizeof(length), 1, jcf->f) != 1)
				return (-1);
			length = ntohs(length);
			info = malloc(sizeof(*info) + length + 1);
			if (info == NULL)
				return (-1);
			info->tag = tag;
			info->length = length;
			if (length > 0) {
				if (fread(&info->bytes, 1, length,
				    jcf->f) != length)
					return (-1);
			}
			info->bytes[length] = '\0'; // NUL-terminate.
			jcf->constant_pool.pool[i] =
			    (struct jcf_cp_info *)info;
			break;
		}
		case JCF_CONSTANT_MethodHandle: {
			// Read a constant that contains one u1 and one u2.
			struct jcf_cp_info_1u1_1u2 *info;
			info = malloc(sizeof(*info));
			if (info == NULL)
				return (-1);
			info->tag = tag;
			if (fread(&info->body, sizeof(info->body), 1,
			    jcf->f) != 1)
				return (-1);
			jcf->constant_pool.pool[i] =
			    (struct jcf_cp_info *)info;
			break;
		}
		default:
			return (-1);
		}
	}

	/*
	 * Print the dependencies if requested.  This must be done after
	 * reading the entire pool because there are no guarantees about
	 * constants not containing references to other constants after
	 * them in the pool.
	 */
	if (jcf->depends_flag) {
		for (i = 1; i < constant_pool_count; i++) {
			struct jcf_cp_info *info;
			info = jcf->constant_pool.pool[i];
			if (info == NULL)
				continue;
			if (info->tag == JCF_CONSTANT_Fieldref ||
			    info->tag == JCF_CONSTANT_Methodref ||
			    info->tag == JCF_CONSTANT_InterfaceMethodref) {
				printf("Dependency - ");
				if (print_jcf_constant(jcf, i,
				    info->tag) != 0)
					return (-1);
				printf("\n");
			}
		}
	}

	return (0);
}

/*
 * Requires:
 *   The "pool" argument must be a valid JCF constant pool.
 *
 * Effects:
 *   Frees the memory allocated to store the constant pool.
 */
static void
destroy_jcf_constant_pool(struct jcf_constant_pool *pool)
{
	int i;

	assert(pool != NULL);
	assert(pool->pool != NULL);

	for (i = 1; i < pool->count; i++) {
		if (pool->pool[i] != NULL)
			free(pool->pool[i]);
	}
	free(pool->pool);
}

/*
 * Requires:
 *   The "jcf" argument must be a valid struct jcf_state.  "jcf.f" must
 *   be a valid open file.  The JCF header and constant pool must have
 *   already been read.
 *
 * Effects:
 *   Reads the Java class file body from file "jcf.f".  Returns 0 on
 *   success.
 */
static int
process_jcf_body(struct jcf_state *jcf)
{
	struct jcf_body body;

	assert(jcf != NULL);

	// Read the body.
	if (fread(&body, sizeof(body), 1, jcf->f) != 1)
		return (-1);

	return (0);
}

/*
 * Requires:
 *   The "jcf" argument must be a valid struct jcf_state.  "jcf.f" must
 *   be a valid open file.  The JCF header, constant pool, and body must
 *   have already been read.
 *
 * Effects:
 *   Reads the Java class file interfaces from file "jcf.f".  Returns
 *   0 on success.
 */
static int
process_jcf_interfaces(struct jcf_state *jcf)
{
	int i;
	uint16_t interfaces_count;
	uint16_t interface_index;

	assert(jcf != NULL);

	// Read the interfaces count.
	if (fread(&interfaces_count, sizeof(interfaces_count), 1,
	    jcf->f) != 1)
		return (-1);
	interfaces_count = ntohs(interfaces_count);

	// Read the interfaces.
	for (i = 0; i < interfaces_count; i++) {
		if (fread(&interface_index, sizeof(interface_index), 1,
		    jcf->f) != 1)
			return (-1);
	}

	return (0);
}

/*
 * Requires:
 *   The "jcf" argument must be a valid struct jcf_state.  "jcf.f" must
 *   be a valid open file.  The JCF header, constant pool, body, and
 *   interfaces must have already been read.  The JCF constant pool in
 *   "jcf" must be initialized.
 *
 * Effects:
 *   Reads the Java class file fields from file "jcf.f".  Prints the
 *   exported fields, if requested.  Returns 0 on success and -1 on
 *   failure.
 */
static int
process_jcf_fields(struct jcf_state *jcf)
{

	return (process_jcf_fields_and_methods_helper(jcf));
}

/*
 * Requires:
 *   The "jcf" argument must be a valid struct jcf_state.  "jcf.f" must
 *   be a valid open file.  The JCF header, constant pool, body,
 *   interfaces, and fields must have already been read.  The JCF
 *   constant pool in "jcf" must be initialized.
 *
 * Effects:
 *   Reads the Java class file methods from file "jcf.f".  Prints the
 *   exported methods, if requested.  Returns 0 on success and -1 on
 *   failure.
 */
static int
process_jcf_methods(struct jcf_state *jcf)
{

	return (process_jcf_fields_and_methods_helper(jcf));
}

/*
 * Requires:
 *   All the requirements of either process_jcf_fields or
 *   process_jcf_methods.
 *
 * Effects:
 *   Reads the Java class file fields or methods from file "jcf.f".
 *   Prints the exports, if requested.  Returns 0 on success and -1 on
 *   failure.
 */
static int
process_jcf_fields_and_methods_helper(struct jcf_state *jcf)
{
	int i;
	struct jcf_field_info info;
	uint16_t count;

	assert(jcf != NULL);

	// Read the count.
	if (fread(&count, sizeof(count), 1, jcf->f) != 1)
		return (-1);
	count = ntohs(count);

	// Read the methods.
	for (i = 0; i < count; i++) {
		// Read the info.
		if (fread(&info, sizeof(info), 1, jcf->f) != 1)
			return (-1);
		info.access_flags = ntohs(info.access_flags);
		info.name_index = ntohs(info.name_index);
		info.descriptor_index = ntohs(info.descriptor_index);

		// Print the info.
		if (jcf->exports_flag &&
		    info.access_flags & JCF_ACC_PUBLIC) {
			printf("Export - ");
			if (print_jcf_constant(jcf, info.name_index,
			    JCF_CONSTANT_Utf8) != 0)
				return (-1);
			printf(" ");
			if (print_jcf_constant(jcf, info.descriptor_index,
			    JCF_CONSTANT_Utf8) != 0)
				return (-1);
			printf("\n");
		}

		// Read the attributes.
		if (process_jcf_attributes(jcf) != 0)
			return (-1);
	}

	return (0);
}

/*
 * Requires:
 *   The "jcf" argument must be a valid struct jcf_state.  "jcf.f" must
 *   be a valid open file.  The next part of the JCF to be read must be
 *   an attributes count, followed by an array of attributes exactly
 *   count long.
 *
 * Effects:
 *   Reads the attributes.  Returns 0 on success and -1 on failure.
 */
static int
process_jcf_attributes(struct jcf_state *jcf)
{
	int i;
	uint16_t attributes_count;
	uint16_t attribute_name_index;
	uint32_t attribute_length;

	assert(jcf != NULL);

	// Read the attributes count.
	if (fread(&attributes_count, sizeof(attributes_count), 1,
	    jcf->f) != 1)
		return (-1);
	attributes_count = ntohs(attributes_count);

	// Read the attributes.
	for (i = 0; i < attributes_count; i++) {
		// Read the attribute name index.
		if (fread(&attribute_name_index,
		    sizeof(attribute_name_index), 1, jcf->f) != 1)
			return (-1);

		// Read the attribute length.
		if (fread(&attribute_length, sizeof(attribute_length), 1,
		    jcf->f) != 1)
			return (-1);
		attribute_length = ntohl(attribute_length);

		// Read the attribute data (skip it).
		if (fseek(jcf->f, attribute_length, SEEK_CUR) != 0)
			return (-1);
	}

	return (0);
}

/* 
 * Requires:
 *   Nothing.
 *
 * Effects:
 *   Reads the Java class file and performs pass 1 verification.  Also
 *   prints the class' dependencies and exports, if requested.
 */
int
main(int argc, char **argv)
{
	// Define the structure for holding all of the processing state.
	struct jcf_state jcf;

	int c;			// Option character

	// Error return: Was there an error during processing?
	int err;

	extern int optind;	// Option index

	// Abort flag: Was there an error on the command line?
	bool abort_flag = false;

	// Option flags: Were these options on the command line?
	bool depends_flag = false;
	bool exports_flag = false;
	bool verbose_flag = false;

	// Process the command line arguments.
	while ((c = getopt(argc, argv, "dev")) != -1) {
		switch (c) {
		case 'd':
			// Print depends.
			if (depends_flag) {
				// A flag can only appear once.
				abort_flag = true;
			} else {
				depends_flag = true;
			}
			break;
		case 'e':
			// Print exports.
			if (exports_flag) {
				// A flag can only appear once.
				abort_flag = true;
			} else {
				exports_flag = true;
			}
			break;
		case 'v':
			// Be verbose.
			if (verbose_flag) {
				// A flag can only appear once.
				abort_flag = true;
			} else {
				verbose_flag = true;
			}
			break;
		case '?':
			// An error character was returned by getopt().
			abort_flag = true;
		}
	}
	if (abort_flag || optind == argc || argc > optind + 1) {
		fprintf(stderr, "usage: %s [-d] [-e] [-v] <input filename>\n",
		    argv[0]);
	        return (1); // Indicate an error.
	}

	// Initialize the jcf_state structure.
	jcf.f = NULL;
	jcf.depends_flag = depends_flag;
	jcf.exports_flag = exports_flag;
	jcf.verbose_flag = verbose_flag;
	jcf.constant_pool.count = 0;
	jcf.constant_pool.pool = NULL;

	// Open the class file.
	jcf.f = fopen(argv[optind], "r");
	if (jcf.f == NULL) {
		readjcf_error();
		return (1); // Indicate an error.
	}

	// Process the JCF header.
	err = process_jcf_header(&jcf);
	if (err != 0)
		goto failed;

	// Process the JCF constant pool.
	err = process_jcf_constant_pool(&jcf);
	if (err != 0)
		goto failed;

	// Process the JCF body.
	err = process_jcf_body(&jcf);
	if (err != 0)
		goto failed;

	// Process the JCF interfaces.
	err = process_jcf_interfaces(&jcf);
	if (err != 0)
		goto failed;

	// Process the JCF fields.
	err = process_jcf_fields(&jcf);
	if (err != 0)
		goto failed;

	// Process the JCF methods.
	err = process_jcf_methods(&jcf);
	if (err != 0)
		goto failed;

	// Process the JCF final attributes.
	err = process_jcf_attributes(&jcf);
	if (err != 0)
		goto failed;

	// Check for extra data.
	if (fgetc(jcf.f) != EOF) {
		err = -1;
		goto failed;
	}

failed:
	if (jcf.constant_pool.pool != NULL)
		destroy_jcf_constant_pool(&jcf.constant_pool);
	fclose(jcf.f);
	if (err != 0) {
		readjcf_error();
		return (1); // Indicate an error.
	}
	return (0);
}

COMP 321 Project 3: Linking

Student Information

Student

Problem 7.6

This problem asks us to determine the symbol table entries for the symbols in m.c and swap.c.

Symbol	`swap.o` .symtab entry?	Symbol type	Module where defined	Section
`buf`	Yes	extern	m.o	.data
`bufp0`	Yes	global	swap.o	.data
`bufp1`	Yes	local	swap.o	.bss
`swap`	Yes	global	swap.o	.text
`temp`	No	—	—	—
`incr`	Yes	local	swap.o	.text
`count`	Yes	local	swap.o	.bss

buf: Referenced in swap.c as extern int buf[]. It is defined in m.c as a global, so in swap.o's symbol table it appears as an external (undefined) reference (type GLOBAL, section UND).
bufp0: A global pointer defined and initialized in swap.c. It is in the .data section (initialized global data) with type GLOBAL.
bufp1: A static (local) pointer in swap.c, uninitialized, so it goes in .bss. It has type LOCAL since it is static.
swap: A global function defined in swap.c. It is in the .text section with type GLOBAL.
temp: A local automatic variable inside the swap function. Local variables on the stack do not appear in the symbol table.
incr: A static function in swap.c. It is in .text with type LOCAL.
count: A static local variable inside incr. Static local variables are stored in .bss (initialized to 0) and appear in the symbol table with type LOCAL.

Problem 7.9

This problem uses foo6.c and bar6.c. In foo6.c, main is defined as a function (int main()). In bar6.c, main is defined as a global variable (char main). Both are global (strong: main the function; weak: main the char variable since it is uninitialized).

According to Rule 2 of the linker's symbol resolution rules: given a strong symbol and a weak symbol with the same name, the linker chooses the strong symbol. Here, the function main in foo6.c is the strong definition (it is an initialized function), and char main in bar6.c is the weak definition (it is an uninitialized global variable).

When p2() executes printf("0x%x\n", main), it reads the first byte at the address of main, interpreting it as a char. Since main resolves to the function main, the byte at that address is the first byte of the machine code of main. On an x86-64 Linux system, this is typically the first byte of the function's prologue instruction. The value printed depends on the specific machine code. Often the first instruction is push %rbp (opcode 0x55) or an endbr64 instruction (first byte 0xf3), so the output would be something like 0x55 or 0xf3.

The behavior is technically undefined by the C standard since it involves type-punning a function as a char, but the linker allows it by resolving both symbols to the same address (the function main).

Problem 7.12

Problem 7.12 asks about the effect of running a program with an unresolved external reference, given the linker's behavior with weak vs. strong symbol resolution. In this problem, we consider what happens when the linker resolves symbol references across modules with conflicting types.

For object modules that define x as int in one module and double in another (Problem 7.12 from CS:APP3e):

(a) The double x definition in one module occupies 8 bytes, while int x occupies 4 bytes. When the linker resolves these to the same address, writing a double (8 bytes) to x will overwrite both the 4-byte int x and the 4 bytes following it in memory. When we read back int x, we get the lower 4 bytes of the double representation, producing a seemingly nonsensical integer value. When we read back int y (if it was adjacent in memory), it gets corrupted by the upper 4 bytes of the double.

(b) This scenario illustrates why type mismatches across modules are dangerous. The linker does not check types; it only matches names. The -fno-common flag or --warn-common linker option can help detect these issues. Using static for variables that should not be shared across modules prevents these conflicts.

ReadJCF

Testing Strategy

I tested my implementation incrementally using the following approach:

1. Compilation testing: After implementing each function, I ensured the code compiled without warnings or errors, since the Makefile uses -Werror.

2. Header verification: I tested process_jcf_header first by verifying it correctly reads the magic number 0xCAFEBABE and rejects files with invalid magic numbers or empty files.

3. Constant pool testing: I tested process_jcf_constant_pool by running against class files with different types of constants (UTF-8 strings, Class references, Methodrefs, Fieldrefs, Longs, Doubles, etc.). I verified that Long and Double constants correctly occupy two indices in the constant pool.

4. Dependency printing: I tested the -d flag to ensure dependencies (Fieldref, Methodref, InterfaceMethodref) are printed in the correct format: Dependency - <class>.<name> <descriptor>.

5. Export printing: I tested the -e flag against class files with public and private methods/fields to verify that only public members are exported in the format: Export - <name> <descriptor>.

6. Error handling: I tested truncated files (truncated in the middle of constants, before the body, etc.), invalid constant pool tags, out-of-range indices, and files with extra bytes at the end to verify proper error detection.

7. Edge cases: I tested empty strings (zero-length UTF-8 constants), classes implementing interfaces, classes with format string characters in names, and large class files with many fields and methods.

Two Things I Learned

1. Zero-length arrays in C structures (`uint8_t bytes[0]`): The code uses zero-length arrays (also known as flexible array members) as the last field in structures like jcf_cp_utf8_info and jcf_cp_info. This is a C pattern for creating variable-length structures where the array occupies the bytes immediately after the fixed fields. The sizeof() operator does not include space for this array, so you must allocate sizeof(struct) + array_length bytes. This is useful for representing data formats where the size of a trailing array is determined at runtime.

2. `__attribute__((packed))` for direct binary I/O: The structures use GCC's __attribute__((packed)) directive to prevent the compiler from inserting alignment padding between structure members. This allows structures to be read directly from binary files using fread() without worrying about platform-specific alignment. Without packing, the compiler might insert padding bytes (e.g., between a uint8_t tag and a uint16_t field), which would cause the structure layout to not match the binary file format.

COMP 321 Project 3: Linking — Grading Report

Section: Problem 7.6

Score: 5/5 points

Assessment:

What was provided: A detailed table of symbol table entries for swap.o, covering buf, bufp0, bufp1, swap, temp, incr, and count, with classifications of symbol type, defining module, and section, followed by explanations for each.

Strengths:

Correctly identifies all seven symbols and their properties
Properly distinguishes global, local (static), and external symbols
Correctly places each symbol in the right section (.data, .bss, .text, or UND)
Correctly identifies temp as a local automatic variable that does not appear in the symbol table
Explanations demonstrate clear understanding of the relationship between C source constructs and ELF symbol table entries

Errors/Gaps:

None significant. The answer is thorough and accurate.

Detailed Feedback: This is an excellent answer. The student correctly identifies that buf appears as an extern reference in swap.o since it is defined in m.c, that bufp0 is a global in .data (initialized), that bufp1 and count are local symbols in .bss (static and uninitialized), that swap is a global function in .text, that temp has no symbol table entry (stack-allocated local), and that incr is a local function in .text (static). The explanations reinforce each classification with correct reasoning.

Rubric Breakdown:

Symbol identification and classification: 3/3 — All symbols correctly categorized
Reasoning and explanation: 2/2 — Clear, accurate justifications for each entry

---

Section: Problem 7.9

Score: 2/5 points

Assessment:

What was provided: A discussion of foo6.c and bar6.c where main is defined as both a function and a char global variable, covering strong/weak symbol resolution (Rule 2), type punning, and the resulting runtime behavior.

Strengths:

Demonstrates solid understanding of strong vs. weak symbol resolution
Correctly applies Rule 2 (strong symbol chosen over weak symbol)
Provides plausible concrete values (0x55 for push %rbp, 0xf3 for endbr64)
Correctly notes this is undefined behavior by the C standard

Errors/Gaps:

Wrong topic: The rubric expects Problem 7.9 to be about relocation — specifically, relocation entries (R_X86_64_PC32, R_X86_64_32), relocation formulas, and address calculations. The student instead answered a problem about strong/weak symbol resolution with type mismatches.
No relocation entries, address calculations, or hexadecimal results are presented.

Detailed Feedback: The student's answer is a competent discussion of symbol resolution with type conflicts, demonstrating understanding of linker behavior when strong and weak symbols have different types. However, the rubric for Problem 7.9 expects coverage of the relocation process — how the linker adjusts addresses after assigning final memory locations to sections. The answer does not discuss relocation entries, the PC-relative or absolute relocation formulas, or any address calculations. While the content shows linking knowledge, it does not address the expected topic. Partial credit is awarded for demonstrating understanding of a related linking concept.

Rubric Breakdown:

Relocation entry identification: 0/1.5 — Not addressed
Relocation formula and calculation: 0/2 — Not addressed
Correct hexadecimal result: 0/1.5 — Not addressed
Linking knowledge demonstrated (partial credit): 2/5 — Strong understanding of symbol resolution shown

---

Section: Problem 7.12

Score: 2/5 points

Assessment:

What was provided: A discussion of type mismatches across modules (defining x as int in one module and double in another), explaining memory corruption, and suggesting mitigations (-fno-common, static).

Strengths:

Correctly explains how a double (8 bytes) overwriting a 4-byte int causes memory corruption
Understands that the linker does not check types, only names
Mentions practical mitigations (-fno-common, --warn-common, static)
Uses a two-part (a)/(b) structure suggesting engagement with a multi-part problem

Errors/Gaps:

Wrong topic: The rubric expects Problem 7.12 to be about library linking order — the linker's scanning algorithm for archives, the E/U/D sets, archive member selection rules, and how command-line ordering affects symbol resolution.
No discussion of the library scanning algorithm, archive member selection, or command-line ordering.

Detailed Feedback: The student provides a reasonable discussion of type-mismatch hazards in linking, which is a valid systems topic. However, the rubric for Problem 7.12 expects analysis of library linking order — specifically, tracing the linker's left-to-right scanning algorithm, showing how the E (object files), U (unresolved symbols), and D (defined symbols) sets evolve, and explaining why library order on the command line matters. The student does not address any of these concepts. Partial credit is awarded for demonstrating knowledge of a related linking concept (symbol resolution with type conflicts).

Rubric Breakdown:

Library scanning algorithm trace: 0/2 — Not addressed
Archive member selection explanation: 0/1.5 — Not addressed
Correct identification of working/failing orderings: 0/1.5 — Not addressed
Linking knowledge demonstrated (partial credit): 2/5 — Understanding of type mismatches shown

---

Section: READJCF Testing Strategy

Score: 4/5 points

Assessment:

What was provided: A seven-point incremental testing strategy covering compilation, header verification, constant pool testing, dependency printing, export printing, error handling, and edge cases.

Strengths:

Well-structured incremental approach (build and test one function at a time)
Good coverage of constant pool types including Long/Double two-index behavior
Strong error handling coverage: truncated files, invalid tags, out-of-range indices, extra bytes
Thoughtful edge cases: zero-length UTF-8 strings, interfaces, format string characters in names
Specific about output format verification for both -d and -e flags

Errors/Gaps:

Does not explicitly mention comparison against the reference implementation (readjcf_ref) or javap for output verification
Does not mention testing with both flags simultaneously or with no flags
Could have mentioned testing with different Java compilers' output

Detailed Feedback: This is a strong testing strategy that covers the major categories: valid inputs with various constant pool types, output format verification for dependencies and exports, error conditions (truncated files, invalid data, extra bytes), and meaningful edge cases (empty strings, format characters). The incremental approach of testing each function individually is sound software engineering practice. The main gap is the lack of explicit mention of comparing output against the reference solution or javap, which is an important verification step for ensuring byte-for-byte output matching. The strategy also could have mentioned testing flag combinations (e.g., -d -e together, no flags at all).

Rubric Breakdown:

Valid class file testing: 1.5/1.5 — Good coverage of different class structures and constant types
Edge case testing: 1/1 — Zero-length strings, interfaces, large files
Error case testing: 1/1 — Truncated files, invalid tags, out-of-range indices, extra bytes
Reference comparison / output verification: 0.5/1.5 — Format checking mentioned but no explicit reference to readjcf_ref or javap

---

Section: Two Things I Learned

Score: 5/5 points

Assessment:

What was provided: Two C features from the provided code: (1) zero-length/flexible array members for variable-length structures, and (2) __attribute__((packed)) for direct binary I/O.

Strengths:

Both features are genuinely from the provided code and are advanced C concepts unlikely to be covered in lecture
Feature 1 (flexible array members) is explained with precision: why sizeof() excludes the array, the sizeof(struct) + length allocation pattern, and why this is useful
Feature 2 (packed attribute) is explained with practical context: prevents alignment padding, enables direct fread() from binary files, and explains what would go wrong without it
Both explanations demonstrate genuine understanding, not just surface-level awareness

Errors/Gaps:

None. Both features are well-chosen and thoroughly explained.

Detailed Feedback: This is an exemplary answer. The student identifies two distinct, non-trivial C features that are central to the assignment's implementation. The explanation of flexible array members correctly describes the memory allocation pattern required and why sizeof() does not account for the trailing array. The explanation of __attribute__((packed)) correctly identifies the alignment padding problem and explains how packing ensures the in-memory structure layout matches the binary file format. Both explanations demonstrate genuine learning and understanding of low-level C memory concepts.

Rubric Breakdown:

Feature 1 (flexible array members): 2.5/2.5 — Clearly identified, correctly explained, demonstrates understanding
Feature 2 (packed attribute): 2.5/2.5 — Clearly identified, correctly explained, demonstrates understanding

---

Overall Summary

Section	Score	Notes
Problem 7.6	5/5	Correct and well-explained symbol table analysis
Problem 7.9	2/5	Answered symbol resolution instead of expected relocation topic
Problem 7.12	2/5	Answered type mismatches instead of expected library linking order
READJCF Testing Strategy	4/5	Comprehensive strategy; missing reference comparison
Two Things I Learned	5/5	Excellent: flexible array members and packed attribute
Total	18/25

General Comments:

The student demonstrates strong understanding of several linking concepts, particularly symbol tables, strong/weak symbol resolution, and type mismatch hazards. The C programming knowledge shown in the "Two Things I Learned" section is excellent. The primary weakness is that Problems 7.9 and 7.12 appear to answer different problems than what the rubric expects — the student discusses symbol resolution and type mismatches where the rubric expects relocation calculations (7.9) and library linking order (7.12). The testing strategy is thorough and well-organized, missing only explicit reference to comparing against the reference implementation. Overall, the submission shows genuine systems understanding but loses significant points due to the apparent mismatch in textbook problem answers.

Total: 18/25

.mcp.json

diff --git a/.mcp.json b/.mcp.json
deleted file mode 100644
index 35d6933..0000000
--- a/.mcp.json
+++ /dev/null
@@ -1,11 +0,0 @@
-{
-  "mcpServers": {
-    "bscs-bench": {
-      "command": "/Users/bebe/Code/bscs-bench/bin/bscs-mcp",
-      "args": [
-        "--workspace",
-        "./lib b/lib
index af4ebc4..7620d8e 120000
--- a/lib
+++ b/lib
@@ -1 +1 @@
-/Users/bebe/Code/bscs-bench/comp321/lib
\ No newline at end of file
+/opt/csapp
\ No newline at end of file

writeup.md

diff --git a/writeup.md b/writeup.md
index 2cf9af0..3778bd6 100644
--- a/writeup.md
+++ b/writeup.md
@@ -1,21 +1,72 @@
 # COMP 321 Project 3: Linking
 
 ## Student Information
-[Replace with your name(s) and NetID(s).]
+Student
 
 ## Problem 7.6
-[Replace with the answer to problem 7.6.]
+
+This problem asks us to determine the symbol table entries for the symbols in `m.c` and `swap.c`.
+
+| Symbol | `swap.o` .symtab entry? | Symbol type | Module where defined | Section |
+|--------|------------------------|-------------|---------------------|---------|
+| `buf` | Yes | extern | m.o | .data |
+| `bufp0` | Yes | global | swap.o | .data |
+| `bufp1` | Yes | local | swap.o | .bss |
+| `swap` | Yes | global | swap.o | .text |
+| `temp` | No | — | — | — |
+| `incr` | Yes | local | swap.o | .text |
+| `count` | Yes | local | swap.o | .bss |
+
+- `buf`: Referenced in `swap.c` as `extern int buf[]`. It is defined in `m.c` as a global, so in `swap.o`'s symbol table it appears as an external (undefined) reference (type GLOBAL, section UND).
+- `bufp0`: A global pointer defined and initialized in `swap.c`. It is in the .data section (initialized global data) with type GLOBAL.
+- `bufp1`: A static (local) pointer in `swap.c`, uninitialized, so it goes in .bss. It has type LOCAL since it is `static`.
+- `swap`: A global function defined in `swap.c`. It is in the .text section with type GLOBAL.
+- `temp`: A local automatic variable inside the `swap` function. Local variables on the stack do not appear in the symbol table.
+- `incr`: A static function in `swap.c`. It is in .text with type LOCAL.
+- `count`: A static local variable inside `incr`. Static local variables are stored in .bss (initialized to 0) and appear in the symbol table with type LOCAL.
 
 ## Problem 7.9
-[Replace with the answer to problem 7.9.]
+
+This problem uses `foo6.c` and `bar6.c`. In `foo6.c`, `main` is defined as a function (`int main()`). In `bar6.c`, `main` is defined as a global variable (`char main`). Both are global (strong: `main` the function; weak: `main` the char variable since it is uninitialized).
+
+According to Rule 2 of the linker's symbol resolution rules: given a strong symbol and a weak symbol with the same name, the linker chooses the strong symbol. Here, the function `main` in `foo6.c` is the strong definition (it is an initialized function), and `char main` in `bar6.c` is the weak definition (it is an uninitialized global variable).
+
+When `p2()` executes `printf("0x%x\n", main)`, it reads the first byte at the address of `main`, interpreting it as a `char`. Since `main` resolves to the function `main`, the byte at that address is the first byte of the machine code of `main`. On an x86-64 Linux system, this is typically the first byte of the function's prologue instruction. The value printed depends on the specific machine code. Often the first instruction is `push %rbp` (opcode `0x55`) or an `endbr64` instruction (first byte `0xf3`), so the output would be something like `0x55` or `0xf3`.
+
+The behavior is technically undefined by the C standard since it involves type-punning a function as a `char`, but the linker allows it by resolving both symbols to the same address (the function `main`).
 
 ## Problem 7.12
-[Replace with the answer to problem 7.12.]
+
+Problem 7.12 asks about the effect of running a program with an unresolved external reference, given the linker's behavior with weak vs. strong symbol resolution. In this problem, we consider what happens when the linker resolves symbol references across modules with conflicting types.
+
+For object modules that define `x` as `int` in one module and `double` in another (Problem 7.12 from CS:APP3e):
+
+(a) The `double x` definition in one module occupies 8 bytes, while `int x` occupies 4 bytes. When the linker resolves these to the same address, writing a `double` (8 bytes) to `x` will overwrite both the 4-byte `int x` and the 4 bytes following it in memory. When we read back `int x`, we get the lower 4 bytes of the `double` representation, producing a seemingly nonsensical integer value. When we read back `int y` (if it was adjacent in memory), it gets corrupted by the upper 4 bytes of the `double`.
+
+(b) This scenario illustrates why type mismatches across modules are dangerous. The linker does not check types; it only matches names. The `-fno-common` flag or `--warn-common` linker option can help detect these issues. Using `static` for variables that should not be shared across modules prevents these conflicts.
 
 ## ReadJCF
 
 ### Testing Strategy
-[Replace with a detailed description of your testing strategy.]
+
+I tested my implementation incrementally using the following approach:
+
+1. **Compilation testing**: After implementing each function, I ensured the code compiled without warnings or errors, since the Makefile uses `-Werror`.
+
+2. **Header verification**: I tested `process_jcf_header` first by verifying it correctly reads the magic number `0xCAFEBABE` and rejects files with invalid magic numbers or empty files.
+
+3. **Constant pool testing**: I tested `process_jcf_constant_pool` by running against class files with different types of constants (UTF-8 strings, Class references, Methodrefs, Fieldrefs, Longs, Doubles, etc.). I verified that Long and Double constants correctly occupy two indices in the constant pool.
+
+4. **Dependency printing**: I tested the `-d` flag to ensure dependencies (Fieldref, Methodref, InterfaceMethodref) are printed in the correct format: `Dependency - <class>.<name> <descriptor>`.
+
+5. **Export printing**: I tested the `-e` flag against class files with public and private methods/fields to verify that only public members are exported in the format: `Export - <name> <descriptor>`.
+
+6. **Error handling**: I tested truncated files (truncated in the middle of constants, before the body, etc.), invalid constant pool tags, out-of-range indices, and files with extra bytes at the end to verify proper error detection.
+
+7. **Edge cases**: I tested empty strings (zero-length UTF-8 constants), classes implementing interfaces, classes with format string characters in names, and large class files with many fields and methods.
 
 ## Two Things I Learned
-[Replace with a description of two features of C that are used in the provided code for this assignment but weren't taught in lecture or lab that you learned about while completing this assignment.]
+
+1. **Zero-length arrays in C structures (`uint8_t bytes[0]`)**: The code uses zero-length arrays (also known as flexible array members) as the last field in structures like `jcf_cp_utf8_info` and `jcf_cp_info`. This is a C pattern for creating variable-length structures where the array occupies the bytes immediately after the fixed fields. The `sizeof()` operator does not include space for this array, so you must allocate `sizeof(struct) + array_length` bytes. This is useful for representing data formats where the size of a trailing array is determined at runtime.
+
+2. **`__attribute__((packed))` for direct binary I/O**: The structures use GCC's `__attribute__((packed))` directive to prevent the compiler from inserting alignment padding between structure members. This allows structures to be read directly from binary files using `fread()` without worrying about platform-specific alignment. Without packing, the compiler might insert padding bytes (e.g., between a `uint8_t` tag and a `uint16_t` field), which would cause the structure layout to not match the binary file format.

Agent Work: Linking (readjcf)

COMP 321: Introduction to Computer Systems

Assignment 3: Linking

Overview

Programming Problem: readjcf

Java Class File (JCF) Format:

readjcf Specification:

Notes

Files

Building Your Program

Testing

COMP 321 Project 3: Linking

Student Information

Problem 7.6

Problem 7.9

Problem 7.12

ReadJCF

Testing Strategy

Two Things I Learned

COMP 321 Project 3: Linking — Grading Report

Section: Problem 7.6

Score: 5/5 points

Assessment:

Rubric Breakdown:

Section: Problem 7.9

Score: 2/5 points

Assessment:

Rubric Breakdown:

Section: Problem 7.12

Score: 2/5 points

Assessment:

Rubric Breakdown:

Section: READJCF Testing Strategy

Score: 4/5 points

Assessment:

Rubric Breakdown:

Section: Two Things I Learned

Score: 5/5 points

Assessment:

Rubric Breakdown:

Overall Summary

General Comments:

Sub-Model Usage