char *getname(const char *filename) {
  register unsigned int a1, a2, a3, a4, a5, a6, a7, a8, a9;
  a1 = (unsigned int)(filename)*5 + 1;
  a2 = (unsigned int)(filename)*6 + 2;
  a3 = (unsigned int)(filename)*7 + 3;
  a4 = (unsigned int)(filename)*8 + 4;
  a5 = (unsigned int)(filename)*9 + 5;
  a6 = (unsigned int)(filename)*10 + 5;
  a7 = (unsigned int)(filename)*11 + 5;
  a8 = (unsigned int)(filename)*12 + 5;
  a9 = (unsigned int)(filename)*13 + 5;
  return (char *)(a1 * a2 + a3 * a4 + a5 * a6 + a7 * a8 + a9);
}


x86 assembly (clang, -O0):
<getname>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rax
imul   $0x5,%eax,%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
mov    -0x8(%rbp),%rax
imul   $0x6,%eax,%eax
add    $0x2,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
imul   $0x7,%eax,%eax
add    $0x3,%eax
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rax
shl    $0x3,%eax
add    $0x4,%eax
mov    %eax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
imul   $0x9,%eax,%eax
add    $0x5,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
imul   $0xa,%eax,%eax
add    $0x5,%eax
mov    %eax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
imul   $0xb,%eax,%eax
add    $0x5,%eax
mov    %eax,-0x24(%rbp)
mov    -0x8(%rbp),%rax
imul   $0xc,%eax,%eax
add    $0x5,%eax
mov    %eax,-0x28(%rbp)
mov    -0x8(%rbp),%rax
imul   $0xd,%eax,%eax
add    $0x5,%eax
mov    %eax,-0x2c(%rbp)
mov    -0xc(%rbp),%eax
imul   -0x10(%rbp),%eax
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    %ecx,%eax
mov    -0x1c(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    %ecx,%eax
mov    -0x24(%rbp),%ecx
imul   -0x28(%rbp),%ecx
add    %ecx,%eax
add    -0x2c(%rbp),%eax
mov    %eax,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<getname>:
lea    (%rdi,%rdi,4),%r8d
lea    (%rdi,%rdi,4),%ecx
add    $0x1,%ecx
lea    (%rdi,%rdi,2),%edx
lea    (%rdx,%rdx,1),%r10d
add    $0x2,%r10d
imul   %ecx,%r10d
lea    0x0(,%rdi,8),%ecx
sub    %edi,%ecx
add    $0x3,%ecx
lea    0x4(,%rdi,8),%eax
imul   %ecx,%eax
lea    (%rdi,%rdi,8),%r9d
add    $0x5,%r9d
lea    (%r8,%r8,1),%ecx
add    $0x5,%ecx
imul   %r9d,%ecx
lea    (%rdi,%r8,2),%r8d
add    $0x5,%r8d
lea    0x5(,%rdx,4),%esi
imul   %r8d,%esi
lea    (%rdi,%rdx,4),%edx
add    %eax,%edx
add    %r10d,%edx
add    %ecx,%edx
lea    (%rsi,%rdx,1),%eax
add    $0x5,%eax
ret

LLVM IR (-O0):
define i8* @getname(i8* %0) {
%2 = alloca i8*
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
store i8* %0, i8** %2
%12 = load i8*, i8** %2
%13 = ptrtoint i8* %12 to i32
%14 = mul i32 %13, 5
%15 = add i32 %14, 1
store i32 %15, i32* %3
%16 = load i8*, i8** %2
%17 = ptrtoint i8* %16 to i32
%18 = mul i32 %17, 6
%19 = add i32 %18, 2
store i32 %19, i32* %4
%20 = load i8*, i8** %2
%21 = ptrtoint i8* %20 to i32
%22 = mul i32 %21, 7
%23 = add i32 %22, 3
store i32 %23, i32* %5
%24 = load i8*, i8** %2
%25 = ptrtoint i8* %24 to i32
%26 = mul i32 %25, 8
%27 = add i32 %26, 4
store i32 %27, i32* %6
%28 = load i8*, i8** %2
%29 = ptrtoint i8* %28 to i32
%30 = mul i32 %29, 9
%31 = add i32 %30, 5
store i32 %31, i32* %7
%32 = load i8*, i8** %2
%33 = ptrtoint i8* %32 to i32
%34 = mul i32 %33, 10
%35 = add i32 %34, 5
store i32 %35, i32* %8
%36 = load i8*, i8** %2
%37 = ptrtoint i8* %36 to i32
%38 = mul i32 %37, 11
%39 = add i32 %38, 5
store i32 %39, i32* %9
%40 = load i8*, i8** %2
%41 = ptrtoint i8* %40 to i32
%42 = mul i32 %41, 12
%43 = add i32 %42, 5
store i32 %43, i32* %10
%44 = load i8*, i8** %2
%45 = ptrtoint i8* %44 to i32
%46 = mul i32 %45, 13
%47 = add i32 %46, 5
store i32 %47, i32* %11
%48 = load i32, i32* %3
%49 = load i32, i32* %4
%50 = mul i32 %48, %49
%51 = load i32, i32* %5
%52 = load i32, i32* %6
%53 = mul i32 %51, %52
%54 = add i32 %50, %53
%55 = load i32, i32* %7
%56 = load i32, i32* %8
%57 = mul i32 %55, %56
%58 = add i32 %54, %57
%59 = load i32, i32* %9
%60 = load i32, i32* %10
%61 = mul i32 %59, %60
%62 = add i32 %58, %61
%63 = load i32, i32* %11
%64 = add i32 %62, %63
%65 = zext i32 %64 to i64
%66 = inttoptr i64 %65 to i8*
ret i8* %66
}

LLVM IR (-O2):
define i8* @getname(i8* %0) {
%2 = ptrtoint i8* %0 to i64
%3 = mul i64 %2, 5
%4 = add i64 %3, 1
%5 = mul i64 %2, 6
%6 = add i64 %5, 2
%7 = mul i64 %2, 7
%8 = add i64 %7, 3
%9 = shl i64 %2, 3
%10 = or i64 %9, 4
%11 = mul i64 %2, 9
%12 = add i64 %11, 5
%13 = mul i64 %2, 10
%14 = add i64 %13, 5
%15 = mul i64 %2, 11
%16 = add i64 %15, 5
%17 = mul i64 %2, 12
%18 = add i64 %17, 5
%19 = mul i64 %2, 13
%20 = mul i64 %4, %6
%21 = mul i64 %8, %10
%22 = mul i64 %12, %14
%23 = mul i64 %16, %18
%24 = add i64 %19, 5
%25 = add i64 %24, %21
%26 = add i64 %25, %20
%27 = add i64 %26, %22
%28 = add i64 %27, %23
%29 = and i64 %28, 4294967295
%30 = inttoptr i64 %29 to i8*
ret i8* %30
}