Revision bdd19e29

View differences:

libavutil/arm/intreadwrite.h
25 25
#if HAVE_FAST_UNALIGNED && HAVE_INLINE_ASM
26 26

  
27 27
#define AV_RN16 AV_RN16
28
static inline uint16_t AV_RN16(const void *p)
28
static av_always_inline uint16_t AV_RN16(const void *p)
29 29
{
30 30
    uint16_t v;
31 31
    __asm__ ("ldrh %0, %1" : "=r"(v) : "m"(*(const uint16_t *)p));
......
33 33
}
34 34

  
35 35
#define AV_WN16 AV_WN16
36
static inline void AV_WN16(void *p, uint16_t v)
36
static av_always_inline void AV_WN16(void *p, uint16_t v)
37 37
{
38 38
    __asm__ ("strh %1, %0" : "=m"(*(uint16_t *)p) : "r"(v));
39 39
}
40 40

  
41 41
#define AV_RN32 AV_RN32
42
static inline uint32_t AV_RN32(const void *p)
42
static av_always_inline uint32_t AV_RN32(const void *p)
43 43
{
44 44
    uint32_t v;
45 45
    __asm__ ("ldr  %0, %1" : "=r"(v) : "m"(*(const uint32_t *)p));
......
47 47
}
48 48

  
49 49
#define AV_WN32 AV_WN32
50
static inline void AV_WN32(void *p, uint32_t v)
50
static av_always_inline void AV_WN32(void *p, uint32_t v)
51 51
{
52 52
    __asm__ ("str  %1, %0" : "=m"(*(uint32_t *)p) : "r"(v));
53 53
}
54 54

  
55 55
#define AV_RN64 AV_RN64
56
static inline uint64_t AV_RN64(const void *p)
56
static av_always_inline uint64_t AV_RN64(const void *p)
57 57
{
58 58
    union { uint64_t v; uint32_t hl[2]; } v;
59 59
    __asm__ ("ldr   %0, %2  \n\t"
......
64 64
}
65 65

  
66 66
#define AV_WN64 AV_WN64
67
static inline void AV_WN64(void *p, uint64_t v)
67
static av_always_inline void AV_WN64(void *p, uint64_t v)
68 68
{
69 69
    union { uint64_t v; uint32_t hl[2]; } vv = { v };
70 70
    __asm__ ("str  %2, %0  \n\t"
libavutil/avr32/intreadwrite.h
40 40
 */
41 41

  
42 42
#define AV_RL16 AV_RL16
43
static inline uint16_t AV_RL16(const void *p)
43
static av_always_inline uint16_t AV_RL16(const void *p)
44 44
{
45 45
    uint16_t v;
46 46
    __asm__ ("ld.ub    %0,   %1  \n\t"
......
51 51
}
52 52

  
53 53
#define AV_RB16 AV_RB16
54
static inline uint16_t AV_RB16(const void *p)
54
static av_always_inline uint16_t AV_RB16(const void *p)
55 55
{
56 56
    uint16_t v;
57 57
    __asm__ ("ld.ub    %0,   %2  \n\t"
......
62 62
}
63 63

  
64 64
#define AV_RB24 AV_RB24
65
static inline uint32_t AV_RB24(const void *p)
65
static av_always_inline uint32_t AV_RB24(const void *p)
66 66
{
67 67
    uint32_t v;
68 68
    __asm__ ("ld.ub    %0,   %3  \n\t"
......
76 76
}
77 77

  
78 78
#define AV_RL24 AV_RL24
79
static inline uint32_t AV_RL24(const void *p)
79
static av_always_inline uint32_t AV_RL24(const void *p)
80 80
{
81 81
    uint32_t v;
82 82
    __asm__ ("ld.ub    %0,   %1  \n\t"
......
92 92
#if ARCH_AVR32_AP
93 93

  
94 94
#define AV_RB32 AV_RB32
95
static inline uint32_t AV_RB32(const void *p)
95
static av_always_inline uint32_t AV_RB32(const void *p)
96 96
{
97 97
    uint32_t v;
98 98
    __asm__ ("ld.w %0, %1" : "=r"(v) : "m"(*(const uint32_t*)p));
......
100 100
}
101 101

  
102 102
#define AV_WB32 AV_WB32
103
static inline void AV_WB32(void *p, uint32_t v)
103
static av_always_inline void AV_WB32(void *p, uint32_t v)
104 104
{
105 105
    __asm__ ("st.w %0, %1" : "=m"(*(uint32_t*)p) : "r"(v));
106 106
}
......
110 110
#define AV_WL32(p, v) AV_WB32(p, bswap_32(v))
111 111

  
112 112
#define AV_WB64 AV_WB64
113
static inline void AV_WB64(void *p, uint64_t v)
113
static av_always_inline void AV_WB64(void *p, uint64_t v)
114 114
{
115 115
    union { uint64_t v; uint32_t hl[2]; } vv = { v };
116 116
    AV_WB32(p, vv.hl[0]);
......
118 118
}
119 119

  
120 120
#define AV_WL64 AV_WL64
121
static inline void AV_WL64(void *p, uint64_t v)
121
static av_always_inline void AV_WL64(void *p, uint64_t v)
122 122
{
123 123
    union { uint64_t v; uint32_t hl[2]; } vv = { v };
124 124
    AV_WL32(p, vv.hl[1]);
......
128 128
#else /* ARCH_AVR32_AP */
129 129

  
130 130
#define AV_RB32 AV_RB32
131
static inline uint32_t AV_RB32(const void *p)
131
static av_always_inline uint32_t AV_RB32(const void *p)
132 132
{
133 133
    uint32_t v;
134 134
    __asm__ ("ld.ub    %0,   %4  \n\t"
......
144 144
}
145 145

  
146 146
#define AV_RL32 AV_RL32
147
static inline uint32_t AV_RL32(const void *p)
147
static av_always_inline uint32_t AV_RL32(const void *p)
148 148
{
149 149
    uint32_t v;
150 150
    __asm__ ("ld.ub    %0,   %1  \n\t"
......
162 162
#endif /* ARCH_AVR32_AP */
163 163

  
164 164
#define AV_RB64 AV_RB64
165
static inline uint64_t AV_RB64(const void *p)
165
static av_always_inline uint64_t AV_RB64(const void *p)
166 166
{
167 167
    union { uint64_t v; uint32_t hl[2]; } v;
168 168
    v.hl[0] = AV_RB32(p);
......
171 171
}
172 172

  
173 173
#define AV_RL64 AV_RL64
174
static inline uint64_t AV_RL64(const void *p)
174
static av_always_inline uint64_t AV_RL64(const void *p)
175 175
{
176 176
    union { uint64_t v; uint32_t hl[2]; } v;
177 177
    v.hl[1] = AV_RL32(p);
libavutil/mips/intreadwrite.h
25 25
#include "config.h"
26 26

  
27 27
#define AV_RN32 AV_RN32
28
static inline uint32_t AV_RN32(const void *p)
28
static av_always_inline uint32_t AV_RN32(const void *p)
29 29
{
30 30
    uint32_t v;
31 31
    __asm__ ("lwl %0, %1  \n\t"
......
37 37
}
38 38

  
39 39
#define AV_WN32 AV_WN32
40
static inline void AV_WN32(void *p, uint32_t v)
40
static av_always_inline void AV_WN32(void *p, uint32_t v)
41 41
{
42 42
    __asm__ ("swl %2, %0  \n\t"
43 43
             "swr %2, %1  \n\t"
......
49 49
#if ARCH_MIPS64
50 50

  
51 51
#define AV_RN64 AV_RN64
52
static inline uint64_t AV_RN64(const void *p)
52
static av_always_inline uint64_t AV_RN64(const void *p)
53 53
{
54 54
    uint64_t v;
55 55
    __asm__ ("ldl %0, %1  \n\t"
......
61 61
}
62 62

  
63 63
#define AV_WN64 AV_WN64
64
static inline void AV_WN64(void *p, uint64_t v)
64
static av_always_inline void AV_WN64(void *p, uint64_t v)
65 65
{
66 66
    __asm__ ("sdl %2, %0  \n\t"
67 67
             "sdr %2, %1  \n\t"
......
73 73
#else
74 74

  
75 75
#define AV_RN64 AV_RN64
76
static inline uint64_t AV_RN64(const void *p)
76
static av_always_inline uint64_t AV_RN64(const void *p)
77 77
{
78 78
    union { uint64_t v; uint32_t hl[2]; } v;
79 79
    v.hl[0] = AV_RN32(p);
......
82 82
}
83 83

  
84 84
#define AV_WN64 AV_WN64
85
static inline void AV_WN64(void *p, uint64_t v)
85
static av_always_inline void AV_WN64(void *p, uint64_t v)
86 86
{
87 87
    union { uint64_t v; uint32_t hl[2]; } vv = { v };
88 88
    AV_WN32(p, vv.hl[0]);
libavutil/ppc/intreadwrite.h
27 27
#if HAVE_XFORM_ASM
28 28

  
29 29
#define AV_RL16 AV_RL16
30
static inline uint16_t AV_RL16(const void *p)
30
static av_always_inline uint16_t AV_RL16(const void *p)
31 31
{
32 32
    uint16_t v;
33 33
    __asm__ ("lhbrx   %0, %y1" : "=r"(v) : "Z"(*(const uint16_t*)p));
......
35 35
}
36 36

  
37 37
#define AV_WL16 AV_WL16
38
static inline void AV_WL16(void *p, uint16_t v)
38
static av_always_inline void AV_WL16(void *p, uint16_t v)
39 39
{
40 40
    __asm__ ("sthbrx  %1, %y0" : "=Z"(*(uint16_t*)p) : "r"(v));
41 41
}
42 42

  
43 43
#define AV_RL32 AV_RL32
44
static inline uint32_t AV_RL32(const void *p)
44
static av_always_inline uint32_t AV_RL32(const void *p)
45 45
{
46 46
    uint32_t v;
47 47
    __asm__ ("lwbrx   %0, %y1" : "=r"(v) : "Z"(*(const uint32_t*)p));
......
49 49
}
50 50

  
51 51
#define AV_WL32 AV_WL32
52
static inline void AV_WL32(void *p, uint32_t v)
52
static av_always_inline void AV_WL32(void *p, uint32_t v)
53 53
{
54 54
    __asm__ ("stwbrx  %1, %y0" : "=Z"(*(uint32_t*)p) : "r"(v));
55 55
}
......
57 57
#if HAVE_LDBRX
58 58

  
59 59
#define AV_RL64 AV_RL64
60
static inline uint64_t AV_RL64(const void *p)
60
static av_always_inline uint64_t AV_RL64(const void *p)
61 61
{
62 62
    uint64_t v;
63 63
    __asm__ ("ldbrx   %0, %y1" : "=r"(v) : "Z"(*(const uint64_t*)p));
......
65 65
}
66 66

  
67 67
#define AV_WL64 AV_WL64
68
static inline void AV_WL64(void *p, uint64_t v)
68
static av_always_inline void AV_WL64(void *p, uint64_t v)
69 69
{
70 70
    __asm__ ("stdbrx  %1, %y0" : "=Z"(*(uint64_t*)p) : "r"(v));
71 71
}
......
73 73
#else
74 74

  
75 75
#define AV_RL64 AV_RL64
76
static inline uint64_t AV_RL64(const void *p)
76
static av_always_inline uint64_t AV_RL64(const void *p)
77 77
{
78 78
    union { uint64_t v; uint32_t hl[2]; } v;
79 79
    __asm__ ("lwbrx   %0, %y2  \n\t"
......
84 84
}
85 85

  
86 86
#define AV_WL64 AV_WL64
87
static inline void AV_WL64(void *p, uint64_t v)
87
static av_always_inline void AV_WL64(void *p, uint64_t v)
88 88
{
89 89
    union { uint64_t v; uint32_t hl[2]; } vv = { v };
90 90
    __asm__ ("stwbrx  %2, %y0  \n\t"

Also available in: Unified diff