void I2CClockBlockingControl(unsigned int baseAdd, unsigned int ownAdd0,
                             unsigned int ownAdd1, unsigned int ownAdd2,
                             unsigned int ownAdd3) {
  (*((volatile unsigned int *)(baseAdd + (0xD4)))) &= ~((0x00000001u));
  (*((volatile unsigned int *)(baseAdd + (0xD4)))) |= ownAdd0 << (0x00000000u);
  (*((volatile unsigned int *)(baseAdd + (0xD4)))) &= ~((0x00000002u));
  (*((volatile unsigned int *)(baseAdd + (0xD4)))) |= ownAdd1 << (0x00000001u);
  (*((volatile unsigned int *)(baseAdd + (0xD4)))) &= ~((0x00000004u));
  (*((volatile unsigned int *)(baseAdd + (0xD4)))) |= ownAdd2 << (0x00000002u);
  (*((volatile unsigned int *)(baseAdd + (0xD4)))) &= ~((0x00000008u));
  (*((volatile unsigned int *)(baseAdd + (0xD4)))) |= ownAdd3 << (0x00000003u);
}


x86 assembly (clang, -O0):
<I2CClockBlockingControl>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %ecx,-0x10(%rbp)
mov    %r8d,-0x14(%rbp)
mov    -0x4(%rbp),%eax
add    $0xd4,%eax
mov    %eax,%eax
mov    (%rax),%ecx
and    $0xfffffffe,%ecx
mov    %ecx,(%rax)
mov    -0x8(%rbp),%edx
shl    $0x0,%edx
mov    -0x4(%rbp),%eax
add    $0xd4,%eax
mov    %eax,%eax
mov    (%rax),%ecx
or     %edx,%ecx
mov    %ecx,(%rax)
mov    -0x4(%rbp),%eax
add    $0xd4,%eax
mov    %eax,%eax
mov    (%rax),%ecx
and    $0xfffffffd,%ecx
mov    %ecx,(%rax)
mov    -0xc(%rbp),%edx
shl    $0x1,%edx
mov    -0x4(%rbp),%eax
add    $0xd4,%eax
mov    %eax,%eax
mov    (%rax),%ecx
or     %edx,%ecx
mov    %ecx,(%rax)
mov    -0x4(%rbp),%eax
add    $0xd4,%eax
mov    %eax,%eax
mov    (%rax),%ecx
and    $0xfffffffb,%ecx
mov    %ecx,(%rax)
mov    -0x10(%rbp),%edx
shl    $0x2,%edx
mov    -0x4(%rbp),%eax
add    $0xd4,%eax
mov    %eax,%eax
mov    (%rax),%ecx
or     %edx,%ecx
mov    %ecx,(%rax)
mov    -0x4(%rbp),%eax
add    $0xd4,%eax
mov    %eax,%eax
mov    (%rax),%ecx
and    $0xfffffff7,%ecx
mov    %ecx,(%rax)
mov    -0x14(%rbp),%edx
shl    $0x3,%edx
mov    -0x4(%rbp),%eax
add    $0xd4,%eax
mov    %eax,%eax
mov    (%rax),%ecx
or     %edx,%ecx
mov    %ecx,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<I2CClockBlockingControl>:
add    $0xd4,%edi
andl   $0xfffffffe,(%rdi)
or     %esi,(%rdi)
andl   $0xfffffffd,(%rdi)
add    %edx,%edx
or     %edx,(%rdi)
andl   $0xfffffffb,(%rdi)
shl    $0x2,%ecx
or     %ecx,(%rdi)
andl   $0xfffffff7,(%rdi)
shl    $0x3,%r8d
or     %r8d,(%rdi)
ret

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

LLVM IR (-O2):
define void @I2CClockBlockingControl(i32 %0, i32 %1, i32 %2, i32 %3, i32 %4) {
%6 = add i32 %0, 212
%7 = zext i32 %6 to i64
%8 = inttoptr i64 %7 to i32*
%9 = load volatile i32, i32* %8
%10 = and i32 %9, -2
store volatile i32 %10, i32* %8
%11 = load volatile i32, i32* %8
%12 = or i32 %11, %1
store volatile i32 %12, i32* %8
%13 = load volatile i32, i32* %8
%14 = and i32 %13, -3
store volatile i32 %14, i32* %8
%15 = shl i32 %2, 1
%16 = load volatile i32, i32* %8
%17 = or i32 %16, %15
store volatile i32 %17, i32* %8
%18 = load volatile i32, i32* %8
%19 = and i32 %18, -5
store volatile i32 %19, i32* %8
%20 = shl i32 %3, 2
%21 = load volatile i32, i32* %8
%22 = or i32 %21, %20
store volatile i32 %22, i32* %8
%23 = load volatile i32, i32* %8
%24 = and i32 %23, -9
store volatile i32 %24, i32* %8
%25 = shl i32 %4, 3
%26 = load volatile i32, i32* %8
%27 = or i32 %26, %25
store volatile i32 %27, i32* %8
ret void
}