void crypte(char texte[], int longueur, int cle) {
  for (int i = 0; i < longueur; i++) {
    texte[i] = texte[i] + cle;
  }
}


x86 assembly (clang, -O0):
<crypte>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    114b <crypte+0x4b>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
add    -0x10(%rbp),%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1115 <crypte+0x15>
pop    %rbp
ret

x86 assembly (clang, -O2):
<crypte>:
test   %esi,%esi
jle    122c <crypte+0x12c>
mov    %esi,%r10d
cmp    $0x8,%esi
jae    1117 <crypte+0x17>
xor    %ecx,%ecx
jmp    1220 <crypte+0x120>
movzbl %dl,%r8d
cmp    $0x20,%esi
jae    1127 <crypte+0x27>
xor    %ecx,%ecx
jmp    11e7 <crypte+0xe7>
mov    %r10d,%ecx
and    $0xffffffe0,%ecx
movd   %r8d,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x20(%rcx),%rax
mov    %rax,%r9
shr    $0x5,%r9
add    $0x1,%r9
test   %rax,%rax
je     122d <crypte+0x12d>
mov    %r9,%rax
and    $0xfffffffffffffffe,%rax
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movdqu (%rdi,%rsi,1),%xmm1
movdqu 0x10(%rdi,%rsi,1),%xmm2
movdqu 0x20(%rdi,%rsi,1),%xmm3
movdqu 0x30(%rdi,%rsi,1),%xmm4
paddb  %xmm0,%xmm1
paddb  %xmm0,%xmm2
movdqu %xmm1,(%rdi,%rsi,1)
movdqu %xmm2,0x10(%rdi,%rsi,1)
paddb  %xmm0,%xmm3
paddb  %xmm0,%xmm4
movdqu %xmm3,0x20(%rdi,%rsi,1)
movdqu %xmm4,0x30(%rdi,%rsi,1)
add    $0x40,%rsi
add    $0xfffffffffffffffe,%rax
jne    1170 <crypte+0x70>
test   $0x1,%r9b
je     11dc <crypte+0xdc>
movdqu (%rdi,%rsi,1),%xmm1
movdqu 0x10(%rdi,%rsi,1),%xmm2
paddb  %xmm0,%xmm1
paddb  %xmm0,%xmm2
movdqu %xmm1,(%rdi,%rsi,1)
movdqu %xmm2,0x10(%rdi,%rsi,1)
cmp    %r10,%rcx
je     122c <crypte+0x12c>
test   $0x18,%r10b
je     1220 <crypte+0x120>
mov    %rcx,%rax
mov    %r10d,%ecx
and    $0xfffffff8,%ecx
movd   %r8d,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
xchg   %ax,%ax
movq   (%rdi,%rax,1),%xmm1
paddb  %xmm0,%xmm1
movq   %xmm1,(%rdi,%rax,1)
add    $0x8,%rax
cmp    %rax,%rcx
jne    1200 <crypte+0x100>
cmp    %r10,%rcx
je     122c <crypte+0x12c>
nopl   0x0(%rax)
add    %dl,(%rdi,%rcx,1)
add    $0x1,%rcx
cmp    %rcx,%r10
jne    1220 <crypte+0x120>
ret
xor    %esi,%esi
test   $0x1,%r9b
jne    11be <crypte+0xbe>
jmp    11dc <crypte+0xdc>

LLVM IR (-O0):
define void @crypte(i8* %0, i32 %1, i32 %2) {
%4 = alloca i8*
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
store i8* %0, i8** %4
store i32 %1, i32* %5
store i32 %2, i32* %6
store i32 0, i32* %7
br label %8
8: ; preds = %26, %3
%9 = load i32, i32* %7
%10 = load i32, i32* %5
%11 = icmp slt i32 %9, %10
br i1 %11, label %12, label %29
12: ; preds = %8
%13 = load i8*, i8** %4
%14 = load i32, i32* %7
%15 = sext i32 %14 to i64
%16 = getelementptr inbounds i8, i8* %13, i64 %15
%17 = load i8, i8* %16
%18 = sext i8 %17 to i32
%19 = load i32, i32* %6
%20 = add nsw i32 %18, %19
%21 = trunc i32 %20 to i8
%22 = load i8*, i8** %4
%23 = load i32, i32* %7
%24 = sext i32 %23 to i64
%25 = getelementptr inbounds i8, i8* %22, i64 %24
store i8 %21, i8* %25
br label %26
26: ; preds = %12
%27 = load i32, i32* %7
%28 = add nsw i32 %27, 1
store i32 %28, i32* %7
br label %8
29: ; preds = %8
ret void
}

LLVM IR (-O2):
define void @crypte(i8* nocapture %0, i32 %1, i32 %2) {
%4 = icmp sgt i32 %1, 0
br i1 %4, label %5, label %88
5: ; preds = %3
%6 = trunc i32 %2 to i8
%7 = zext i32 %1 to i64
%8 = icmp ult i32 %1, 8
br i1 %8, label %86, label %9
9: ; preds = %5
%10 = icmp ult i32 %1, 32
br i1 %10, label %70, label %11
11: ; preds = %9
%12 = and i64 %7, 4294967264
%13 = insertelement <16 x i8> poison, i8 %6, i64 0
%14 = shufflevector <16 x i8> %13, <16 x i8> poison, <16 x i32> zeroinitializer
%15 = insertelement <16 x i8> poison, i8 %6, i64 0
%16 = shufflevector <16 x i8> %15, <16 x i8> poison, <16 x i32> zeroinitializer
%17 = add nsw i64 %12, -32
%18 = lshr exact i64 %17, 5
%19 = add nuw nsw i64 %18, 1
%20 = and i64 %19, 1
%21 = icmp eq i64 %17, 0
br i1 %21, label %51, label %22
22: ; preds = %11
%23 = and i64 %19, 1152921504606846974
br label %24
24: ; preds = %24, %22
%25 = phi i64 [ 0, %22 ], [ %48, %24 ]
%26 = phi i64 [ 0, %22 ], [ %49, %24 ]
%27 = getelementptr inbounds i8, i8* %0, i64 %25
%28 = bitcast i8* %27 to <16 x i8>*
%29 = load <16 x i8>, <16 x i8>* %28
%30 = getelementptr inbounds i8, i8* %27, i64 16
%31 = bitcast i8* %30 to <16 x i8>*
%32 = load <16 x i8>, <16 x i8>* %31
%33 = add <16 x i8> %29, %14
%34 = add <16 x i8> %32, %16
%35 = bitcast i8* %27 to <16 x i8>*
store <16 x i8> %33, <16 x i8>* %35
%36 = bitcast i8* %30 to <16 x i8>*
store <16 x i8> %34, <16 x i8>* %36
%37 = or i64 %25, 32
%38 = getelementptr inbounds i8, i8* %0, i64 %37
%39 = bitcast i8* %38 to <16 x i8>*
%40 = load <16 x i8>, <16 x i8>* %39
%41 = getelementptr inbounds i8, i8* %38, i64 16
%42 = bitcast i8* %41 to <16 x i8>*
%43 = load <16 x i8>, <16 x i8>* %42
%44 = add <16 x i8> %40, %14
%45 = add <16 x i8> %43, %16
%46 = bitcast i8* %38 to <16 x i8>*
store <16 x i8> %44, <16 x i8>* %46
%47 = bitcast i8* %41 to <16 x i8>*
store <16 x i8> %45, <16 x i8>* %47
%48 = add nuw i64 %25, 64
%49 = add i64 %26, 2
%50 = icmp eq i64 %49, %23
br i1 %50, label %51, label %24
51: ; preds = %24, %11
%52 = phi i64 [ 0, %11 ], [ %48, %24 ]
%53 = icmp eq i64 %20, 0
br i1 %53, label %65, label %54
54: ; preds = %51
%55 = getelementptr inbounds i8, i8* %0, i64 %52
%56 = bitcast i8* %55 to <16 x i8>*
%57 = load <16 x i8>, <16 x i8>* %56
%58 = getelementptr inbounds i8, i8* %55, i64 16
%59 = bitcast i8* %58 to <16 x i8>*
%60 = load <16 x i8>, <16 x i8>* %59
%61 = add <16 x i8> %57, %14
%62 = add <16 x i8> %60, %16
%63 = bitcast i8* %55 to <16 x i8>*
store <16 x i8> %61, <16 x i8>* %63
%64 = bitcast i8* %58 to <16 x i8>*
store <16 x i8> %62, <16 x i8>* %64
br label %65
65: ; preds = %51, %54
%66 = icmp eq i64 %12, %7
br i1 %66, label %88, label %67
67: ; preds = %65
%68 = and i64 %7, 24
%69 = icmp eq i64 %68, 0
br i1 %69, label %86, label %70
70: ; preds = %9, %67
%71 = phi i64 [ %12, %67 ], [ 0, %9 ]
%72 = and i64 %7, 4294967288
%73 = insertelement <8 x i8> poison, i8 %6, i64 0
%74 = shufflevector <8 x i8> %73, <8 x i8> poison, <8 x i32> zeroinitializer
br label %75
75: ; preds = %75, %70
%76 = phi i64 [ %71, %70 ], [ %82, %75 ]
%77 = getelementptr inbounds i8, i8* %0, i64 %76
%78 = bitcast i8* %77 to <8 x i8>*
%79 = load <8 x i8>, <8 x i8>* %78
%80 = add <8 x i8> %79, %74
%81 = bitcast i8* %77 to <8 x i8>*
store <8 x i8> %80, <8 x i8>* %81
%82 = add nuw i64 %76, 8
%83 = icmp eq i64 %82, %72
br i1 %83, label %84, label %75
84: ; preds = %75
%85 = icmp eq i64 %72, %7
br i1 %85, label %88, label %86
86: ; preds = %5, %67, %84
%87 = phi i64 [ 0, %5 ], [ %12, %67 ], [ %72, %84 ]
br label %89
88: ; preds = %89, %65, %84, %3
ret void
89: ; preds = %86, %89
%90 = phi i64 [ %94, %89 ], [ %87, %86 ]
%91 = getelementptr inbounds i8, i8* %0, i64 %90
%92 = load i8, i8* %91
%93 = add i8 %92, %6
store i8 %93, i8* %91
%94 = add nuw nsw i64 %90, 1
%95 = icmp eq i64 %94, %7
br i1 %95, label %88, label %89
}