User contributions for Bfh-sts

Jump to navigation Jump to search
Search for contributionsExpandCollapse
⧼contribs-top⧽
⧼contribs-date⧽
(newest | oldest) View (newer 50 | ) (20 | 50 | 100 | 250 | 500)

27 October 2025

20 October 2025

  • 14:5714:57, 20 October 2025 diff hist +4,754‎ N Exercises - 02 Kontrollaufgaben ‎ Created page with "= Kontrollaufgaben Aussagenlogik Teil 2 = ''Achtung: detaillierte Lösungswege mit Zwischenresultaten werden erwartet. Ohne klar ersichtlichen Lösungsweg bzw. Begründung gibt es keine Punkte.'' == Aufgabe 1 == Max wird mit hohem Fieber und ausgeprägtem Gliederschmerzen in das Spital eingeliefert. Dr. House diskutiert die Diagnose mit einer Kollegin. * Dr. House: „Wenn der Patient Fieber hat, handelt es sich um Grippe oder Erkältung.” * Cameron: „Wenn er kein..." current
  • 14:5714:57, 20 October 2025 diff hist +2,314‎ N Exercises - 01 Kontrollaufgaben ‎ Created page with "= Kontrollaufgaben = == Aufgabe 1 == Wenden Sie in den folgenden logischen Ausdrücken die Verneinung auf die Einzelaussagen an: (a) <syntaxhighlight lang='text' inline>¬(¬A ᐯ B)</syntaxhighlight> (b) <syntaxhighlight lang='text' inline>¬(A ⇒ (B ⇒ C))</syntaxhighlight> === Aufgabe 1 - Lösung === a) <syntaxhighlight lang='text'> ¬(¬A ᐯ B) ≡ A ᐱ ¬B (7,10b) </syntaxhighlight> b) <syntaxhighlight lang='text'> (A => (B => C)) ≡ ¬(¬A ᐯ (B => C))..." current
  • 14:5614:56, 20 October 2025 diff hist 0‎ Main Page ‎No edit summary current
  • 14:5214:52, 20 October 2025 diff hist +17‎ Category:Numeral Systems ‎No edit summary current
  • 14:4914:49, 20 October 2025 diff hist +2,905‎ N Hands-on: Debugger Exercise for Register Parts (AX/BX/CX) ‎ Created page with "= Hands-on: Debugger Exercise for Register Parts (AX, BX, CX) = This exercise helps you understand how register hierarchies and partial register operations work in x86-64 assembly. It focuses on how smaller register portions (8-bit and 16-bit) affect and reflect values in their parent registers. == Background == <syntaxhighlight lang='text'> x86-64 registers are divided into accessible parts: | Register (64-bit) | 32-bit | 16-bit | 8-bit High | 8-bit Low | |----------..." current
  • 14:4814:48, 20 October 2025 diff hist +3,547‎ N Linux x86-64 Syscalls: syscall, Registers, sys write, sys exit ‎ Created page with "= Linux x86-64 Syscalls (syscall, Registers, sys_write, sys_exit) = System calls (syscalls) allow a program to interact directly with the operating system. They provide controlled access to privileged functions such as printing to the screen, reading files, or terminating the program. == What Is a Syscall? == In user mode, a program cannot directly access hardware or kernel resources. To perform privileged operations, it must **request** the kernel to do so on its b..." current
  • 14:4814:48, 20 October 2025 diff hist +3,072‎ N Strings in Assembly: Buffers, Length with $ and equ, Concatenation ‎ Created page with "= Strings in Assembly (Buffers, Length with $, equ, Concatenation) = Strings in assembly language are simply sequences of bytes in memory. Each byte may represent a character depending on the encoding (commonly ASCII or UTF-8). == What Is a String in Assembly? == A string is not a special data type — it is an array of bytes. The assembler does not automatically track the string’s length or add an end marker. Example: SECTION .data Msg: db "Eat at Joe’s!", 10..." current
  • 14:4814:48, 20 October 2025 diff hist +2,210‎ N Data Definition Directives: db, dw, dd, dq, equ ‎ Created page with "= Data Definition Directives (db, dw, dd, dq, equ) = Assembly language provides directives to define data in memory. These specify how many bytes are allocated and what values they hold. == Overview == Data definition directives do not generate executable code — they reserve and optionally initialize memory. They are primarily used in the **.data** and **.bss** sections. == Common Directives == <syntaxhighlight lang='text'> | Directive | Meaning | Size..." current
  • 14:4814:48, 20 October 2025 diff hist +2,645‎ N Program Structure: .data, .bss, .text, global start ‎ Created page with "= Program Structure (.data, .bss, .text, global _start) = Assembly programs are organized into well-defined sections that separate code and data. Understanding this structure is crucial for writing, linking, and debugging NASM programs. == Overview == A typical x86-64 assembly program for GNU/Linux contains: * A **comment block** describing metadata * A **.data** section for initialized data * A **.bss** section for uninitialized data * A **.text** section for executabl..." current
  • 14:4714:47, 20 October 2025 diff hist +3,097‎ N Multiplication and Division (mul, imul, div, idiv) ‎ Created page with "= Multiplication and Division (mul, imul, div, idiv) = This page explains how integer multiplication and division work in x86-64 assembly. It covers unsigned and signed arithmetic, implicit operands, and register usage. == Multiplication instructions == There are two main multiplication instructions: * **mul** — for unsigned multiplication * **imul** — for signed multiplication Syntax examples: mul rbx imul rbx Both multiply the accumulator register (a-regist..." current
  • 14:4714:47, 20 October 2025 diff hist +2,132‎ N Sign Extension and Negation (movsx, neg) ‎ Created page with "= Sign Extension and Negation (movsx, neg) = This page explains how to handle signed numbers of different sizes and how to change their sign in x86-64 assembly. == Copying signed numbers == When using mov to copy signed numbers, the sign bit is not automatically extended to the larger register size. This can lead to incorrect values when moving smaller signed values into larger registers. Example: mov ax, -42 mov bx, ax ; bx = -42 (ok, same size) mov ecx, bx..." current
  • 14:4714:47, 20 October 2025 diff hist +2,009‎ N Signed Integers and Flags (Two’s Complement) ‎ Created page with "= Signed Integers and Flags (Two’s Complement) = This page explains how signed integers are represented in x86 architecture using two’s complement and how arithmetic instructions affect CPU flags. == Unsigned vs signed integers == Unsigned integers represent only positive values. Signed integers represent both positive and negative values using two’s complement. Example with 8 bits: * 00000000₂ = 0 * 00000001₂ = +1 * 01111111₂ = +127 * 11111111₂ = −1..." current
  • 14:4714:47, 20 October 2025 diff hist +1,996‎ N Arithmetic: add, sub, inc, dec ‎ Created page with "= Arithmetic: add, sub, inc, dec = This page explains basic arithmetic instructions in x86-64 assembly language, including addition, subtraction, increment, and decrement. == Overview == Arithmetic instructions modify register or memory contents. Most of them follow this general pattern: instruction destination, source The result is stored in the destination operand. == Addition (add) == Adds the source value to the destination and stores the result in the destinat..." current
  • 14:4614:46, 20 October 2025 diff hist +1,932‎ N Labels and Entry Point ( start) ‎ Created page with "= Labels and Entry Point (_start) = This page explains how labels work in assembly programming and how the program’s entry point is defined. == What are labels == A label is a symbolic name for a memory address. It marks a location in code or data that can be referenced later. Syntax: LabelName: Example: SECTION .data EatMsg: db "Eat at Joe’s" SECTION .text mov rcx, EatMsg ; rcx ← address of the string mov rdx, [EatMsg] ; rdx ← first 8 bytes of the..." current
  • 14:4614:46, 20 October 2025 diff hist +1,996‎ N Memory Operands in Other Instructions (add, etc.) ‎ Created page with "= Arithmetic: add, sub, inc, dec = This page explains basic arithmetic instructions in x86-64 assembly language, including addition, subtraction, increment, and decrement. == Overview == Arithmetic instructions modify register or memory contents. Most of them follow this general pattern: instruction destination, source The result is stored in the destination operand. == Addition (add) == Adds the source value to the destination and stores the result in the destinat..." current
  • 14:4614:46, 20 October 2025 diff hist +2,437‎ N Addressing Modes: Direct, Indirect, Base+Index, Offsets ‎ Created page with "= Addressing Modes: Direct, Indirect, Base+Index, Offsets = This page explains how different addressing modes work in x86-64 assembly and how they apply beyond the mov instruction. == Overview == Addressing modes define how operands are interpreted by the CPU: * **Immediate** – The value is part of the instruction itself. * **Register** – The operand is stored in a CPU register. * **Memory** – The operand is located in RAM, referenced by an address. Understanding..." current
  • 14:4614:46, 20 October 2025 diff hist +2,664‎ N mov Instruction: Registers, Immediates, Memory ‎ Created page with "= mov Instruction: Registers, Immediates, Memory = This page introduces the mov instruction — one of the most fundamental instructions in assembly — and explains the different addressing modes used with it. == The mov instruction == The mov instruction copies (moves) data from one location to another. Syntax: mov destination, source It can copy data: * From one register to another. * From an immediate (constant) value to a register. * From memory to a register (l..." current
  • 14:4614:46, 20 October 2025 diff hist +1,919‎ N Assembly Programming: Overview & Conventions ‎ Created page with "= Assembly Programming: Overview & Conventions = This page introduces x86-64 assembly programming, the syntax conventions used in this course, and the tools involved. == Introduction == Assembly language (ASM) is a low-level programming language that provides direct access to the CPU’s instruction set. Unlike high-level languages, assembly operates on registers, memory addresses, and immediate values. In this course, we use NASM (Netwide Assembler) on GNU/Linux wit..." current
  • 14:4514:45, 20 October 2025 diff hist +1,019‎ N Category:Assembly Programming ‎ Created page with "= Overview = This category covers x86-64 assembly programming with NASM on GNU/Linux: syntax, addressing, arithmetic, data definitions, program structure, strings, and syscalls. == Pages == * Assembly Programming: Overview & Conventions * mov Instruction: Registers, Immediates, Memory * Addressing Modes: Direct, Indirect, Base+Index, Offsets * Memory Operands in Other Instructions (add, etc.) * Labels and Entry Point (_start) * Arithmetic: add, sub..." current
  • 14:4514:45, 20 October 2025 diff hist +2,807‎ N Assembly Playfield: Build, Run & Debug (NASM, LD, GDB) ‎ Created page with "= Assembly Playfield: Build, Run & Debug (NASM, LD, GDB) = This page provides a practical starting point for experimenting with assembly programming under Linux, using NASM for assembling, LD for linking, and GDB for debugging. == The playfield program == To learn assembly, we use a minimal “playfield” — a small skeleton program that runs correctly but does nothing by default. It provides a clean structure that you can modify freely. Basic structure of `playfie..." current
  • 14:4514:45, 20 October 2025 diff hist +2,656‎ N Historical Context: Register Growth & Segment Registers ‎ Created page with "= Historical Context: Register Growth & Segment Registers = This page explains how CPU register design evolved over time and how early architectural choices still influence modern processors. == Register growth over time == The number and width of registers in CPUs have increased dramatically. In the early 1980s, accessing main memory was nearly as fast as using registers, so CPUs could work efficiently with only a few of them. * **1970s:** Typical CPUs had 3–8 gen..." current
(newest | oldest) View (newer 50 | ) (20 | 50 | 100 | 250 | 500)
Retrieved from "https://bsccs.stoney-wiki.com/wiki/Special:Contributions/Bfh-sts"