LLVM  13.0.0git
Macros
MD5.cpp File Reference
#include "llvm/Support/MD5.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/Endian.h"
#include "llvm/Support/Format.h"
#include "llvm/Support/raw_ostream.h"
#include <array>
#include <cstdint>
#include <cstring>
Include dependency graph for MD5.cpp:

Go to the source code of this file.

Macros

#define F(x, y, z)   ((z) ^ ((x) & ((y) ^ (z))))
 
#define G(x, y, z)   ((y) ^ ((z) & ((x) ^ (y))))
 
#define H(x, y, z)   ((x) ^ (y) ^ (z))
 
#define I(x, y, z)   ((y) ^ ((x) | ~(z)))
 
#define STEP(f, a, b, c, d, x, t, s)
 
#define SET(n)
 
#define GET(n)   (block[(n)])
 

Macro Definition Documentation

◆ F

#define F (   x,
  y,
  z 
)    ((z) ^ ((x) & ((y) ^ (z))))

Definition at line 56 of file MD5.cpp.

◆ G

#define G (   x,
  y,
  z 
)    ((y) ^ ((z) & ((x) ^ (y))))

Definition at line 57 of file MD5.cpp.

◆ GET

#define GET (   n)    (block[(n)])

Definition at line 74 of file MD5.cpp.

◆ H

#define H (   x,
  y,
  z 
)    ((x) ^ (y) ^ (z))

Definition at line 58 of file MD5.cpp.

◆ I

#define I (   x,
  y,
  z 
)    ((y) ^ ((x) | ~(z)))

Definition at line 59 of file MD5.cpp.

◆ SET

#define SET (   n)
Value:
(block[(n)] = \
(MD5_u32plus) ptr[(n) * 4] | ((MD5_u32plus) ptr[(n) * 4 + 1] << 8) | \
((MD5_u32plus) ptr[(n) * 4 + 2] << 16) | \
((MD5_u32plus) ptr[(n) * 4 + 3] << 24))

Definition at line 69 of file MD5.cpp.

◆ STEP

#define STEP (   f,
  a,
  b,
  c,
  d,
  x,
  t,
  s 
)
Value:
(a) += f((b), (c), (d)) + (x) + (t); \
(a) = (((a) << (s)) | (((a) & 0xffffffff) >> (32 - (s)))); \
(a) += (b);

Definition at line 62 of file MD5.cpp.

block
we get the following basic block
Definition: README_ALTIVEC.txt:95
a
=0.0 ? 0.0 :(a > 0.0 ? 1.0 :-1.0) a
Definition: README.txt:489
f
Itanium Name Demangler i e convert the string _Z1fv into f()". You can also use the CRTP base ManglingParser to perform some simple analysis on the mangled name
t
bitcast float %x to i32 %s=and i32 %t, 2147483647 %d=bitcast i32 %s to float ret float %d } declare float @fabsf(float %n) define float @bar(float %x) nounwind { %d=call float @fabsf(float %x) ret float %d } This IR(from PR6194):target datalayout="e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target triple="x86_64-apple-darwin10.0.0" %0=type { double, double } %struct.float3=type { float, float, float } define void @test(%0, %struct.float3 *nocapture %res) nounwind noinline ssp { entry:%tmp18=extractvalue %0 %0, 0 t
Definition: README-SSE.txt:788
b
the resulting code requires compare and branches when and if the revised code is with conditional branches instead of More there is a byte word extend before each where there should be only and the condition codes are not remembered when the same two values are compared twice More LSR enhancements i8 and i32 load store addressing modes are identical int b
Definition: README.txt:418
c
the resulting code requires compare and branches when and if the revised code is with conditional branches instead of More there is a byte word extend before each where there should be only and the condition codes are not remembered when the same two values are compared twice More LSR enhancements i8 and i32 load store addressing modes are identical int int c
Definition: README.txt:418
s
multiplies can be turned into SHL s
Definition: README.txt:370
x
TODO unsigned x
Definition: README.txt:10
d
the resulting code requires compare and branches when and if the revised code is with conditional branches instead of More there is a byte word extend before each where there should be only and the condition codes are not remembered when the same two values are compared twice More LSR enhancements i8 and i32 load store addressing modes are identical int int int d
Definition: README.txt:418
n
The same transformation can work with an even modulo with the addition of a and shrink the compare RHS by the same amount Unless the target supports that transformation probably isn t worthwhile The transformation can also easily be made to work with non zero equality for n
Definition: README.txt:685