To be able to execute programs written in high-level programming languages, they first have to be translated into
CPU instructions using a compiler. Language
constructs and statements of high-level programming languages are CPU architecture independent and do not have any special relationship with
individual CPU instructions. The compiler is
responsible for selecting and emitting the appropriate instructions which are required for the task at hand.Assembly languages are special kinds of low-level
programming languages. Unlike their high-level counterparts, assembly languages are not architecture-independent but
instead target a specific instruction set. While language constructs in high-level languages may be compiled into
any number of instructions, each statement in an assembly language is translated into one specific CPU instruction. An assembly language can also be
thought of as a translation between human-readable mnemonics and binary opcodes readable by the CPU (e.g.jmp = 0xE9). A compiler for an assembly
language is also called an assembler.While it is
usually a lot more efficient and practical to write code in high-level languages, some things still require
low-level assembly instructions because they are simply not possible to accomplish in other programming languages.
This is especially true when using CPU hardware features that can only be accessed using special instructions. For
instance, the rdtsc instruction, which you may use
in the Operating Systems course for precise timing, or the later discussed cpuid instruction. When using the GCC C compiler, it is possible to combine normal code written in C with
assembly code in the same source file or even the same function by using GCC inline assembly. In order to gather experience with inline assembly you will implement the first task of
this exercise.

On the x86 architecture, the cpuid instruction can
be used to retrieve information about the CPU that a program is running on. This includes information about the
processor type and manufacturer, as well as information about features and instruction set extensions that are
supported by the CPU. The specific category of information to be retrieved can be selected by setting the eax register (and in some cases also the ecx register) to various ID values before executing the cpuid instruction. The CPU then provides the requested information in the
eax, ebx, ecx
and edx registers.

Your Task

Use the cpuid instruction to read information about the CPU (5 Points)

Write a program that uses the cpuid instruction to read the following pieces of information about the CPU:

• Manufacturer ID string (e.g. ‘AuthenticAMD’)
• Processor brand string (e.g. ‘AMD Ryzen 9 3900X 12-Core Processor’)

You should also determine which of the following features are supported by reading the corresponding feature flags
(for more information about these flags, see the resources). It is sufficient to stick to Intels layout for the
feature flags.

• SSE
• MSR
• CMOV
• AVX
• AVX2
• VMX
• FMA
• HYBRID

Print the retrieved information to stdout via the printf calls provided as comments in the code (see file cpuid/cpuid.c). Do not use any compiler
intrinsics or library functions to call the cpuid instruction, only inline assembly. Make sure to properly handle
all inputs, outputs, and clobbered registers in your inline assembly blocks.
Verify your results by comparing them with the output of cat /proc/cpuinfo.

Resources

• Documentation for the cpuid instruction
• ID values for eax register

Task 6.2: ABI – Calling Conventions

Calling Conventions

Your Tasks

uint64_t calculate_fibonacci_ref(uint64_t *fibonacci_numbers, uint64_t amount) {
    fibonacci_numbers[0] = 0;
    fibonacci_numbers[1] = 1;
    uint64_t current = 1;

    for (uint64_t i = 2; i < amount; i++) {
        current = fibonacci_numbers[i - 1] + fibonacci_numbers[i - 2];
        fibonacci_numbers[i] = current; 
    }

    return current;
}