itoda(value, p, size) int value;
char *p;
int size;
{
  int i;
  int j;
  int k;
  int aval;
  char c[20];
  aval = abs(value);
  c[0] = '\0';
  i = 1;
  do {
    c[i++] = (aval % 10) + '0';
    aval /= 10;
  } while (aval > 0 && i <= size);
  if (value < 0 && i <= size)
    c[i++] = '-';
  for (j = 0; j < i; ++j)
    *p++ = c[i - j - 1];
  return (i);
}


x86 assembly (clang, -O0):
<itoda>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    -0x4(%rbp),%edi
call   1030 <abs@plt>
mov    %eax,-0x24(%rbp)
movb   $0x0,-0x40(%rbp)
movl   $0x1,-0x18(%rbp)
mov    -0x24(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
add    $0x30,%edx
mov    %dl,%cl
mov    -0x18(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x18(%rbp)
cltq
mov    %cl,-0x40(%rbp,%rax,1)
mov    -0x24(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %eax,-0x24(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x24(%rbp)
mov    %al,-0x41(%rbp)
jle    1182 <itoda+0x72>
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
setle  %al
mov    %al,-0x41(%rbp)
mov    -0x41(%rbp),%al
test   $0x1,%al
jne    1138 <itoda+0x28>
cmpl   $0x0,-0x4(%rbp)
jge    11b5 <itoda+0xa5>
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     11b5 <itoda+0xa5>
mov    -0x18(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x18(%rbp)
cltq
movb   $0x2d,-0x40(%rbp,%rax,1)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    11f6 <itoda+0xe6>
mov    -0x18(%rbp),%eax
sub    -0x1c(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0x40(%rbp,%rax,1),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11bc <itoda+0xac>
mov    -0x18(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<itoda>:
push   %rbx
mov    %edi,%ecx
neg    %ecx
cmovs  %edi,%ecx
movb   $0x0,-0x20(%rsp)
movslq %edx,%r8
mov    $0x1,%r9d
mov    $0x2,%eax
nopl   0x0(%rax,%rax,1)
mov    %r9,%r11
movslq %ecx,%r10
imul   $0x66666667,%r10,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x22,%rcx
add    %edx,%ecx
lea    (%rcx,%rcx,1),%edx
lea    (%rdx,%rdx,4),%edx
mov    %r10d,%ebx
sub    %edx,%ebx
add    $0x30,%bl
add    $0x1,%r9
mov    %bl,-0x20(%rsp,%r11,1)
add    $0x1,%eax
cmp    $0xa,%r10d
jl     115f <itoda+0x5f>
cmp    %r8,%r11
jl     1120 <itoda+0x20>
test   %edi,%edi
jns    1170 <itoda+0x70>
cmp    %r8,%r11
jge    1170 <itoda+0x70>
movb   $0x2d,-0x20(%rsp,%r9,1)
jmp    1173 <itoda+0x73>
mov    %r9d,%eax
cmp    $0x2,%eax
mov    $0x1,%r8d
cmovge %eax,%r8d
cmp    $0x8,%r8d
jae    1238 <itoda+0x138>
xor    %r9d,%r9d
mov    %rsi,%rdi
mov    %r9,%r10
not    %r10
add    %r8,%r10
mov    %r8,%rdx
and    $0x3,%rdx
je     11cd <itoda+0xcd>
mov    %r9d,%esi
not    %esi
add    %eax,%esi
neg    %rdx
xor    %ecx,%ecx
xchg   %ax,%ax
lea    (%rsi,%rcx,1),%ebx
movslq %ebx,%rbx
movzbl -0x20(%rsp,%rbx,1),%ebx
mov    %bl,(%rdi)
add    $0x1,%rdi
add    $0xffffffffffffffff,%rcx
cmp    %rcx,%rdx
jne    11b0 <itoda+0xb0>
sub    %rcx,%r9
cmp    $0x3,%r10
jb     1236 <itoda+0x136>
mov    %r9d,%esi
mov    %eax,%edx
sub    %r9d,%edx
lea    -0x4(%rdx),%r10d
lea    -0x3(%rdx),%r11d
add    $0xfffffffe,%edx
sub    %r8,%r9
not    %esi
add    %eax,%esi
xor    %ecx,%ecx
nop
lea    (%rsi,%rcx,1),%ebx
movslq %ebx,%rbx
movzbl -0x20(%rsp,%rbx,1),%ebx
mov    %bl,(%rdi)
lea    (%rdx,%rcx,1),%ebx
movslq %ebx,%rbx
movzbl -0x20(%rsp,%rbx,1),%ebx
mov    %bl,0x1(%rdi)
lea    (%r11,%rcx,1),%ebx
movslq %ebx,%rbx
movzbl -0x20(%rsp,%rbx,1),%ebx
mov    %bl,0x2(%rdi)
lea    (%r10,%rcx,1),%ebx
movslq %ebx,%rbx
movzbl -0x20(%rsp,%rbx,1),%ebx
mov    %bl,0x3(%rdi)
add    $0xfffffffffffffffc,%rcx
add    $0x4,%rdi
cmp    %rcx,%r9
jne    11f0 <itoda+0xf0>
pop    %rbx
ret
lea    -0x1(%r8),%rcx
lea    -0x1(%rax),%edi
mov    %edi,%edx
sub    %ecx,%edx
xor    %r9d,%r9d
cmp    %edi,%edx
jg     118d <itoda+0x8d>
shr    $0x20,%rcx
jne    118d <itoda+0x8d>
cmp    $0x20,%r8d
jae    1266 <itoda+0x166>
xor    %r9d,%r9d
jmp    1315 <itoda+0x215>
mov    %r8d,%r9d
and    $0x7fffffe0,%r9d
xor    %ecx,%ecx
pxor   %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
movslq %edi,%rdi
movdqu -0x3f(%rsp,%rdi,1),%xmm1
movdqu -0x2f(%rsp,%rdi,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
movdqu %xmm2,(%rsi,%rcx,1)
movdqu %xmm1,0x10(%rsi,%rcx,1)
add    $0x20,%rcx
add    $0xffffffe0,%edi
cmp    %rcx,%r9
jne    1280 <itoda+0x180>
cmp    %r8,%r9
je     1236 <itoda+0x136>
test   $0x18,%r8b
je     136f <itoda+0x26f>
mov    %r9,%rcx
mov    %r8d,%r9d
and    $0x7ffffff8,%r9d
lea    (%rsi,%r9,1),%rdi
mov    %ecx,%edx
not    %edx
add    %eax,%edx
pxor   %xmm0,%xmm0
movslq %edx,%rdx
movq   -0x27(%rsp,%rdx,1),%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movq   %xmm1,(%rsi,%rcx,1)
add    $0x8,%rcx
add    $0xfffffff8,%edx
cmp    %rcx,%r9
jne    1330 <itoda+0x230>
cmp    %r8,%r9
jne    1190 <itoda+0x90>
jmp    1236 <itoda+0x136>
add    %r9,%rsi
jmp    118d <itoda+0x8d>

LLVM IR (-O0):
define i32 @itoda(i32 %0, i8* %1, i32 %2) {
%4 = alloca i32
%5 = alloca i8*
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca [20 x i8]
store i32 %0, i32* %4
store i8* %1, i8** %5
store i32 %2, i32* %6
%12 = load i32, i32* %4
%13 = call i32 @abs(i32 %12)
store i32 %13, i32* %10
%14 = getelementptr inbounds [20 x i8], [20 x i8]* %11, i64 0, i64 0
store i8 0, i8* %14
store i32 1, i32* %7
br label %15
15: ; preds = %33, %3
%16 = load i32, i32* %10
%17 = srem i32 %16, 10
%18 = add nsw i32 %17, 48
%19 = trunc i32 %18 to i8
%20 = load i32, i32* %7
%21 = add nsw i32 %20, 1
store i32 %21, i32* %7
%22 = sext i32 %20 to i64
%23 = getelementptr inbounds [20 x i8], [20 x i8]* %11, i64 0, i64 %22
store i8 %19, i8* %23
%24 = load i32, i32* %10
%25 = sdiv i32 %24, 10
store i32 %25, i32* %10
br label %26
26: ; preds = %15
%27 = load i32, i32* %10
%28 = icmp sgt i32 %27, 0
br i1 %28, label %29, label %33
29: ; preds = %26
%30 = load i32, i32* %7
%31 = load i32, i32* %6
%32 = icmp sle i32 %30, %31
br label %33
33: ; preds = %29, %26
%34 = phi i1 [ false, %26 ], [ %32, %29 ]
br i1 %34, label %15, label %35
35: ; preds = %33
%36 = load i32, i32* %4
%37 = icmp slt i32 %36, 0
br i1 %37, label %38, label %47
38: ; preds = %35
%39 = load i32, i32* %7
%40 = load i32, i32* %6
%41 = icmp sle i32 %39, %40
br i1 %41, label %42, label %47
42: ; preds = %38
%43 = load i32, i32* %7
%44 = add nsw i32 %43, 1
store i32 %44, i32* %7
%45 = sext i32 %43 to i64
%46 = getelementptr inbounds [20 x i8], [20 x i8]* %11, i64 0, i64 %45
store i8 45, i8* %46
br label %47
47: ; preds = %42, %38, %35
store i32 0, i32* %8
br label %48
48: ; preds = %62, %47
%49 = load i32, i32* %8
%50 = load i32, i32* %7
%51 = icmp slt i32 %49, %50
br i1 %51, label %52, label %65
52: ; preds = %48
%53 = load i32, i32* %7
%54 = load i32, i32* %8
%55 = sub nsw i32 %53, %54
%56 = sub nsw i32 %55, 1
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds [20 x i8], [20 x i8]* %11, i64 0, i64 %57
%59 = load i8, i8* %58
%60 = load i8*, i8** %5
%61 = getelementptr inbounds i8, i8* %60, i32 1
store i8* %61, i8** %5
store i8 %59, i8* %60
br label %62
62: ; preds = %52
%63 = load i32, i32* %8
%64 = add nsw i32 %63, 1
store i32 %64, i32* %8
br label %48
65: ; preds = %48
%66 = load i32, i32* %7
ret i32 %66
}

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