int sc_isnonzero(const unsigned char *s) {
  return (((int)(s[0] | s[1] | s[2] | s[3] | s[4] | s[5] | s[6] | s[7] | s[8] |
                 s[9] | s[10] | s[11] | s[12] | s[13] | s[14] | s[15] | s[16] |
                 s[17] | s[18] | s[19] | s[20] | s[21] | s[22] | s[23] | s[24] |
                 s[25] | s[26] | s[27] | s[28] | s[29] | s[30] | s[31]) -
           1) >>
          8) +
         1;
}


x86 assembly (clang, -O0):
<sc_isnonzero>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rax
movzbl (%rax),%eax
mov    -0x8(%rbp),%rcx
movzbl 0x1(%rcx),%ecx
or     %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x2(%rcx),%ecx
or     %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x3(%rcx),%ecx
or     %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x4(%rcx),%ecx
or     %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x5(%rcx),%ecx
or     %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x6(%rcx),%ecx
or     %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x7(%rcx),%ecx
or     %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x8(%rcx),%ecx
or     %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x9(%rcx),%ecx
or     %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0xa(%rcx),%ecx
or     %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0xb(%rcx),%ecx
or     %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0xc(%rcx),%ecx
or     %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0xd(%rcx),%ecx
or     %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0xe(%rcx),%ecx
or     %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0xf(%rcx),%ecx
or     %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x10(%rcx),%ecx
or     %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x11(%rcx),%ecx
or     %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x12(%rcx),%ecx
or     %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x13(%rcx),%ecx
or     %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x14(%rcx),%ecx
or     %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x15(%rcx),%ecx
or     %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x16(%rcx),%ecx
or     %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x17(%rcx),%ecx
or     %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x18(%rcx),%ecx
or     %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x19(%rcx),%ecx
or     %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x1a(%rcx),%ecx
or     %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x1b(%rcx),%ecx
or     %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x1c(%rcx),%ecx
or     %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x1d(%rcx),%ecx
or     %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x1e(%rcx),%ecx
or     %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x1f(%rcx),%ecx
or     %ecx,%eax
sub    $0x1,%eax
sar    $0x8,%eax
add    $0x1,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<sc_isnonzero>:
movdqu (%rdi),%xmm0
movdqu 0x10(%rdi),%xmm1
por    %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
por    %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
por    %xmm0,%xmm1
movdqa %xmm1,%xmm0
psrld  $0x10,%xmm0
por    %xmm1,%xmm0
movdqa %xmm0,%xmm1
psrlw  $0x8,%xmm1
por    %xmm0,%xmm1
movd   %xmm1,%eax
movzbl %al,%eax
add    $0xffffffff,%eax
sar    $0x8,%eax
add    $0x1,%eax
ret

LLVM IR (-O0):
define i32 @sc_isnonzero(i8* %0) {
%2 = alloca i8*
store i8* %0, i8** %2
%3 = load i8*, i8** %2
%4 = getelementptr inbounds i8, i8* %3, i64 0
%5 = load i8, i8* %4
%6 = zext i8 %5 to i32
%7 = load i8*, i8** %2
%8 = getelementptr inbounds i8, i8* %7, i64 1
%9 = load i8, i8* %8
%10 = zext i8 %9 to i32
%11 = or i32 %6, %10
%12 = load i8*, i8** %2
%13 = getelementptr inbounds i8, i8* %12, i64 2
%14 = load i8, i8* %13
%15 = zext i8 %14 to i32
%16 = or i32 %11, %15
%17 = load i8*, i8** %2
%18 = getelementptr inbounds i8, i8* %17, i64 3
%19 = load i8, i8* %18
%20 = zext i8 %19 to i32
%21 = or i32 %16, %20
%22 = load i8*, i8** %2
%23 = getelementptr inbounds i8, i8* %22, i64 4
%24 = load i8, i8* %23
%25 = zext i8 %24 to i32
%26 = or i32 %21, %25
%27 = load i8*, i8** %2
%28 = getelementptr inbounds i8, i8* %27, i64 5
%29 = load i8, i8* %28
%30 = zext i8 %29 to i32
%31 = or i32 %26, %30
%32 = load i8*, i8** %2
%33 = getelementptr inbounds i8, i8* %32, i64 6
%34 = load i8, i8* %33
%35 = zext i8 %34 to i32
%36 = or i32 %31, %35
%37 = load i8*, i8** %2
%38 = getelementptr inbounds i8, i8* %37, i64 7
%39 = load i8, i8* %38
%40 = zext i8 %39 to i32
%41 = or i32 %36, %40
%42 = load i8*, i8** %2
%43 = getelementptr inbounds i8, i8* %42, i64 8
%44 = load i8, i8* %43
%45 = zext i8 %44 to i32
%46 = or i32 %41, %45
%47 = load i8*, i8** %2
%48 = getelementptr inbounds i8, i8* %47, i64 9
%49 = load i8, i8* %48
%50 = zext i8 %49 to i32
%51 = or i32 %46, %50
%52 = load i8*, i8** %2
%53 = getelementptr inbounds i8, i8* %52, i64 10
%54 = load i8, i8* %53
%55 = zext i8 %54 to i32
%56 = or i32 %51, %55
%57 = load i8*, i8** %2
%58 = getelementptr inbounds i8, i8* %57, i64 11
%59 = load i8, i8* %58
%60 = zext i8 %59 to i32
%61 = or i32 %56, %60
%62 = load i8*, i8** %2
%63 = getelementptr inbounds i8, i8* %62, i64 12
%64 = load i8, i8* %63
%65 = zext i8 %64 to i32
%66 = or i32 %61, %65
%67 = load i8*, i8** %2
%68 = getelementptr inbounds i8, i8* %67, i64 13
%69 = load i8, i8* %68
%70 = zext i8 %69 to i32
%71 = or i32 %66, %70
%72 = load i8*, i8** %2
%73 = getelementptr inbounds i8, i8* %72, i64 14
%74 = load i8, i8* %73
%75 = zext i8 %74 to i32
%76 = or i32 %71, %75
%77 = load i8*, i8** %2
%78 = getelementptr inbounds i8, i8* %77, i64 15
%79 = load i8, i8* %78
%80 = zext i8 %79 to i32
%81 = or i32 %76, %80
%82 = load i8*, i8** %2
%83 = getelementptr inbounds i8, i8* %82, i64 16
%84 = load i8, i8* %83
%85 = zext i8 %84 to i32
%86 = or i32 %81, %85
%87 = load i8*, i8** %2
%88 = getelementptr inbounds i8, i8* %87, i64 17
%89 = load i8, i8* %88
%90 = zext i8 %89 to i32
%91 = or i32 %86, %90
%92 = load i8*, i8** %2
%93 = getelementptr inbounds i8, i8* %92, i64 18
%94 = load i8, i8* %93
%95 = zext i8 %94 to i32
%96 = or i32 %91, %95
%97 = load i8*, i8** %2
%98 = getelementptr inbounds i8, i8* %97, i64 19
%99 = load i8, i8* %98
%100 = zext i8 %99 to i32
%101 = or i32 %96, %100
%102 = load i8*, i8** %2
%103 = getelementptr inbounds i8, i8* %102, i64 20
%104 = load i8, i8* %103
%105 = zext i8 %104 to i32
%106 = or i32 %101, %105
%107 = load i8*, i8** %2
%108 = getelementptr inbounds i8, i8* %107, i64 21
%109 = load i8, i8* %108
%110 = zext i8 %109 to i32
%111 = or i32 %106, %110
%112 = load i8*, i8** %2
%113 = getelementptr inbounds i8, i8* %112, i64 22
%114 = load i8, i8* %113
%115 = zext i8 %114 to i32
%116 = or i32 %111, %115
%117 = load i8*, i8** %2
%118 = getelementptr inbounds i8, i8* %117, i64 23
%119 = load i8, i8* %118
%120 = zext i8 %119 to i32
%121 = or i32 %116, %120
%122 = load i8*, i8** %2
%123 = getelementptr inbounds i8, i8* %122, i64 24
%124 = load i8, i8* %123
%125 = zext i8 %124 to i32
%126 = or i32 %121, %125
%127 = load i8*, i8** %2
%128 = getelementptr inbounds i8, i8* %127, i64 25
%129 = load i8, i8* %128
%130 = zext i8 %129 to i32
%131 = or i32 %126, %130
%132 = load i8*, i8** %2
%133 = getelementptr inbounds i8, i8* %132, i64 26
%134 = load i8, i8* %133
%135 = zext i8 %134 to i32
%136 = or i32 %131, %135
%137 = load i8*, i8** %2
%138 = getelementptr inbounds i8, i8* %137, i64 27
%139 = load i8, i8* %138
%140 = zext i8 %139 to i32
%141 = or i32 %136, %140
%142 = load i8*, i8** %2
%143 = getelementptr inbounds i8, i8* %142, i64 28
%144 = load i8, i8* %143
%145 = zext i8 %144 to i32
%146 = or i32 %141, %145
%147 = load i8*, i8** %2
%148 = getelementptr inbounds i8, i8* %147, i64 29
%149 = load i8, i8* %148
%150 = zext i8 %149 to i32
%151 = or i32 %146, %150
%152 = load i8*, i8** %2
%153 = getelementptr inbounds i8, i8* %152, i64 30
%154 = load i8, i8* %153
%155 = zext i8 %154 to i32
%156 = or i32 %151, %155
%157 = load i8*, i8** %2
%158 = getelementptr inbounds i8, i8* %157, i64 31
%159 = load i8, i8* %158
%160 = zext i8 %159 to i32
%161 = or i32 %156, %160
%162 = sub nsw i32 %161, 1
%163 = ashr i32 %162, 8
%164 = add nsw i32 %163, 1
ret i32 %164
}

LLVM IR (-O2):
define i32 @sc_isnonzero(i8* %0) {
%2 = bitcast i8* %0 to <32 x i8>*
%3 = load <32 x i8>, <32 x i8>* %2
%4 = call i8 @llvm.vector.reduce.or.v32i8(<32 x i8> %3)
%5 = zext i8 %4 to i32
%6 = add nsw i32 %5, -1
%7 = ashr i32 %6, 8
%8 = add nsw i32 %7, 1
ret i32 %8
}