int big_endian_number(const char *buf, char len) {
  int num = 0;
  unsigned char rest = 4 - len;
  while (--len >= 0) {
    *((char *)&num + 3 - len) = *(buf + len);
  }
  return num >> (rest * 8);
}


x86 assembly (clang, -O0):
<big_endian_number>:
push   %rbp
mov    %rsp,%rbp
mov    %sil,%al
mov    %rdi,-0x8(%rbp)
mov    %al,-0x9(%rbp)
movl   $0x0,-0x10(%rbp)
movsbl -0x9(%rbp),%ecx
mov    $0x4,%eax
sub    %ecx,%eax
mov    %al,-0x11(%rbp)
mov    -0x9(%rbp),%al
add    $0xff,%al
mov    %al,-0x9(%rbp)
movsbl %al,%eax
cmp    $0x0,%eax
jl     115a <big_endian_number+0x5a>
mov    -0x8(%rbp),%rax
movsbl -0x9(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%cl
movsbl -0x9(%rbp),%eax
movslq %eax,%rdx
xor    %eax,%eax
sub    %rdx,%rax
mov    %cl,-0xd(%rbp,%rax,1)
jmp    1123 <big_endian_number+0x23>
mov    -0x10(%rbp),%eax
movzbl -0x11(%rbp),%ecx
shl    $0x3,%ecx
sar    %cl,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<big_endian_number>:
movl   $0x0,-0x4(%rsp)
mov    %esi,%r9d
add    $0xff,%r9b
js     124a <big_endian_number+0x14a>
cmp    $0x7,%r9b
jb     1251 <big_endian_number+0x151>
movzbl %r9b,%r8d
add    $0x1,%r8d
xor    %edx,%edx
cmp    $0x1f,%r9b
jb     11e6 <big_endian_number+0xe6>
mov    %r8d,%edx
and    $0xffffffe0,%edx
pxor   %xmm0,%xmm0
lea    -0x4(%rsp),%r10
mov    %r9d,%eax
mov    %edx,%r11d
nopl   0x0(%rax,%rax,1)
movzbl %al,%eax
movdqu -0x1f(%rdi,%rax,1),%xmm1
movdqu -0xf(%rdi,%rax,1),%xmm2
movdqa %xmm2,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm3,%xmm2
movdqa %xmm1,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm3,%xmm1
mov    %r10,%rcx
sub    %rax,%rcx
movdqu %xmm2,0x3(%rcx)
movdqu %xmm1,0x13(%rcx)
add    $0xe0,%al
add    $0xffffffe0,%r11d
jne    1150 <big_endian_number+0x50>
cmp    %edx,%r8d
je     1285 <big_endian_number+0x185>
test   $0x18,%r8b
je     124e <big_endian_number+0x14e>
mov    %r8d,%r10d
and    $0xfffffff8,%r10d
sub    %r10b,%r9b
mov    %edx,%ecx
sub    %r10d,%ecx
not    %dl
add    %sil,%dl
pxor   %xmm0,%xmm0
lea    -0x4(%rsp),%r11
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl %dl,%edx
movq   -0x7(%rdi,%rdx,1),%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
mov    %r11,%rax
sub    %rdx,%rax
movq   %xmm1,0x3(%rax)
add    $0xf8,%dl
add    $0x8,%ecx
jne    1210 <big_endian_number+0x110>
cmp    %r10d,%r8d
jne    1251 <big_endian_number+0x151>
jmp    1285 <big_endian_number+0x185>
xor    %eax,%eax
jmp    1289 <big_endian_number+0x189>
sub    %dl,%r9b
movzbl %r9b,%eax
lea    -0x4(%rsp),%rcx
sub    %rax,%rcx
add    $0x3,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%rdi,%rax,1),%edx
mov    %dl,(%rcx)
add    $0xffffffffffffffff,%rax
lea    0x1(%rax),%edx
add    $0x1,%rcx
test   %dl,%dl
jg     1270 <big_endian_number+0x170>
mov    -0x4(%rsp),%eax
mov    $0x4,%cl
sub    %sil,%cl
movzbl %cl,%ecx
shl    $0x3,%ecx
sar    %cl,%eax
ret

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

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