void moveb(source, dest, nbytes, offs, offd) char *source;
char *dest;
int nbytes;
int offs;
int offd;
{
  char *from, *last, *to;
  from = source + offs;
  to = dest + offd;
  last = from + nbytes;
  while (from < last)
    *(to++) = *(from++);
  return;
}


x86 assembly (clang, -O0):
<moveb>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x14(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x30(%rbp),%rax
jae    1178 <moveb+0x78>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
jmp    1143 <moveb+0x43>
pop    %rbp
ret

x86 assembly (clang, -O2):
<moveb>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
test   %edx,%edx
jle    1182 <moveb+0x82>
movslq %ecx,%r15
lea    (%rdi,%r15,1),%rax
movslq %edx,%r9
lea    (%rdi,%r15,1),%rdx
lea    (%rdx,%r9,1),%r11
lea    (%rdi,%r15,1),%r14
add    $0x1,%r14
cmp    %r14,%r11
mov    %r14,%rbx
cmova  %r11,%rbx
movslq %r8d,%r8
lea    (%rsi,%r8,1),%r13
sub    %rdx,%rbx
cmp    $0x8,%rbx
jb     115f <moveb+0x5f>
cmp    %r14,%r11
mov    %r14,%rcx
cmova  %r11,%rcx
cmp    %rcx,%r13
jae    118d <moveb+0x8d>
add    %r8,%rcx
sub    %rdx,%rcx
add    %rsi,%rcx
cmp    %rcx,%rax
jae    118d <moveb+0x8d>
mov    %r13,%rsi
mov    %rax,%rdi
add    %r9,%rax
nopl   0x0(%rax,%rax,1)
movzbl (%rdi),%ecx
add    $0x1,%rdi
mov    %cl,(%rsi)
add    $0x1,%rsi
cmp    %rax,%rdi
jb     1170 <moveb+0x70>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
cmp    $0x20,%rbx
jae    119a <moveb+0x9a>
xor    %ecx,%ecx
jmp    12b3 <moveb+0x1b3>
mov    %rdx,-0x10(%rsp)
mov    %r9,-0x8(%rsp)
mov    %rbx,%rcx
and    $0xffffffffffffffe0,%rcx
lea    -0x20(%rcx),%rbp
mov    %rbp,%rdx
shr    $0x5,%rdx
add    $0x1,%rdx
mov    %edx,%r12d
and    $0x3,%r12d
cmp    $0x60,%rbp
jae    11ce <moveb+0xce>
xor    %ebp,%ebp
jmp    1258 <moveb+0x158>
and    $0xfffffffffffffffc,%rdx
lea    (%r8,%rsi,1),%r9
add    $0x70,%r9
lea    (%r15,%rdi,1),%r10
add    $0x70,%r10
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups -0x70(%r10,%rbp,1),%xmm0
movups -0x60(%r10,%rbp,1),%xmm1
movups %xmm0,-0x70(%r9,%rbp,1)
movups %xmm1,-0x60(%r9,%rbp,1)
movups -0x50(%r10,%rbp,1),%xmm0
movups -0x40(%r10,%rbp,1),%xmm1
movups %xmm0,-0x50(%r9,%rbp,1)
movups %xmm1,-0x40(%r9,%rbp,1)
movups -0x30(%r10,%rbp,1),%xmm0
movups -0x20(%r10,%rbp,1),%xmm1
movups %xmm0,-0x30(%r9,%rbp,1)
movups %xmm1,-0x20(%r9,%rbp,1)
movups -0x10(%r10,%rbp,1),%xmm0
movups (%r10,%rbp,1),%xmm1
movups %xmm0,-0x10(%r9,%rbp,1)
movups %xmm1,(%r9,%rbp,1)
sub    $0xffffffffffffff80,%rbp
add    $0xfffffffffffffffc,%rdx
jne    11f0 <moveb+0xf0>
test   %r12,%r12
je     129b <moveb+0x19b>
add    %rbp,%r15
lea    (%rdi,%r15,1),%rdx
add    $0x10,%rdx
add    %rbp,%r8
add    %r8,%rsi
add    $0x10,%rsi
shl    $0x5,%r12
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movups -0x10(%rdx,%rdi,1),%xmm0
movups (%rdx,%rdi,1),%xmm1
movups %xmm0,-0x10(%rsi,%rdi,1)
movups %xmm1,(%rsi,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r12
jne    1280 <moveb+0x180>
cmp    %rcx,%rbx
mov    -0x8(%rsp),%r9
je     1182 <moveb+0x82>
test   $0x18,%bl
je     12f0 <moveb+0x1f0>
mov    -0x10(%rsp),%rdx
cmp    %r14,%r11
cmova  %r11,%r14
sub    %rdx,%r14
mov    %r14,%rdx
and    $0xfffffffffffffff8,%rdx
lea    (%rdx,%r13,1),%rsi
lea    (%rax,%rdx,1),%rdi
nopl   0x0(%rax)
mov    (%rax,%rcx,1),%rbp
mov    %rbp,0x0(%r13,%rcx,1)
add    $0x8,%rcx
cmp    %rcx,%rdx
jne    12d0 <moveb+0x1d0>
cmp    %rdx,%r14
jne    1165 <moveb+0x65>
jmp    1182 <moveb+0x82>
lea    (%rax,%rcx,1),%rdi
add    %rcx,%r13
mov    %r13,%rsi
jmp    1165 <moveb+0x65>

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

LLVM IR (-O2):
define void @moveb(i8* %0, i8* nocapture writeonly %1, i32 %2, i32 %3, i32 %4) {
%6 = ptrtoint i8* %0 to i64
%7 = sext i32 %3 to i64
%8 = getelementptr i8, i8* %0, i64 %7
%9 = sext i32 %2 to i64
%10 = getelementptr inbounds i8, i8* %8, i64 %9
%11 = icmp sgt i32 %2, 0
br i1 %11, label %12, label %154
12: ; preds = %5
%13 = sext i32 %4 to i64
%14 = getelementptr i8, i8* %1, i64 %13
%15 = add i64 %6, %7
%16 = add i64 %15, %9
%17 = add i64 %15, 1
%18 = call i64 @llvm.umax.i64(i64 %16, i64 %17)
%19 = add i64 %6, %7
%20 = sub i64 %18, %19
%21 = icmp ult i64 %20, 8
br i1 %21, label %144, label %22
22: ; preds = %12
%23 = add i64 %6, %7
%24 = add i64 %23, %9
%25 = add i64 %23, 1
%26 = call i64 @llvm.umax.i64(i64 %24, i64 %25)
%27 = add i64 %26, %13
%28 = add i64 %6, %7
%29 = sub i64 %27, %28
%30 = getelementptr i8, i8* %1, i64 %29
%31 = sub i64 %26, %6
%32 = getelementptr i8, i8* %0, i64 %31
%33 = icmp ult i8* %14, %32
%34 = icmp ult i8* %8, %30
%35 = and i1 %33, %34
br i1 %35, label %144, label %36
36: ; preds = %22
%37 = icmp ult i64 %20, 32
br i1 %37, label %122, label %38
38: ; preds = %36
%39 = and i64 %20, -32
%40 = add i64 %39, -32
%41 = lshr exact i64 %40, 5
%42 = add nuw nsw i64 %41, 1
%43 = and i64 %42, 3
%44 = icmp ult i64 %40, 96
br i1 %44, label %96, label %45
45: ; preds = %38
%46 = and i64 %42, 1152921504606846972
br label %47
47: ; preds = %47, %45
%48 = phi i64 [ 0, %45 ], [ %93, %47 ]
%49 = phi i64 [ 0, %45 ], [ %94, %47 ]
%50 = getelementptr i8, i8* %14, i64 %48
%51 = getelementptr i8, i8* %8, i64 %48
%52 = bitcast i8* %51 to <16 x i8>*
%53 = load <16 x i8>, <16 x i8>* %52
%54 = getelementptr i8, i8* %51, i64 16
%55 = bitcast i8* %54 to <16 x i8>*
%56 = load <16 x i8>, <16 x i8>* %55
%57 = bitcast i8* %50 to <16 x i8>*
store <16 x i8> %53, <16 x i8>* %57
%58 = getelementptr i8, i8* %50, i64 16
%59 = bitcast i8* %58 to <16 x i8>*
store <16 x i8> %56, <16 x i8>* %59
%60 = or i64 %48, 32
%61 = getelementptr i8, i8* %14, i64 %60
%62 = getelementptr i8, i8* %8, i64 %60
%63 = bitcast i8* %62 to <16 x i8>*
%64 = load <16 x i8>, <16 x i8>* %63
%65 = getelementptr i8, i8* %62, i64 16
%66 = bitcast i8* %65 to <16 x i8>*
%67 = load <16 x i8>, <16 x i8>* %66
%68 = bitcast i8* %61 to <16 x i8>*
store <16 x i8> %64, <16 x i8>* %68
%69 = getelementptr i8, i8* %61, i64 16
%70 = bitcast i8* %69 to <16 x i8>*
store <16 x i8> %67, <16 x i8>* %70
%71 = or i64 %48, 64
%72 = getelementptr i8, i8* %14, i64 %71
%73 = getelementptr i8, i8* %8, i64 %71
%74 = bitcast i8* %73 to <16 x i8>*
%75 = load <16 x i8>, <16 x i8>* %74
%76 = getelementptr i8, i8* %73, i64 16
%77 = bitcast i8* %76 to <16 x i8>*
%78 = load <16 x i8>, <16 x i8>* %77
%79 = bitcast i8* %72 to <16 x i8>*
store <16 x i8> %75, <16 x i8>* %79
%80 = getelementptr i8, i8* %72, i64 16
%81 = bitcast i8* %80 to <16 x i8>*
store <16 x i8> %78, <16 x i8>* %81
%82 = or i64 %48, 96
%83 = getelementptr i8, i8* %14, i64 %82
%84 = getelementptr i8, i8* %8, i64 %82
%85 = bitcast i8* %84 to <16 x i8>*
%86 = load <16 x i8>, <16 x i8>* %85
%87 = getelementptr i8, i8* %84, i64 16
%88 = bitcast i8* %87 to <16 x i8>*
%89 = load <16 x i8>, <16 x i8>* %88
%90 = bitcast i8* %83 to <16 x i8>*
store <16 x i8> %86, <16 x i8>* %90
%91 = getelementptr i8, i8* %83, i64 16
%92 = bitcast i8* %91 to <16 x i8>*
store <16 x i8> %89, <16 x i8>* %92
%93 = add nuw i64 %48, 128
%94 = add i64 %49, 4
%95 = icmp eq i64 %94, %46
br i1 %95, label %96, label %47
96: ; preds = %47, %38
%97 = phi i64 [ 0, %38 ], [ %93, %47 ]
%98 = icmp eq i64 %43, 0
br i1 %98, label %115, label %99
99: ; preds = %96, %99
%100 = phi i64 [ %112, %99 ], [ %97, %96 ]
%101 = phi i64 [ %113, %99 ], [ 0, %96 ]
%102 = getelementptr i8, i8* %14, i64 %100
%103 = getelementptr i8, i8* %8, i64 %100
%104 = bitcast i8* %103 to <16 x i8>*
%105 = load <16 x i8>, <16 x i8>* %104
%106 = getelementptr i8, i8* %103, i64 16
%107 = bitcast i8* %106 to <16 x i8>*
%108 = load <16 x i8>, <16 x i8>* %107
%109 = bitcast i8* %102 to <16 x i8>*
store <16 x i8> %105, <16 x i8>* %109
%110 = getelementptr i8, i8* %102, i64 16
%111 = bitcast i8* %110 to <16 x i8>*
store <16 x i8> %108, <16 x i8>* %111
%112 = add nuw i64 %100, 32
%113 = add i64 %101, 1
%114 = icmp eq i64 %113, %43
br i1 %114, label %115, label %99
115: ; preds = %99, %96
%116 = icmp eq i64 %20, %39
br i1 %116, label %154, label %117
117: ; preds = %115
%118 = getelementptr i8, i8* %8, i64 %39
%119 = getelementptr i8, i8* %14, i64 %39
%120 = and i64 %20, 24
%121 = icmp eq i64 %120, 0
br i1 %121, label %144, label %122
122: ; preds = %36, %117
%123 = phi i64 [ %39, %117 ], [ 0, %36 ]
%124 = add i64 %6, %7
%125 = add i64 %124, %9
%126 = add i64 %124, 1
%127 = call i64 @llvm.umax.i64(i64 %125, i64 %126)
%128 = add i64 %6, %7
%129 = sub i64 %127, %128
%130 = and i64 %129, -8
%131 = getelementptr i8, i8* %14, i64 %130
%132 = getelementptr i8, i8* %8, i64 %130
br label %133
133: ; preds = %133, %122
%134 = phi i64 [ %123, %122 ], [ %140, %133 ]
%135 = getelementptr i8, i8* %14, i64 %134
%136 = getelementptr i8, i8* %8, i64 %134
%137 = bitcast i8* %136 to <8 x i8>*
%138 = load <8 x i8>, <8 x i8>* %137
%139 = bitcast i8* %135 to <8 x i8>*
store <8 x i8> %138, <8 x i8>* %139
%140 = add nuw i64 %134, 8
%141 = icmp eq i64 %140, %130
br i1 %141, label %142, label %133
142: ; preds = %133
%143 = icmp eq i64 %129, %130
br i1 %143, label %154, label %144
144: ; preds = %22, %12, %117, %142
%145 = phi i8* [ %14, %12 ], [ %14, %22 ], [ %119, %117 ], [ %131, %142 ]
%146 = phi i8* [ %8, %12 ], [ %8, %22 ], [ %118, %117 ], [ %132, %142 ]
br label %147
147: ; preds = %144, %147
%148 = phi i8* [ %152, %147 ], [ %145, %144 ]
%149 = phi i8* [ %150, %147 ], [ %146, %144 ]
%150 = getelementptr inbounds i8, i8* %149, i64 1
%151 = load i8, i8* %149
%152 = getelementptr inbounds i8, i8* %148, i64 1
store i8 %151, i8* %148
%153 = icmp ult i8* %150, %10
br i1 %153, label %147, label %154
154: ; preds = %147, %115, %142, %5
ret void
}