void rotate(char old_matrix[4][4]) {
  char new_matrix[4][4];
  int colum;
  int row;
  int index = 0;
  for (colum = 0; colum <= 3; colum++) {
    for (row = 3; row >= 0; row--) {
      *(new_matrix[0] + index) = (old_matrix[row][colum]);
      index++;
    }
  }
  for (index = 0; index < (4 * 4); index++) {
    *(old_matrix[0] + index) = *(new_matrix[0] + index);
  }
}


x86 assembly (clang, -O0):
<rotate>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x24(%rbp)
cmpl   $0x3,-0x24(%rbp)
jg     1179 <rotate+0x79>
movl   $0x3,-0x28(%rbp)
cmpl   $0x0,-0x28(%rbp)
jl     1166 <rotate+0x66>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
movslq -0x2c(%rbp),%rax
mov    %cl,-0x20(%rbp,%rax,1)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x28(%rbp)
jmp    1127 <rotate+0x27>
jmp    116b <rotate+0x6b>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1116 <rotate+0x16>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x10,-0x2c(%rbp)
jge    11ab <rotate+0xab>
movslq -0x2c(%rbp),%rax
mov    -0x20(%rbp,%rax,1),%dl
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1180 <rotate+0x80>
pop    %rbp
ret

x86 assembly (clang, -O2):
<rotate>:
movdqu (%rdi),%xmm0
pxor   %xmm1,%xmm1
movdqa %xmm0,%xmm2
punpcklbw %xmm1,%xmm2
pshufd $0xe7,%xmm2,%xmm3
pshuflw $0xd8,%xmm3,%xmm3
punpckhbw %xmm1,%xmm0
pshufd $0xe7,%xmm0,%xmm1
pshuflw $0xd8,%xmm1,%xmm1
punpckldq %xmm3,%xmm1
pshufd $0xe8,%xmm2,%xmm2
pshuflw $0x72,%xmm2,%xmm2
pshufd $0xe8,%xmm0,%xmm0
pshuflw $0x72,%xmm0,%xmm0
punpckldq %xmm2,%xmm0
packuswb %xmm1,%xmm0
movdqu %xmm0,(%rdi)
ret

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

LLVM IR (-O2):
define void @rotate([4 x i8]* nocapture %0) {
%2 = bitcast [4 x i8]* %0 to <16 x i8>*
%3 = load <16 x i8>, <16 x i8>* %2
%4 = shufflevector <16 x i8> %3, <16 x i8> poison, <16 x i32> <i32 12, i32 8, i32 4, i32 0, i32 13, i32 9, i32 5, i32 1, i32 14, i32 10, i32 6, i32 2, i32 15, i32 11, i32 7, i32 3>
%5 = bitcast [4 x i8]* %0 to <16 x i8>*
store <16 x i8> %4, <16 x i8>* %5
ret void
}