| Both sides previous revisionPrevious revisionNext revision | Previous revision |
| en:multiasm:cs:chapter_3_10 [2025/01/08 07:22] – [Data addressing] ktokarz | en:multiasm:cs:chapter_3_10 [2025/01/09 08:19] (current) – [Program control flow destination addressing] ktokarz |
|---|
| |
| <figure addrregister> | <figure addrregister> |
| {{ :en:multiasm:cs:addressing_register.png?600 |Ilustration of addressing registers}} | {{ :en:multiasm:cs:addressing_register.png?600 |Illustration of addressing registers}} |
| <caption>Ilustration of addressing registers</caption> | <caption>Illustration of addressing registers</caption> |
| </figure> | </figure> |
| |
| copy R1, 5 | copy R1, 5 |
| </code> | </code> |
| | |
| | <figure addrimmediate> |
| | {{ :en:multiasm:cs:addressing_immediate.png?600 |Illustration of immediate addressing mode}} |
| | <caption>Illustration of immediate addressing mode</caption> |
| | </figure> |
| |
| **A direct memory operand** specifies the data at a given address. An address can be given in numerical form or as the name of the previously defined variable. It is equivalent to static variable definition in high-level languages. If we assume that the //var// represents the address of the variable the instruction which copies data from the variable to //R1// can look like this: | **A direct memory operand** specifies the data at a given address. An address can be given in numerical form or as the name of the previously defined variable. It is equivalent to static variable definition in high-level languages. If we assume that the //var// represents the address of the variable the instruction which copies data from the variable to //R1// can look like this: |
| copy R1, var | copy R1, var |
| </code> | </code> |
| | |
| | <figure addrdirect> |
| | {{ :en:multiasm:cs:addressing_direct.png?600 |Illustration of direct addressing mode}} |
| | <caption>Illustration of direct addressing mode</caption> |
| | </figure> |
| |
| **Indirect memory operand** is accessed by specifying the name of the register which value represents the address of the memory location to reach. We can compare the indirect addressing to the pointer in high-level languages where the variable does not store the value but points to the memory location where the value is stored. Indirect addressing can also be used to access elements of the table in a loop, where we use the index value which changes every loop iteration rather than a single address. Different assemblers have different notations of indirect addressing, some use brackets, some square brackets, and others //@// symbol. Even different assembler programs for the same processor can differ. In the following example, we assume the use of square brackets. The instruction which copies the data from the memory location addressed by the content of the //R0// register to //R1// register would look like this: | **Indirect memory operand** is accessed by specifying the name of the register which value represents the address of the memory location to reach. We can compare the indirect addressing to the pointer in high-level languages where the variable does not store the value but points to the memory location where the value is stored. Indirect addressing can also be used to access elements of the table in a loop, where we use the index value which changes every loop iteration rather than a single address. Different assemblers have different notations of indirect addressing, some use brackets, some square brackets, and others //@// symbol. Even different assembler programs for the same processor can differ. In the following example, we assume the use of square brackets. The instruction which copies the data from the memory location addressed by the content of the //R0// register to //R1// register would look like this: |
| copy R1, [R0] | copy R1, [R0] |
| </code> | </code> |
| | |
| | <figure addrindirect> |
| | {{ :en:multiasm:cs:addressing_indirect.png?600 |Illustration of indirect addressing mode}} |
| | <caption>Illustration of indirect addressing mode</caption> |
| | </figure> |
| |
| **Variations of indirect addressing**. The indirect addressing mode can have many variations where the final address doesn't have to be the content of a single register but rather the sum of a constant value with one or more registers. Some variants implement automatic incrementation (similar to the "++" operator) or decrementation ("--") of the index register before or after instruction execution to make processing the tables faster. For example, accessing elements of the table where the base address of the table is named //data_table// and the register //R0// holds the index of the byte which we want to copy from a table to //R1// could look like this: | **Variations of indirect addressing**. The indirect addressing mode can have many variations where the final address doesn't have to be the content of a single register but rather the sum of a constant value with one or more registers. Some variants implement automatic incrementation (similar to the "++" operator) or decrementation ("--") of the index register before or after instruction execution to make processing the tables faster. For example, accessing elements of the table where the base address of the table is named //data_table// and the register //R0// holds the index of the byte which we want to copy from a table to //R1// could look like this: |
| copy R1, table[R0] | copy R1, table[R0] |
| </code> | </code> |
| | |
| | <figure addrindex> |
| | {{ :en:multiasm:cs:addressing_index.png?600 |Illustration of indirect index addressing mode}} |
| | <caption>Illustration of indirect index addressing mode</caption> |
| | </figure> |
| |
| Addressing mode with pre-decrementation (decrementing before instruction execution) could look like this: | Addressing mode with pre-decrementation (decrementing before instruction execution) could look like this: |
| |
| |
| ===== Program flow destination addressing ===== | ===== Program control flow destination addressing ===== |
| |
| Addressing the destination of the program flow change is the operand of jump, branch or function call instructions. In structural or object-oriented high-level languages jump instructions should be avoided, they are rather common in assembler programming. Our examples will use hypothetic //jump// instruction with a single operand - the destination address. | The operand of jump, branch, or function call instructions addresses the destination of the program flow control. The result of these instructions is the change of the Instruction Pointer content. Jump instructions should be avoided in structural or object-oriented high-level languages, but they are rather common in assembler programming. Our examples will use the hypothetic //jump// instruction with a single operand—the destination address. |
| |
| **Direct addressing** of the destination is similar to direct data addressing. It specifies the destination address as the constant value, usually represented by the name. In assembler, we define the names of the addresses in code as //labels//. In the following example, the code will jump to the label named //destin//: | **Direct addressing** of the destination is similar to direct data addressing. It specifies the destination address as the constant value, usually represented by the name. In assembler, we define the names of the addresses in code as //labels//. In the following example, the code will jump to the label named //destin//: |
| jump destin | jump destin |
| </code> | </code> |
| | |
| | <figure jumpdirect> |
| | {{ :en:multiasm:cs:jump_direct.png?600 |Illustration of addressing in direct jump}} |
| | <caption>Illustration of addressing in direct jump</caption> |
| | </figure> |
| |
| **Indirect addressing** of the destination uses the content of the register as the address where the program will jump. In the following example, the processor will jump to the destination address which is stored in //R0//: | **Indirect addressing** of the destination uses the content of the register as the address where the program will jump. In the following example, the processor will jump to the destination address which is stored in //R0//: |
| jump [R0] | jump [R0] |
| </code> | </code> |
| | |
| | <figure jumpindirect> |
| | {{ :en:multiasm:cs:jump_indirect.png?600 |Illustration of addressing in indirect jump}} |
| | <caption>Illustration of addressing in indirect jump</caption> |
| | </figure> |
| |
| ===== Absolute and Relative addressing ===== | ===== Absolute and Relative addressing ===== |
| |
| In all previous examples, the addresses were specified as the values which represent the **absolute** memory location. The resulting address (even calculated as the sum of some values) was the memory location counted from the beginning of the memory - address "0". | In all previous examples, the addresses were specified as the values which represent the **absolute** memory location. The resulting address (even calculated as the sum of some values) was the memory location counted from the beginning of the memory - address "0". It is presented in Fig{{ref>addrabsolute}}. |
| | |
| | <figure addrabsolute> |
| | {{ :en:multiasm:cs:addressing_absolute.png?600 |Illustration of absolute addressing of the variable}} |
| | <caption>Illustration of absolute addressing of the variable</caption> |
| | </figure> |
| |
| Absolute addressing is simple and doesn't require any additional calculations by the processor. It is often used in embedded systems, where the software is installed and configured by the designer and the location of programs does not change. | Absolute addressing is simple and doesn't require any additional calculations by the processor. It is often used in embedded systems, where the software is installed and configured by the designer and the location of programs does not change. |
| Absolute addressing is very hard to use in general-purpose operating systems like Linux or Windows where the user can start a variety of different programs, and their placement in the memory differs every time they're loaded and executed. Much more useful is the **relative addressing** where operands are specified as differences from memory location and some known value which can be easily modified and accessed. Often the operands are provided relative to the Instruction Pointer which allows the program to be loaded at any address in the address space, but the distance between the currently executed instruction and the location of the data it wants to reach is always the same. This is the default addressing mode in the Windows operating system working on x64 machines. | Absolute addressing is very hard to use in general-purpose operating systems like Linux or Windows where the user can start a variety of different programs, and their placement in the memory differs every time they're loaded and executed. Much more useful is the **relative addressing** where operands are specified as differences from memory location and some known value which can be easily modified and accessed. Often the operands are provided relative to the Instruction Pointer which allows the program to be loaded at any address in the address space, but the distance between the currently executed instruction and the location of the data it wants to reach is always the same. This is the default addressing mode in the Windows operating system working on x64 machines. It is illustrated in Fig{{ref>addrrelative}}. |
| | |
| | <figure addrrelative> |
| | {{ :en:multiasm:cs:addressing_relative.png?600 |Illustration of IP relative addressing of the variable}} |
| | <caption>Illustration of IP relative addressing of the variable</caption> |
| | </figure> |
| |
| Relative addressing is also implemented in many jump, branch or loop instructions. | Relative addressing is also implemented in many jump, branch or loop instructions. |
