void int_to_hex(unsigned int n, unsigned char *str) {
  int i;
  for (i = 9; i >= 2; i--) {
    str[i] = n % 16 + 48;
    if (str[i] >= 58)
      str[i] += 7;
    n /= 16;
  }
  str[0] = '0';
  str[1] = 'x';
  str[10] = '\0';
}


x86 assembly (clang, -O0):
<int_to_hex>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x9,-0x14(%rbp)
cmpl   $0x2,-0x14(%rbp)
jl     1170 <int_to_hex+0x70>
mov    -0x4(%rbp),%eax
and    $0xf,%eax
add    $0x30,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x3a,%eax
jl     1159 <int_to_hex+0x59>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
add    $0x7,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x4(%rbp),%eax
shr    $0x4,%eax
mov    %eax,-0x4(%rbp)
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
jmp    1112 <int_to_hex+0x12>
mov    -0x10(%rbp),%rax
movb   $0x30,(%rax)
mov    -0x10(%rbp),%rax
movb   $0x78,0x1(%rax)
mov    -0x10(%rbp),%rax
movb   $0x0,0xa(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<int_to_hex>:
mov    %edi,%eax
and    $0xf,%al
lea    0x30(%rax),%ecx
add    $0x37,%al
cmp    $0x3a,%cl
movzbl %al,%eax
movzbl %cl,%ecx
cmovae %eax,%ecx
mov    %cl,0x9(%rsi)
mov    %edi,%eax
shr    $0x4,%al
lea    0x30(%rax),%ecx
add    $0x37,%al
cmp    $0x3a,%cl
movzbl %al,%eax
movzbl %cl,%ecx
cmovae %eax,%ecx
mov    %cl,0x8(%rsi)
mov    %edi,%eax
shr    $0x8,%eax
and    $0xf,%al
lea    0x30(%rax),%ecx
add    $0x37,%al
cmp    $0x3a,%cl
movzbl %al,%eax
movzbl %cl,%ecx
cmovae %eax,%ecx
mov    %cl,0x7(%rsi)
mov    %edi,%eax
shr    $0xc,%eax
and    $0xf,%al
lea    0x30(%rax),%ecx
add    $0x37,%al
cmp    $0x3a,%cl
movzbl %al,%eax
movzbl %cl,%ecx
cmovae %eax,%ecx
mov    %cl,0x6(%rsi)
mov    %edi,%eax
shr    $0x10,%eax
and    $0xf,%al
lea    0x30(%rax),%ecx
add    $0x37,%al
cmp    $0x3a,%cl
movzbl %al,%eax
movzbl %cl,%ecx
cmovae %eax,%ecx
mov    %cl,0x5(%rsi)
mov    %edi,%eax
shr    $0x14,%eax
and    $0xf,%al
lea    0x30(%rax),%ecx
add    $0x37,%al
cmp    $0x3a,%cl
movzbl %al,%eax
movzbl %cl,%ecx
cmovae %eax,%ecx
mov    %cl,0x4(%rsi)
mov    %edi,%eax
shr    $0x18,%eax
and    $0xf,%al
lea    0x30(%rax),%ecx
add    $0x37,%al
cmp    $0x3a,%cl
movzbl %al,%eax
movzbl %cl,%ecx
cmovae %eax,%ecx
shr    $0x1c,%edi
lea    0x30(%rdi),%eax
add    $0x37,%dil
cmp    $0x3a,%al
movzbl %dil,%edx
movzbl %al,%eax
cmovae %edx,%eax
mov    %cl,0x3(%rsi)
mov    %al,0x2(%rsi)
movw   $0x7830,(%rsi)
movb   $0x0,0xa(%rsi)
ret

LLVM IR (-O0):
define void @int_to_hex(i32 %0, i8* %1) {
%3 = alloca i32
%4 = alloca i8*
%5 = alloca i32
store i32 %0, i32* %3
store i8* %1, i8** %4
store i32 9, i32* %5
br label %6
6: ; preds = %37, %2
%7 = load i32, i32* %5
%8 = icmp sge i32 %7, 2
br i1 %8, label %9, label %40
9: ; preds = %6
%10 = load i32, i32* %3
%11 = urem i32 %10, 16
%12 = add i32 %11, 48
%13 = trunc i32 %12 to i8
%14 = load i8*, i8** %4
%15 = load i32, i32* %5
%16 = sext i32 %15 to i64
%17 = getelementptr inbounds i8, i8* %14, i64 %16
store i8 %13, i8* %17
%18 = load i8*, i8** %4
%19 = load i32, i32* %5
%20 = sext i32 %19 to i64
%21 = getelementptr inbounds i8, i8* %18, i64 %20
%22 = load i8, i8* %21
%23 = zext i8 %22 to i32
%24 = icmp sge i32 %23, 58
br i1 %24, label %25, label %34
25: ; preds = %9
%26 = load i8*, i8** %4
%27 = load i32, i32* %5
%28 = sext i32 %27 to i64
%29 = getelementptr inbounds i8, i8* %26, i64 %28
%30 = load i8, i8* %29
%31 = zext i8 %30 to i32
%32 = add nsw i32 %31, 7
%33 = trunc i32 %32 to i8
store i8 %33, i8* %29
br label %34
34: ; preds = %25, %9
%35 = load i32, i32* %3
%36 = udiv i32 %35, 16
store i32 %36, i32* %3
br label %37
37: ; preds = %34
%38 = load i32, i32* %5
%39 = add nsw i32 %38, -1
store i32 %39, i32* %5
br label %6
40: ; preds = %6
%41 = load i8*, i8** %4
%42 = getelementptr inbounds i8, i8* %41, i64 0
store i8 48, i8* %42
%43 = load i8*, i8** %4
%44 = getelementptr inbounds i8, i8* %43, i64 1
store i8 120, i8* %44
%45 = load i8*, i8** %4
%46 = getelementptr inbounds i8, i8* %45, i64 10
store i8 0, i8* %46
ret void
}

LLVM IR (-O2):
define void @int_to_hex(i32 %0, i8* nocapture writeonly %1) {
%3 = trunc i32 %0 to i8
%4 = and i8 %3, 15
%5 = or i8 %4, 48
%6 = getelementptr inbounds i8, i8* %1, i64 9
%7 = icmp ugt i8 %5, 57
%8 = add nuw nsw i8 %4, 55
%9 = select i1 %7, i8 %8, i8 %5
store i8 %9, i8* %6
%10 = trunc i32 %0 to i8
%11 = lshr i8 %10, 4
%12 = or i8 %11, 48
%13 = getelementptr inbounds i8, i8* %1, i64 8
%14 = icmp ugt i8 %12, 57
%15 = add nuw nsw i8 %11, 55
%16 = select i1 %14, i8 %15, i8 %12
store i8 %16, i8* %13
%17 = lshr i32 %0, 8
%18 = trunc i32 %17 to i8
%19 = and i8 %18, 15
%20 = or i8 %19, 48
%21 = getelementptr inbounds i8, i8* %1, i64 7
%22 = icmp ugt i8 %20, 57
%23 = add nuw nsw i8 %19, 55
%24 = select i1 %22, i8 %23, i8 %20
store i8 %24, i8* %21
%25 = lshr i32 %0, 12
%26 = trunc i32 %25 to i8
%27 = and i8 %26, 15
%28 = or i8 %27, 48
%29 = getelementptr inbounds i8, i8* %1, i64 6
%30 = icmp ugt i8 %28, 57
%31 = add nuw nsw i8 %27, 55
%32 = select i1 %30, i8 %31, i8 %28
store i8 %32, i8* %29
%33 = lshr i32 %0, 16
%34 = trunc i32 %33 to i8
%35 = and i8 %34, 15
%36 = or i8 %35, 48
%37 = getelementptr inbounds i8, i8* %1, i64 5
%38 = icmp ugt i8 %36, 57
%39 = add nuw nsw i8 %35, 55
%40 = select i1 %38, i8 %39, i8 %36
store i8 %40, i8* %37
%41 = lshr i32 %0, 20
%42 = trunc i32 %41 to i8
%43 = and i8 %42, 15
%44 = or i8 %43, 48
%45 = getelementptr inbounds i8, i8* %1, i64 4
%46 = icmp ugt i8 %44, 57
%47 = add nuw nsw i8 %43, 55
%48 = select i1 %46, i8 %47, i8 %44
store i8 %48, i8* %45
%49 = lshr i32 %0, 24
%50 = trunc i32 %49 to i8
%51 = and i8 %50, 15
%52 = or i8 %51, 48
%53 = getelementptr inbounds i8, i8* %1, i64 3
%54 = icmp ugt i8 %52, 57
%55 = add nuw nsw i8 %51, 55
%56 = select i1 %54, i8 %55, i8 %52
store i8 %56, i8* %53
%57 = lshr i32 %0, 28
%58 = trunc i32 %57 to i8
%59 = or i8 %58, 48
%60 = getelementptr inbounds i8, i8* %1, i64 2
%61 = icmp ugt i8 %59, 57
%62 = add nuw nsw i8 %58, 55
%63 = select i1 %61, i8 %62, i8 %59
store i8 %63, i8* %60
store i8 48, i8* %1
%64 = getelementptr inbounds i8, i8* %1, i64 1
store i8 120, i8* %64
%65 = getelementptr inbounds i8, i8* %1, i64 10
store i8 0, i8* %65
ret void
}