From 151f6c80ea7bd2747736a76308e0366264b92087 Mon Sep 17 00:00:00 2001
From: Peter Gerwinski <peter.gerwinski@hs-bochum.de>
Date: Sun, 4 Jun 2023 22:31:31 +0200
Subject: [PATCH] Notizen und Beispiele 1.6.2023

---
 20230601/ad-20230601.txt | 22 +++++++++++++++++++-
 20230601/binary-01.c     | 18 ++++++++++++++++
 20230601/binary-02.c     | 22 ++++++++++++++++++++
 20230601/binary-03.c     | 22 ++++++++++++++++++++
 20230601/binexp-01.c     | 26 +++++++++++++++++++++++
 20230601/binexp-02.c     | 25 ++++++++++++++++++++++
 20230601/binexp-03.c     | 27 ++++++++++++++++++++++++
 20230601/longadd-01.c    |  6 ++++++
 20230601/longadd-01.s    | 14 +++++++++++++
 20230601/longadd-02.c    |  6 ++++++
 20230601/longadd-02.s    | 16 ++++++++++++++
 20230601/longadd-02.s32  | 25 ++++++++++++++++++++++
 20230601/longadd-03.c    | 16 ++++++++++++++
 20230601/longadd-04.c    | 29 ++++++++++++++++++++++++++
 20230601/longadd-05.c    | 35 +++++++++++++++++++++++++++++++
 20230601/longadd-06.c    | 29 ++++++++++++++++++++++++++
 20230601/longadd-07.c    | 33 +++++++++++++++++++++++++++++
 20230601/longadd-08.c    | 29 ++++++++++++++++++++++++++
 20230601/longadd-09.c    | 29 ++++++++++++++++++++++++++
 20230601/longadd-10.c    | 33 +++++++++++++++++++++++++++++
 20230601/longmul-02.c    |  6 ++++++
 20230601/sum-05-arm.s    | 45 ++++++++++++++++++++++++++++++++++++++++
 20230601/sum-06.s        | 23 ++++++++++++++++++++
 20230601/sum-07-arm.s    | 45 ++++++++++++++++++++++++++++++++++++++++
 20230601/sum-08.s        | 18 ++++++++++++++++
 20230601/sum-09.s        | 18 ++++++++++++++++
 26 files changed, 616 insertions(+), 1 deletion(-)
 create mode 100644 20230601/binary-01.c
 create mode 100644 20230601/binary-02.c
 create mode 100644 20230601/binary-03.c
 create mode 100644 20230601/binexp-01.c
 create mode 100644 20230601/binexp-02.c
 create mode 100644 20230601/binexp-03.c
 create mode 100644 20230601/longadd-01.c
 create mode 100644 20230601/longadd-01.s
 create mode 100644 20230601/longadd-02.c
 create mode 100644 20230601/longadd-02.s
 create mode 100644 20230601/longadd-02.s32
 create mode 100644 20230601/longadd-03.c
 create mode 100644 20230601/longadd-04.c
 create mode 100644 20230601/longadd-05.c
 create mode 100644 20230601/longadd-06.c
 create mode 100644 20230601/longadd-07.c
 create mode 100644 20230601/longadd-08.c
 create mode 100644 20230601/longadd-09.c
 create mode 100644 20230601/longadd-10.c
 create mode 100644 20230601/longmul-02.c
 create mode 100644 20230601/sum-05-arm.s
 create mode 100644 20230601/sum-06.s
 create mode 100644 20230601/sum-07-arm.s
 create mode 100644 20230601/sum-08.s
 create mode 100644 20230601/sum-09.s

diff --git a/20230601/ad-20230601.txt b/20230601/ad-20230601.txt
index 55b8ebb..8469a71 100644
--- a/20230601/ad-20230601.txt
+++ b/20230601/ad-20230601.txt
@@ -13,6 +13,7 @@ heute:
    der Treibhausgasemissionen des Pendelverkehrs für die Treibhausgasbilanz der
    Hochschule Bochum. Zum anderen soll die Bekanntheit und Nutzung bestehender
    Mobilitätsangebote abgefragt werden, die die BO klimafreundlicher gestalten.
+--> https://befragung.hs-bochum.de/evasys/online.php?p=LU2AL
 
 RSA, 25.05.2023, 16:20:49
 ~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -74,5 +75,24 @@ als in einer Schleife fortwährend zu multiplizieren?
 
 Aufgabe:
  (a) Gegeben zwei Zahlen b und e (vom Typ int).
-     Berechnen Sie b^3 mittels binärer Exponentiation.
+     Berechnen Sie b^e mittels binärer Exponentiation.
  (b) Dasselbe modulo einer dritten Zahl n (vom Typ int).
+
+Lösung: siehe binexp-*.c 
+
+Addition langer Zahlen, 01.06.2023, 17:37:20
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Siehe: longadd-*.c, longadd-*.s, sum-*.s
+
+Das Addieren mit Übertrag ("carry") ist in Assembler-Sprache einfacher(!)
+als in C.
+
+Addieren mit Übertrag in C mit der GNU Compiler Collection (GCC):
+https://gcc.gnu.org/onlinedocs/gcc/Integer-Overflow-Builtins.html
+
+Neue Aufgabe: Addieren beliebig langer Zahlen. Siehe: longadd-10.c
+
+Hinweis für die Initialisierung langer Zahlen:
+Um einen String mit einer Dezimalzahl in eine lange Zahl umzuwandeln,
+braucht man bereits funktionierende Langzahlarithmetik.
+Bei Hexadezimalzahlen kann man jeweils eine Hex-Ziffer in 4 Bit umwandeln.
diff --git a/20230601/binary-01.c b/20230601/binary-01.c
new file mode 100644
index 0000000..3e5ef72
--- /dev/null
+++ b/20230601/binary-01.c
@@ -0,0 +1,18 @@
+#include <stdio.h>
+#include <stdint.h>
+
+void print_binary (uint32_t a)
+{
+  uint32_t mask = 0x80000000;  /* binär: Eine 1, 31 Nullen */
+  if (a & mask)
+    printf ("1");
+  else
+    printf ("0");
+  printf ("\n");
+}
+
+int main (void)
+{
+  print_binary (42);  /* binär: 101010 */
+  return 0;
+}
diff --git a/20230601/binary-02.c b/20230601/binary-02.c
new file mode 100644
index 0000000..74e0d42
--- /dev/null
+++ b/20230601/binary-02.c
@@ -0,0 +1,22 @@
+#include <stdio.h>
+#include <stdint.h>
+
+void print_binary (uint32_t a)
+{
+  uint32_t mask = 0x80000000;  /* binär: Eine 1, 31 Nullen */
+  while (mask)
+    {
+      if (a & mask)
+        printf ("1");
+      else
+        printf ("0");
+      mask <<= 1;  /* falsche Richtung */
+    }
+  printf ("\n");
+}
+
+int main (void)
+{
+  print_binary (42);  /* binär: 101010 */
+  return 0;
+}
diff --git a/20230601/binary-03.c b/20230601/binary-03.c
new file mode 100644
index 0000000..b56d0f0
--- /dev/null
+++ b/20230601/binary-03.c
@@ -0,0 +1,22 @@
+#include <stdio.h>
+#include <stdint.h>
+
+void print_binary (uint32_t a)
+{
+  uint32_t mask = 0x80000000;  /* binär: Eine 1, 31 Nullen */
+  while (mask)
+    {
+      if (a & mask)
+        printf ("1");
+      else
+        printf ("0");
+      mask >>= 1;
+    }
+  printf ("\n");
+}
+
+int main (void)
+{
+  print_binary (42);  /* binär: 101010 */
+  return 0;
+}
diff --git a/20230601/binexp-01.c b/20230601/binexp-01.c
new file mode 100644
index 0000000..37ffe82
--- /dev/null
+++ b/20230601/binexp-01.c
@@ -0,0 +1,26 @@
+#include <stdio.h>
+#include <inttypes.h>
+
+int bin_exp(int b, int e){
+	int ret = 1;
+	uint32_t i = 0x80000000;
+	while (!(i & e)) i >>= 1;
+	while (i > 0) {
+		ret = ret * ret;
+		printf("Q = %d\n", ret);
+		if(e & i){
+			ret = ret * b;
+		}
+		printf("M = %d\n", ret);
+		i >>= 1;
+	}
+	return ret;
+}
+
+int main (void){
+	int b = 2;
+	int e = 18;
+	printf("%d\n", bin_exp(b, e));
+
+	return 0;
+}
diff --git a/20230601/binexp-02.c b/20230601/binexp-02.c
new file mode 100644
index 0000000..65f23c9
--- /dev/null
+++ b/20230601/binexp-02.c
@@ -0,0 +1,25 @@
+#include <stdio.h>
+#include <stdint.h>
+
+int bin_exp (int b, int e)
+{
+  int res = 1;
+  int pot = b;
+  uint8_t mask = 1;
+  while (mask <= e)
+    {
+      if (e & mask)
+        res *= pot;
+      pot *= pot;
+      mask <<= 1;
+    }
+  return res;
+}
+
+int main (void)
+{
+  int b = 2;
+  int e = 18;
+  printf ("%d hoch %d = %d\n", b, e, bin_exp (b, e));
+  return 0;
+}
diff --git a/20230601/binexp-03.c b/20230601/binexp-03.c
new file mode 100644
index 0000000..2a0a937
--- /dev/null
+++ b/20230601/binexp-03.c
@@ -0,0 +1,27 @@
+#include <stdio.h>
+#include <inttypes.h>
+
+int bin_exp(int b, int e, int n){
+	int ret = 1;
+	uint32_t i = 0x80000000;
+	while (!(i & e)) i >>= 1;
+	while (i > 0) {
+		ret = (ret * ret) % n;
+		printf("Q = %d\n", ret);
+		if(e & i){
+			ret = (ret * b) % n;
+		}
+		printf("M = %d\n", ret);
+		i >>= 1;
+	}
+	return ret;
+}
+
+int main (void){
+	int b = 2;
+	int e = 18;
+        int n = 42;
+	printf("%d\n", bin_exp(b, e, n));
+
+	return 0;
+}
diff --git a/20230601/longadd-01.c b/20230601/longadd-01.c
new file mode 100644
index 0000000..6fc0b3e
--- /dev/null
+++ b/20230601/longadd-01.c
@@ -0,0 +1,6 @@
+#include <stdint.h>
+
+uint64_t sum (uint32_t a, uint32_t b)
+{
+  return a + b;
+}
diff --git a/20230601/longadd-01.s b/20230601/longadd-01.s
new file mode 100644
index 0000000..692f234
--- /dev/null
+++ b/20230601/longadd-01.s
@@ -0,0 +1,14 @@
+	.file	"longadd-01.c"
+	.text
+	.globl	sum
+	.type	sum, @function
+sum:
+.LFB0:
+	.cfi_startproc
+	leal	(%rdi,%rsi), %eax
+	ret
+	.cfi_endproc
+.LFE0:
+	.size	sum, .-sum
+	.ident	"GCC: (Debian 8.3.0-6) 8.3.0"
+	.section	.note.GNU-stack,"",@progbits
diff --git a/20230601/longadd-02.c b/20230601/longadd-02.c
new file mode 100644
index 0000000..a808650
--- /dev/null
+++ b/20230601/longadd-02.c
@@ -0,0 +1,6 @@
+#include <stdint.h>
+
+uint64_t sum (uint32_t a, uint32_t b)
+{
+  return (uint64_t) a + (uint64_t) b;
+}
diff --git a/20230601/longadd-02.s b/20230601/longadd-02.s
new file mode 100644
index 0000000..8844e2b
--- /dev/null
+++ b/20230601/longadd-02.s
@@ -0,0 +1,16 @@
+	.file	"longadd-02.c"
+	.text
+	.globl	sum
+	.type	sum, @function
+sum:
+.LFB0:
+	.cfi_startproc
+	movl	%edi, %edi
+	movl	%esi, %eax
+	addq	%rdi, %rax
+	ret
+	.cfi_endproc
+.LFE0:
+	.size	sum, .-sum
+	.ident	"GCC: (Debian 8.3.0-6) 8.3.0"
+	.section	.note.GNU-stack,"",@progbits
diff --git a/20230601/longadd-02.s32 b/20230601/longadd-02.s32
new file mode 100644
index 0000000..0d65561
--- /dev/null
+++ b/20230601/longadd-02.s32
@@ -0,0 +1,25 @@
+	.file	"longadd-02.c"
+	.text
+	.globl	sum
+	.type	sum, @function
+sum:
+.LFB0:
+	.cfi_startproc
+	pushl	%ebx                 ; (sichere das ebx-Register auf den Stack)
+	.cfi_def_cfa_offset 8
+	.cfi_offset 3, -8
+	movl	8(%esp), %eax        ; lade den Parameter a ins eax-Register (l = 32 Bit)
+	movl	$0, %edx             ; lade eine 0 ins edx-Register (32 Bit)
+	movl	12(%esp), %ecx       ; lade den Parameter b ins ecx-Register (32 Bit)
+	movl	$0, %ebx             ; lade eine 0 ins ebx-Register (32 Bit)
+	addl	%ecx, %eax           ; addiere: eax += ecx. Merke den Übertrag im Carry-Bit.
+	adcl	%ebx, %edx           ; addiere: edx += ebx + Carry-Bit ("add with carry")
+	popl	%ebx                 ; (hole den auf dem Stack gesicherten Wert zurück ins ebx-Register)
+	.cfi_restore 3
+	.cfi_def_cfa_offset 4
+	ret                          ; Rücksprung aus der Funktion. Der Rückgabewert (64 Bit)
+	.cfi_endproc                 ; liegt in den Registern rax/rdx (untere/obere 32 Bit)
+.LFE0:
+	.size	sum, .-sum
+	.ident	"GCC: (Debian 8.3.0-6) 8.3.0"
+	.section	.note.GNU-stack,"",@progbits
diff --git a/20230601/longadd-03.c b/20230601/longadd-03.c
new file mode 100644
index 0000000..481f888
--- /dev/null
+++ b/20230601/longadd-03.c
@@ -0,0 +1,16 @@
+#include <stdio.h>
+#include <stdint.h>
+
+uint64_t sum (uint32_t a, uint32_t b)
+{
+  return (uint64_t) a + (uint64_t) b;
+}
+
+int main (void)
+{
+  uint32_t a = 0x80000007;
+  uint32_t b = 0x80000014;
+  uint64_t c = sum (a, b);
+  printf ("0x%08x + 0x%08x = 0x%016lx\n", a, b, c);
+  return 0;
+}
diff --git a/20230601/longadd-04.c b/20230601/longadd-04.c
new file mode 100644
index 0000000..eb7de1a
--- /dev/null
+++ b/20230601/longadd-04.c
@@ -0,0 +1,29 @@
+#include <stdio.h>
+#include <stdint.h>
+
+typedef uint32_t uint128_t[4];
+
+extern void sum (uint128_t a, uint128_t b, uint128_t result);
+
+void print128 (uint128_t a)
+{
+  printf ("0x%08x 0x%08x 0x%08x 0x%08x", a[0], a[1], a[2], a[3]);
+}
+
+int main (void)
+{
+  uint128_t a = { 0, 0x80000007, 0x12345678, 0x87654321 };
+  uint128_t b = { 0, 0x80000014, 0x98765432, 0x87654321 };
+  /* -------------1-----------------------1------------ */
+  /*              1, 0x0000001b, 0xaaaaaaab, 0x0eca8642 */
+  uint128_t c;
+  sum (a, b, c);
+  printf ("  ");
+  print128 (a);
+  printf ("\n+ ");
+  print128 (b);
+  printf ("\n= ");
+  print128 (c);
+  printf ("\n");
+  return 0;
+}
diff --git a/20230601/longadd-05.c b/20230601/longadd-05.c
new file mode 100644
index 0000000..e0b3bff
--- /dev/null
+++ b/20230601/longadd-05.c
@@ -0,0 +1,35 @@
+#include <stdio.h>
+#include <stdint.h>
+
+typedef uint32_t uint128_t[4];
+
+void sum (uint128_t a, uint128_t b, uint128_t result)
+{
+  result[3] = a[3] + b[3];  /* Fehler: Übertrag ("carry") nicht berücksichtigt! */
+  result[2] = a[2] + b[2];
+  result[1] = a[1] + b[1];
+  result[0] = a[0] + b[0];
+}
+
+void print128 (uint128_t a)
+{
+  printf ("0x%08x 0x%08x 0x%08x 0x%08x", a[0], a[1], a[2], a[3]);
+}
+
+int main (void)
+{
+  uint128_t a = { 0, 0x80000007, 0x12345678, 0x87654321 };
+  uint128_t b = { 0, 0x80000014, 0x98765432, 0x87654321 };
+  /* -------------1-----------------------1------------ */
+  /*              1, 0x0000001b, 0xaaaaaaab, 0x0eca8642 */
+  uint128_t c;
+  sum (a, b, c);
+  printf ("  ");
+  print128 (a);
+  printf ("\n+ ");
+  print128 (b);
+  printf ("\n= ");
+  print128 (c);
+  printf ("\n");
+  return 0;
+}
diff --git a/20230601/longadd-06.c b/20230601/longadd-06.c
new file mode 100644
index 0000000..eb7de1a
--- /dev/null
+++ b/20230601/longadd-06.c
@@ -0,0 +1,29 @@
+#include <stdio.h>
+#include <stdint.h>
+
+typedef uint32_t uint128_t[4];
+
+extern void sum (uint128_t a, uint128_t b, uint128_t result);
+
+void print128 (uint128_t a)
+{
+  printf ("0x%08x 0x%08x 0x%08x 0x%08x", a[0], a[1], a[2], a[3]);
+}
+
+int main (void)
+{
+  uint128_t a = { 0, 0x80000007, 0x12345678, 0x87654321 };
+  uint128_t b = { 0, 0x80000014, 0x98765432, 0x87654321 };
+  /* -------------1-----------------------1------------ */
+  /*              1, 0x0000001b, 0xaaaaaaab, 0x0eca8642 */
+  uint128_t c;
+  sum (a, b, c);
+  printf ("  ");
+  print128 (a);
+  printf ("\n+ ");
+  print128 (b);
+  printf ("\n= ");
+  print128 (c);
+  printf ("\n");
+  return 0;
+}
diff --git a/20230601/longadd-07.c b/20230601/longadd-07.c
new file mode 100644
index 0000000..003b377
--- /dev/null
+++ b/20230601/longadd-07.c
@@ -0,0 +1,33 @@
+#include <stdio.h>
+#include <stdint.h>
+
+typedef uint64_t uint128_t[2];
+
+void sum (uint128_t a, uint128_t b, uint128_t result)
+{
+  result[1] = a[1] + b[1];  /* Fehler: Übertrag fehlt! */
+  result[0] = a[0] + b[0];
+}
+
+void print128 (uint128_t a)
+{
+  printf ("0x%08lx 0x%08lx 0x%08lx 0x%08lx", a[0] >> 32, a[0] & 0xffffffff, a[1] >> 32, a[1] & 0xffffffff);
+}
+
+int main (void)
+{
+  uint128_t a = { 0x0000000080000007, 0x1234567887654321 };
+  uint128_t b = { 0x0000000080000014, 0x9876543287654321 };
+  /* ----------------------1-------------------1-------- */
+  /*              0x000000010000001b, 0xaaaaaaab0eca8642 */
+  uint128_t c;
+  sum (a, b, c);
+  printf ("  ");
+  print128 (a);
+  printf ("\n+ ");
+  print128 (b);
+  printf ("\n= ");  /* Vorsicht, Falle: Die Ausgabe ist korrekt, weil in unserem Beispiel    */
+  print128 (c);     /* der Übertrag nur jeweils innerhalb einer 64-Bit-"Ziffer" stattfindet, */
+  printf ("\n");    /* aber nicht von der rechten "Ziffer" zur linken.                       */
+  return 0;
+}
diff --git a/20230601/longadd-08.c b/20230601/longadd-08.c
new file mode 100644
index 0000000..88c19be
--- /dev/null
+++ b/20230601/longadd-08.c
@@ -0,0 +1,29 @@
+#include <stdio.h>
+#include <stdint.h>
+
+typedef uint64_t uint128_t[2];
+
+extern void sum (uint128_t a, uint128_t b, uint128_t result);
+
+void print128 (uint128_t a)
+{
+  printf ("0x%08lx 0x%08lx 0x%08lx 0x%08lx", a[0] >> 32, a[0] & 0xffffffff, a[1] >> 32, a[1] & 0xffffffff);
+}
+
+int main (void)
+{
+  uint128_t a = { 0x0000000080000007, 0x1234567887654321 };
+  uint128_t b = { 0x0000000080000014, 0x9876543287654321 };
+  /* ----------------------1-------------------1-------- */
+  /*              0x000000010000001b, 0xaaaaaaab0eca8642 */
+  uint128_t c;
+  sum (a, b, c);
+  printf ("  ");
+  print128 (a);
+  printf ("\n+ ");
+  print128 (b);
+  printf ("\n= ");  /* Der Fehler von vorhin ist jetzt behoben. Das sehen wir aber nicht, */
+  print128 (c);     /* weil das Beispiel auf das Auftreten dieses Fehlers nicht testet.   */
+  printf ("\n");
+  return 0;
+}
diff --git a/20230601/longadd-09.c b/20230601/longadd-09.c
new file mode 100644
index 0000000..380da2f
--- /dev/null
+++ b/20230601/longadd-09.c
@@ -0,0 +1,29 @@
+include <stdio.h>
+#include <stdint.h>
+
+typedef uint64_t uint128_t[2];
+
+extern void sum (uint128_t a, uint128_t b, uint128_t result);
+
+void print128 (uint128_t a)
+{
+  printf ("0x%08lx 0x%08lx 0x%08lx 0x%08lx", a[0] >> 32, a[0] & 0xffffffff, a[1] >> 32, a[1] & 0xffffffff);
+}
+
+int main (void)
+{
+  uint128_t a = { 0x0000000080000007, 0x1234567887654321 };
+  uint128_t b = { 0x0000000080000014, 0xf876543287654321 };
+  /* ----------------------1-------1-----------1-------- */
+  /*              0x000000010000001c, 0x0aaaaaab0eca8642 */
+  uint128_t c;
+  sum (a, b, c);
+  printf ("  ");
+  print128 (a);
+  printf ("\n+ ");
+  print128 (b);
+  printf ("\n= ");  /* Jetzt ist die Ausgabe korrekt, weil die Funktion korrekt rechnet. */
+  print128 (c);
+  printf ("\n");
+  return 0;
+}
diff --git a/20230601/longadd-10.c b/20230601/longadd-10.c
new file mode 100644
index 0000000..d21d20b
--- /dev/null
+++ b/20230601/longadd-10.c
@@ -0,0 +1,33 @@
+#include <stdio.h>
+#include <stdint.h>
+
+#define N 42
+
+/* 42 Zahlen à 64 Bit = 2688-Bit-Zahlen */
+
+typedef uint64_t uintN_t[N];
+
+extern void sum (uintN_t a, uintN_t b, uintN_t result);  /* Übungsaufgabe */
+
+/* Hinweis: Die bisherigen Beispiele verwendeten Big-Endian. Litte-Endian ist besser. */
+
+void printN (uintN_t a)
+{
+  /* Übungsaufgabe */
+}
+
+int main (void)
+{
+  uintN_t a;  /* Übungsaufgabe: Funktion(en) schreiben, um die Zahlen irgendwie */
+  uintN_t b;  /* sinnvoll zu initialisieren, z.B. durch String mit Hex-Ziffern  */
+  uintN_t c;
+  sum (a, b, c);
+  printf ("  ");
+  printN (a);
+  printf ("\n+ ");
+  printN (b);
+  printf ("\n= ");
+  printN (c);
+  printf ("\n");
+  return 0;
+}
diff --git a/20230601/longmul-02.c b/20230601/longmul-02.c
new file mode 100644
index 0000000..b6e992b
--- /dev/null
+++ b/20230601/longmul-02.c
@@ -0,0 +1,6 @@
+#include <stdint.h>
+
+uint64_t product (uint32_t a, uint32_t b)
+{
+  return (uint64_t) a * (uint64_t) b;
+}
diff --git a/20230601/sum-05-arm.s b/20230601/sum-05-arm.s
new file mode 100644
index 0000000..d86b855
--- /dev/null
+++ b/20230601/sum-05-arm.s
@@ -0,0 +1,45 @@
+	.arch armv7-a
+	.eabi_attribute 28, 1
+	.eabi_attribute 20, 1
+	.eabi_attribute 21, 1
+	.eabi_attribute 23, 3
+	.eabi_attribute 24, 1
+	.eabi_attribute 25, 1
+	.eabi_attribute 26, 2
+	.eabi_attribute 30, 1
+	.eabi_attribute 34, 1
+	.eabi_attribute 18, 4
+	.file	"longadd-05.c"
+	.text
+	.align	1
+	.global	sum
+	.arch armv7-a
+	.syntax unified
+	.thumb
+	.thumb_func
+	.fpu vfpv3-d16
+	.type	sum, %function
+sum:
+	@ args = 0, pretend = 0, frame = 0
+	@ frame_needed = 0, uses_anonymous_args = 0
+	@ link register save eliminated.
+	push	{r4}
+	ldr	r3, [r0, #12]  # r3 = a[3]
+	ldr	r4, [r1, #12]  # r4 = b[3]        # void sum (uint128_t a, uint128_t b, uint128_t result)
+	add	r3, r3, r4     # r3 += r4         # {
+	str	r3, [r2, #12]  # result[3] = r3   #   result[3] = a[3] + b[3];  /* Fehler: Übertrag ("carry") nicht berücksichtigt! */
+	ldr	r3, [r0, #8]                      #   result[2] = a[2] + b[2];
+	ldr	r4, [r1, #8]                      #   result[1] = a[1] + b[1];
+	add	r3, r3, r4     # durch "adc"      #   result[0] = a[0] + b[0];
+	str	r3, [r2, #8]   # ersetzen, dann   # }
+	ldr	r3, [r0, #4]   # mit Übertrag
+	ldr	r4, [r1, #4]
+	add	r3, r3, r4
+	str	r3, [r2, #4]
+	ldr	r3, [r0]
+	ldr	r1, [r1]
+	add	r3, r3, r1
+	str	r3, [r2]
+	ldr	r4, [sp], #4
+	bx	lr
+	.size	sum, .-sum
diff --git a/20230601/sum-06.s b/20230601/sum-06.s
new file mode 100644
index 0000000..7693fe3
--- /dev/null
+++ b/20230601/sum-06.s
@@ -0,0 +1,23 @@
+	.text
+	.globl	sum
+	.type	sum, @function
+sum:
+.LFB11:
+	.cfi_startproc
+	movl	12(%rsi), %eax
+	addl	12(%rdi), %eax
+	movl	%eax, 12(%rdx)
+	movl	8(%rsi), %eax
+	adcl	8(%rdi), %eax    # adc statt add: Übertrag ("carry") berücksichtigen
+	movl	%eax, 8(%rdx)
+	movl	4(%rsi), %eax
+	adcl	4(%rdi), %eax    # adc statt add: Übertrag ("carry") berücksichtigen
+	movl	%eax, 4(%rdx)
+	movl	(%rsi), %eax
+	adcl	(%rdi), %eax     # adc statt add: Übertrag ("carry") berücksichtigen
+	movl	%eax, (%rdx)
+	ret
+	.cfi_endproc
+.LFE11:
+	.size	sum, .-sum
+	.section	.rodata.str1.1,"aMS",@progbits,1
diff --git a/20230601/sum-07-arm.s b/20230601/sum-07-arm.s
new file mode 100644
index 0000000..045ad3a
--- /dev/null
+++ b/20230601/sum-07-arm.s
@@ -0,0 +1,45 @@
+	.arch armv7-a
+	.eabi_attribute 28, 1
+	.eabi_attribute 20, 1
+	.eabi_attribute 21, 1
+	.eabi_attribute 23, 3
+	.eabi_attribute 24, 1
+	.eabi_attribute 25, 1
+	.eabi_attribute 26, 2
+	.eabi_attribute 30, 1
+	.eabi_attribute 34, 1
+	.eabi_attribute 18, 4
+	.file	"longadd-07.c"
+	.text
+	.align	1
+	.global	sum
+	.arch armv7-a
+	.syntax unified
+	.thumb
+	.thumb_func
+	.fpu vfpv3-d16
+	.type	sum, %function
+sum:
+	@ args = 0, pretend = 0, frame = 0
+	@ frame_needed = 0, uses_anonymous_args = 0
+	@ link register save eliminated.
+	push	{r4, r5, r6}
+	ldr	r3, [r0, #8]
+	ldr	r4, [r0, #12]
+	ldr	r5, [r1, #8]
+	ldr	r6, [r1, #12]
+	adds	r3, r3, r5
+	adc	r4, r6, r4
+	str	r3, [r2, #8]
+	str	r4, [r2, #12]
+	ldr	r3, [r0]
+	ldr	r0, [r0, #4]
+	ldr	r4, [r1]
+	ldr	r1, [r1, #4]
+	adds	r3, r3, r4
+	adc	r0, r1, r0
+	str	r3, [r2]
+	str	r0, [r2, #4]
+	pop	{r4, r5, r6}
+	bx	lr
+	.size	sum, .-sum
diff --git a/20230601/sum-08.s b/20230601/sum-08.s
new file mode 100644
index 0000000..7370fe6
--- /dev/null
+++ b/20230601/sum-08.s
@@ -0,0 +1,18 @@
+	.file	"longadd-07.c"
+	.text
+	.globl	sum
+	.type	sum, @function
+sum:
+.LFB11:
+	.cfi_startproc
+	movq	8(%rsi), %rax
+	addq	8(%rdi), %rax
+	movq	%rax, 8(%rdx)
+	movq	(%rsi), %rax
+	adcq	(%rdi), %rax     # adc statt add: Übertrag ("carry") berücksichtigen
+	movq	%rax, (%rdx)
+	ret
+	.cfi_endproc
+.LFE11:
+	.size	sum, .-sum
+	.section	.rodata.str1.8,"aMS",@progbits,1
diff --git a/20230601/sum-09.s b/20230601/sum-09.s
new file mode 100644
index 0000000..7370fe6
--- /dev/null
+++ b/20230601/sum-09.s
@@ -0,0 +1,18 @@
+	.file	"longadd-07.c"
+	.text
+	.globl	sum
+	.type	sum, @function
+sum:
+.LFB11:
+	.cfi_startproc
+	movq	8(%rsi), %rax
+	addq	8(%rdi), %rax
+	movq	%rax, 8(%rdx)
+	movq	(%rsi), %rax
+	adcq	(%rdi), %rax     # adc statt add: Übertrag ("carry") berücksichtigen
+	movq	%rax, (%rdx)
+	ret
+	.cfi_endproc
+.LFE11:
+	.size	sum, .-sum
+	.section	.rodata.str1.8,"aMS",@progbits,1
-- 
GitLab