Blame - include/atomic - fp2-dev/platform/external/libcxx

Howard Hinnant

8f73c63

2010-09-27 21:17:38 +0000

[diff] [blame^]

1

// -*- C++ -*-

2

//===--------------------------- atomic -----------------------------------===//

3

//

4

// The LLVM Compiler Infrastructure

5

//

6

// This file is distributed under the University of Illinois Open Source

7

// License. See LICENSE.TXT for details.

8

//

9

//===----------------------------------------------------------------------===//

10

11

#ifndef _LIBCPP_ATOMIC

12

#define _LIBCPP_ATOMIC

/*

atomic synopsis

namespace std

{

// order and consistency

21

22

typedef enum memory_order

23

{

24

memory_order_relaxed, memory_order_consume, memory_order_acquire,

25

memory_order_release, memory_order_acq_rel, memory_order_seq_cst

26

} memory_order;

27

28

template <class T> T kill_dependency(T y);

29

30

// lock-free property

31

32

#define ATOMIC_CHAR_LOCK_FREE unspecified

33

#define ATOMIC_CHAR16_T_LOCK_FREE unspecified

34

#define ATOMIC_CHAR32_T_LOCK_FREE unspecified

35

#define ATOMIC_WCHAR_T_LOCK_FREE unspecified

36

#define ATOMIC_SHORT_LOCK_FREE unspecified

37

#define ATOMIC_INT_LOCK_FREE unspecified

38

#define ATOMIC_LONG_LOCK_FREE unspecified

39

#define ATOMIC_LLONG_LOCK_FREE unspecified

40

#define ATOMIC_ADDRESS_LOCK_FREE unspecified

41

42

// operations on atomic types

43

44

#define ATOMIC_VAR_INIT(value) see below

45

46

// flag type and operations

47

48

typedef struct atomic_flag

49

{

50

bool test_and_set(memory_order = memory_order_seq_cst) volatile;

51

bool test_and_set(memory_order = memory_order_seq_cst);

52

void clear(memory_order = memory_order_seq_cst) volatile;

53

void clear(memory_order = memory_order_seq_cst);

54

atomic_flag() = default;

55

atomic_flag(const atomic_flag&) = delete;

56

atomic_flag& operator=(const atomic_flag&) = delete;

57

atomic_flag& operator=(const atomic_flag&) volatile = delete;

58

} atomic_flag;

59

60

bool atomic_flag_test_and_set(volatile atomic_flag*);

61

bool atomic_flag_test_and_set(atomic_flag*);

62

bool atomic_flag_test_and_set_explicit(volatile atomic_flag*, memory_order);

63

bool atomic_flag_test_and_set_explicit(atomic_flag*, memory_order);

64

void atomic_flag_clear(volatile atomic_flag*);

65

void atomic_flag_clear(atomic_flag*);

66

void atomic_flag_clear_explicit(volatile atomic_flag*, memory_order);

67

void atomic_flag_clear_explicit(atomic_flag*, memory_order);

68

69

#define ATOMIC_FLAG_INIT see below

// atomic_bool

typedef struct atomic_bool

74

{

75

bool is_lock_free() const volatile;

76

bool is_lock_free() const;

77

void store(bool, memory_order = memory_order_seq_cst) volatile;

78

void store(bool, memory_order = memory_order_seq_cst);

79

bool load(memory_order = memory_order_seq_cst) const volatile;

80

bool load(memory_order = memory_order_seq_cst) const;

81

operator bool() const volatile;

82

operator bool() const;

83

bool exchange(bool, memory_order = memory_order_seq_cst) volatile;

84

bool exchange(bool, memory_order = memory_order_seq_cst);

85

bool compare_exchange_weak(bool&, bool, memory_order,

86

memory_order) volatile;

87

bool compare_exchange_weak(bool&, bool, memory_order, memory_order);

88

bool compare_exchange_strong(bool&, bool, memory_order,

89

memory_order) volatile;

90

bool compare_exchange_strong(bool&, bool, memory_order, memory_order);

91

bool compare_exchange_weak(bool&, bool,

92

memory_order = memory_order_seq_cst) volatile;

93

bool compare_exchange_weak(bool&, bool,

94

memory_order = memory_order_seq_cst);

95

bool compare_exchange_strong(bool&, bool,

96

memory_order = memory_order_seq_cst) volatile;

97

bool compare_exchange_strong(bool&, bool,

98

memory_order = memory_order_seq_cst);

99

atomic_bool() = default;

100

constexpr atomic_bool(bool);

101

atomic_bool(const atomic_bool&) = delete;

102

atomic_bool& operator=(const atomic_bool&) = delete;

103

atomic_bool& operator=(const atomic_bool&) volatile = delete;

104

bool operator=(bool) volatile;

105

} atomic_bool;

106

107

bool atomic_is_lock_free(const volatile atomic_bool*);

108

bool atomic_is_lock_free(const atomic_bool*);

109

void atomic_init(volatile atomic_bool*, bool);

110

void atomic_init(atomic_bool*, bool);

111

void atomic_store(volatile atomic_bool*, bool);

112

void atomic_store(atomic_bool*, bool);

113

void atomic_store_explicit(volatile atomic_bool*, bool, memory_order);

114

void atomic_store_explicit(atomic_bool*, bool, memory_order);

115

bool atomic_load(const volatile atomic_bool*);

116

bool atomic_load(const atomic_bool*);

117

bool atomic_load_explicit(const volatile atomic_bool*, memory_order);

118

bool atomic_load_explicit(const atomic_bool*, memory_order);

119

bool atomic_exchange(volatile atomic_bool*, bool);

120

bool atomic_exchange(atomic_bool*, bool);

121

bool atomic_exchange_explicit(volatile atomic_bool*, bool, memory_order);

122

bool atomic_exchange_explicit(atomic_bool*, bool, memory_order);

123

bool atomic_compare_exchange_weak(volatile atomic_bool*, bool*, bool);

124

bool atomic_compare_exchange_weak(atomic_bool*, bool*, bool);

125

bool atomic_compare_exchange_strong(volatile atomic_bool*, bool*, bool);

126

bool atomic_compare_exchange_strong(atomic_bool*, bool*, bool);

127

bool atomic_compare_exchange_weak_explicit(volatile atomic_bool*, bool*, bool,

128

memory_order, memory_order);

129

bool atomic_compare_exchange_weak_explicit(atomic_bool*, bool*, bool,

130

memory_order, memory_order);

131

bool atomic_compare_exchange_strong_explicit(volatile atomic_bool*, bool*, bool,

132

memory_order, memory_order);

133

bool atomic_compare_exchange_strong_explicit(atomic_bool*, bool*, bool,

134

memory_order, memory_order);

// atomic_char

typedef struct atomic_char

139

{

140

bool is_lock_free() const volatile;

141

bool is_lock_free() const;

142

void store(char, memory_order = memory_order_seq_cst) volatile;

143

void store(char, memory_order = memory_order_seq_cst);

144

char load(memory_order = memory_order_seq_cst) const volatile;

145

char load(memory_order = memory_order_seq_cst) const;

146

operator char() const volatile;

147

operator char() const;

148

char exchange(char,

149

memory_order = memory_order_seq_cst) volatile;

150

char exchange(char, memory_order = memory_order_seq_cst);

151

bool compare_exchange_weak(char&, char, memory_order,

152

memory_order) volatile;

153

bool compare_exchange_weak(char&, char, memory_order, memory_order);

154

bool compare_exchange_strong(char&, char, memory_order,

155

memory_order) volatile;

156

bool compare_exchange_strong(char&, char, memory_order, memory_order);

157

bool compare_exchange_weak(char&, char,

158

memory_order = memory_order_seq_cst) volatile;

159

bool compare_exchange_weak(char&, char,

160

memory_order = memory_order_seq_cst);

161

bool compare_exchange_strong(char&, char,

162

memory_order = memory_order_seq_cst) volatile;

163

bool compare_exchange_strong(char&, char,

164

memory_order = memory_order_seq_cst);

165

char fetch_add(char, memory_order = memory_order_seq_cst) volatile;

166

char fetch_add(char, memory_order = memory_order_seq_cst);

167

char fetch_sub(char, memory_order = memory_order_seq_cst) volatile;

168

char fetch_sub(char, memory_order = memory_order_seq_cst);

169

char fetch_and(char, memory_order = memory_order_seq_cst) volatile;

170

char fetch_and(char, memory_order = memory_order_seq_cst);

171

char fetch_or(char, memory_order = memory_order_seq_cst) volatile;

172

char fetch_or(char, memory_order = memory_order_seq_cst);

173

char fetch_xor(char, memory_order = memory_order_seq_cst) volatile;

174

char fetch_xor(char, memory_order = memory_order_seq_cst);

175

atomic_char() = default;

176

constexpr atomic_char(char);

177

atomic_char(const atomic_char&) = delete;

178

atomic_char& operator=(const atomic_char&) = delete;

179

atomic_char& operator=(const atomic_char&) volatile = delete;

180

char operator=(char) volatile;

181

char operator=(char);

182

char operator++(int) volatile;

183

char operator++(int);

184

char operator--(int) volatile;

185

char operator--(int);

186

char operator++() volatile;

187

char operator++();

188

char operator--() volatile;

189

char operator--();

190

char operator+=(char) volatile;

191

char operator+=(char);

192

char operator-=(char) volatile;

193

char operator-=(char);

194

char operator&=(char) volatile;

195

char operator&=(char);

196

char operator|=(char) volatile;

197

char operator|=(char);

198

char operator^=(char) volatile;

199

char operator^=(char);

200

} atomic_char;

201

202

bool atomic_is_lock_free(const volatile atomic_char*);

203

bool atomic_is_lock_free(const atomic_char*);

204

void atomic_init(volatile atomic_char*, itype);

205

void atomic_init(atomic_char*, itype);

206

void atomic_store(volatile atomic_char*, char);

207

void atomic_store(atomic_char*, char);

208

void atomic_store_explicit(volatile atomic_char*, char, memory_order);

209

void atomic_store_explicit(atomic_char*, char, memory_order);

210

char atomic_load(const volatile atomic_char*);

211

char atomic_load(const atomic_char*);

212

char atomic_load_explicit(const volatile atomic_char*, memory_order);

213

char atomic_load_explicit(const atomic_char*, memory_order);

214

char atomic_exchange(volatile atomic_char*, char);

215

char atomic_exchange(atomic_char*, char);

216

char atomic_exchange_explicit(volatile atomic_char*, char, memory_order);

217

char atomic_exchange_explicit(atomic_char*, char, memory_order);

218

bool atomic_compare_exchange_weak(volatile atomic_char*, char*, char);

219

bool atomic_compare_exchange_weak(atomic_char*, char*, char);

220

bool atomic_compare_exchange_strong(volatile atomic_char*, char*, char);

221

bool atomic_compare_exchange_strong(atomic_char*, char*, char);

222

bool atomic_compare_exchange_weak_explicit(volatile atomic_char*, char*, char,

223

memory_order, memory_order);

224

bool atomic_compare_exchange_weak_explicit(atomic_char*, char*, char,

225

memory_order, memory_order);

226

bool atomic_compare_exchange_strong_explicit(volatile atomic_char*, char*, char,

227

memory_order, memory_order);

228

bool atomic_compare_exchange_strong_explicit(atomic_char*, char*, char,

229

memory_order, memory_order);

230

char atomic_fetch_add(volatile atomic_char*, char);

231

char atomic_fetch_add(atomic_char*, char);

232

char atomic_fetch_add_explicit(volatile atomic_char*, char, memory_order);

233

char atomic_fetch_add_explicit(atomic_char*, char, memory_order);

234

char atomic_fetch_sub(volatile atomic_char*, char);

235

char atomic_fetch_sub(atomic_char*, char);

236

char atomic_fetch_sub_explicit(volatile atomic_char*, char, memory_order);

237

char atomic_fetch_sub_explicit(atomic_char*, char, memory_order);

238

char atomic_fetch_and(volatile atomic_char*, char);

239

char atomic_fetch_and(atomic_char*, char);

240

char atomic_fetch_and_explicit(volatile atomic_char*, char, memory_order);

241

char atomic_fetch_and_explicit(atomic_char*, char, memory_order);

242

char atomic_fetch_or(volatile atomic_char*, char);

243

char atomic_fetch_or(atomic_char*, char);

244

char atomic_fetch_or_explicit(volatile atomic_char*, char, memory_order);

245

char atomic_fetch_or_explicit(atomic_char*, char, memory_order);

246

char atomic_fetch_xor(volatile atomic_char*, char);

247

char atomic_fetch_xor(atomic_char*, char);

248

char atomic_fetch_xor_explicit(volatile atomic_char*, char, memory_order);

249

char atomic_fetch_xor_explicit(atomic_char*, char, memory_order);

// atomic_schar

typedef struct atomic_schar

254

{

255

bool is_lock_free() const volatile;

256

bool is_lock_free() const;

257

void store(signed char, memory_order = memory_order_seq_cst) volatile;

258

void store(signed char, memory_order = memory_order_seq_cst);

259

signed char load(memory_order = memory_order_seq_cst) const volatile;

260

signed char load(memory_order = memory_order_seq_cst) const;

261

operator signed char() const volatile;

262

operator signed char() const;

263

signed char exchange(signed char,

264

memory_order = memory_order_seq_cst) volatile;

265

signed char exchange(signed char, memory_order = memory_order_seq_cst);

266

bool compare_exchange_weak(signed char&, signed char, memory_order,

267

memory_order) volatile;

268

bool compare_exchange_weak(signed char&, signed char, memory_order,

269

memory_order);

270

bool compare_exchange_strong(signed char&, signed char, memory_order,

271

memory_order) volatile;

272

bool compare_exchange_strong(signed char&, signed char, memory_order,

273

memory_order);

274

bool compare_exchange_weak(signed char&, signed char,

275

memory_order = memory_order_seq_cst) volatile;

276

bool compare_exchange_weak(signed char&, signed char,

277

memory_order = memory_order_seq_cst);

278

bool compare_exchange_strong(signed char&, signed char,

279

memory_order = memory_order_seq_cst) volatile;

280

bool compare_exchange_strong(signed char&, signed char,

281

memory_order = memory_order_seq_cst);

282

signed char fetch_add(signed char,

283

memory_order = memory_order_seq_cst) volatile;

284

signed char fetch_add(signed char, memory_order = memory_order_seq_cst);

285

signed char fetch_sub(signed char,

286

memory_order = memory_order_seq_cst) volatile;

287

signed char fetch_sub(signed char, memory_order = memory_order_seq_cst);

288

signed char fetch_and(signed char,

289

memory_order = memory_order_seq_cst) volatile;

290

signed char fetch_and(signed char, memory_order = memory_order_seq_cst);

291

signed char fetch_or(signed char,

292

memory_order = memory_order_seq_cst) volatile;

293

signed char fetch_or(signed char, memory_order = memory_order_seq_cst);

294

signed char fetch_xor(signed char,

295

memory_order = memory_order_seq_cst) volatile;

296

signed char fetch_xor(signed char, memory_order = memory_order_seq_cst);

297

atomic_schar() = default;

298

constexpr atomic_schar(signed char);

299

atomic_schar(const atomic_schar&) = delete;

300

atomic_schar& operator=(const atomic_schar&) = delete;

301

atomic_schar& operator=(const atomic_schar&) volatile = delete;

302

signed char operator=(signed char) volatile;

303

signed char operator=(signed char);

304

signed char operator++(int) volatile;

305

signed char operator++(int);

306

signed char operator--(int) volatile;

307

signed char operator--(int);

308

signed char operator++() volatile;

309

signed char operator++();

310

signed char operator--() volatile;

311

signed char operator--();

312

signed char operator+=(signed char) volatile;

313

signed char operator+=(signed char);

314

signed char operator-=(signed char) volatile;

315

signed char operator-=(signed char);

316

signed char operator&=(signed char) volatile;

317

signed char operator&=(signed char);

318

signed char operator|=(signed char) volatile;

319

signed char operator|=(signed char);

320

signed char operator^=(signed char) volatile;

321

signed char operator^=(signed char);

322

} atomic_schar;

323

324

bool atomic_is_lock_free(const volatile atomic_schar*);

325

bool atomic_is_lock_free(const atomic_schar*);

326

void atomic_init(volatile atomic_schar*, itype);

327

void atomic_init(atomic_schar*, itype);

328

void atomic_store(volatile atomic_schar*, signed char);

329

void atomic_store(atomic_schar*, signed char);

330

void atomic_store_explicit(volatile atomic_schar*, signed char, memory_order);

331

void atomic_store_explicit(atomic_schar*, signed char, memory_order);

332

signed char atomic_load(const volatile atomic_schar*);

333

signed char atomic_load(const atomic_schar*);

334

signed char atomic_load_explicit(const volatile atomic_schar*, memory_order);

335

signed char atomic_load_explicit(const atomic_schar*, memory_order);

336

signed char atomic_exchange(volatile atomic_schar*, signed char);

337

signed char atomic_exchange(atomic_schar*, signed char);

338

signed char atomic_exchange_explicit(volatile atomic_schar*, signed char,

339

memory_order);

340

signed char atomic_exchange_explicit(atomic_schar*, signed char, memory_order);

341

bool atomic_compare_exchange_weak(volatile atomic_schar*, signed char*,

342

signed char);

343

bool atomic_compare_exchange_weak(atomic_schar*, signed char*, signed char);

344

bool atomic_compare_exchange_strong(volatile atomic_schar*, signed char*,

345

signed char);

346

bool atomic_compare_exchange_strong(atomic_schar*, signed char*, signed char);

347

bool atomic_compare_exchange_weak_explicit(volatile atomic_schar*, signed char*,

348

signed char, memory_order,

349

memory_order);

350

bool atomic_compare_exchange_weak_explicit(atomic_schar*, signed char*,

351

signed char, memory_order,

352

memory_order);

353

bool atomic_compare_exchange_strong_explicit(volatile atomic_schar*,

354

signed char*, signed char,

355

memory_order, memory_order);

356

bool atomic_compare_exchange_strong_explicit(atomic_schar*, signed char*,

357

signed char, memory_order, memory_order);

358

signed char atomic_fetch_add(volatile atomic_schar*, signed char);

359

signed char atomic_fetch_add(atomic_schar*, signed char);

360

signed char atomic_fetch_add_explicit(volatile atomic_schar*, signed char,

361

memory_order);

362

signed char atomic_fetch_add_explicit(atomic_schar*, signed char, memory_order);

363

signed char atomic_fetch_sub(volatile atomic_schar*, signed char);

364

signed char atomic_fetch_sub(atomic_schar*, signed char);

365

signed char atomic_fetch_sub_explicit(volatile atomic_schar*, signed char,

366

memory_order);

367

signed char atomic_fetch_sub_explicit(atomic_schar*, signed char, memory_order);

368

signed char atomic_fetch_and(volatile atomic_schar*, signed char);

369

signed char atomic_fetch_and(atomic_schar*, signed char);

370

signed char atomic_fetch_and_explicit(volatile atomic_schar*, signed char,

371

memory_order);

372

signed char atomic_fetch_and_explicit(atomic_schar*, signed char, memory_order);

373

signed char atomic_fetch_or(volatile atomic_schar*, signed char);

374

signed char atomic_fetch_or(atomic_schar*, signed char);

375

signed char atomic_fetch_or_explicit(volatile atomic_schar*, signed char,

376

memory_order);

377

signed char atomic_fetch_or_explicit(atomic_schar*, signed char, memory_order);

378

signed char atomic_fetch_xor(volatile atomic_schar*, signed char);

379

signed char atomic_fetch_xor(atomic_schar*, signed char);

380

signed char atomic_fetch_xor_explicit(volatile atomic_schar*, signed char,

381

memory_order);

382

signed char atomic_fetch_xor_explicit(atomic_schar*, signed char, memory_order);

// atomic_uchar

typedef struct atomic_uchar

387

{

388

bool is_lock_free() const volatile;

389

bool is_lock_free() const;

390

void store(unsigned char, memory_order = memory_order_seq_cst) volatile;

391

void store(unsigned char, memory_order = memory_order_seq_cst);

392

unsigned char load(memory_order = memory_order_seq_cst) const volatile;

393

unsigned char load(memory_order = memory_order_seq_cst) const;

394

operator unsigned char() const volatile;

395

operator unsigned char() const;

396

unsigned char exchange(unsigned char,

397

memory_order = memory_order_seq_cst) volatile;

398

unsigned char exchange(unsigned char, memory_order = memory_order_seq_cst);

399

bool compare_exchange_weak(unsigned char&, unsigned char, memory_order,

400

memory_order) volatile;

401

bool compare_exchange_weak(unsigned char&, unsigned char, memory_order,

402

memory_order);

403

bool compare_exchange_strong(unsigned char&, unsigned char, memory_order,

404

memory_order) volatile;

405

bool compare_exchange_strong(unsigned char&, unsigned char, memory_order,

406

memory_order);

407

bool compare_exchange_weak(unsigned char&, unsigned char,

408

memory_order = memory_order_seq_cst) volatile;

409

bool compare_exchange_weak(unsigned char&, unsigned char,

410

memory_order = memory_order_seq_cst);

411

bool compare_exchange_strong(unsigned char&, unsigned char,

412

memory_order = memory_order_seq_cst) volatile;

413

bool compare_exchange_strong(unsigned char&, unsigned char,

414

memory_order = memory_order_seq_cst);

415

unsigned char fetch_add(unsigned char,

416

memory_order = memory_order_seq_cst) volatile;

417

unsigned char fetch_add(unsigned char, memory_order = memory_order_seq_cst);

418

unsigned char fetch_sub(unsigned char,

419

memory_order = memory_order_seq_cst) volatile;

420

unsigned char fetch_sub(unsigned char, memory_order = memory_order_seq_cst);

421

unsigned char fetch_and(unsigned char,

422

memory_order = memory_order_seq_cst) volatile;

423

unsigned char fetch_and(unsigned char, memory_order = memory_order_seq_cst);

424

unsigned char fetch_or(unsigned char,

425

memory_order = memory_order_seq_cst) volatile;

426

unsigned char fetch_or(unsigned char, memory_order = memory_order_seq_cst);

427

unsigned char fetch_xor(unsigned char,

428

memory_order = memory_order_seq_cst) volatile;

429

unsigned char fetch_xor(unsigned char, memory_order = memory_order_seq_cst);

430

atomic_uchar() = default;

431

constexpr atomic_uchar(unsigned char);

432

atomic_uchar(const atomic_uchar&) = delete;

433

atomic_uchar& operator=(const atomic_uchar&) = delete;

434

atomic_uchar& operator=(const atomic_uchar&) volatile = delete;

435

unsigned char operator=(unsigned char) volatile;

436

unsigned char operator=(unsigned char);

437

unsigned char operator++(int) volatile;

438

unsigned char operator++(int);

439

unsigned char operator--(int) volatile;

440

unsigned char operator--(int);

441

unsigned char operator++() volatile;

442

unsigned char operator++();

443

unsigned char operator--() volatile;

444

unsigned char operator--();

445

unsigned char operator+=(unsigned char) volatile;

446

unsigned char operator+=(unsigned char);

447

unsigned char operator-=(unsigned char) volatile;

448

unsigned char operator-=(unsigned char);

449

unsigned char operator&=(unsigned char) volatile;

450

unsigned char operator&=(unsigned char);

451

unsigned char operator|=(unsigned char) volatile;

452

unsigned char operator|=(unsigned char);

453

unsigned char operator^=(unsigned char) volatile;

454

unsigned char operator^=(unsigned char);

455

} atomic_uchar;

456

457

bool atomic_is_lock_free(const volatile atomic_uchar*);

458

bool atomic_is_lock_free(const atomic_uchar*);

459

void atomic_init(volatile atomic_uchar*, itype);

460

void atomic_init(atomic_uchar*, itype);

461

void atomic_store(volatile atomic_uchar*, unsigned char);

462

void atomic_store(atomic_uchar*, unsigned char);

463

void atomic_store_explicit(volatile atomic_uchar*, unsigned char, memory_order);

464

void atomic_store_explicit(atomic_uchar*, unsigned char, memory_order);

465

unsigned char atomic_load(const volatile atomic_uchar*);

466

unsigned char atomic_load(const atomic_uchar*);

467

unsigned char atomic_load_explicit(const volatile atomic_uchar*, memory_order);

468

unsigned char atomic_load_explicit(const atomic_uchar*, memory_order);

469

unsigned char atomic_exchange(volatile atomic_uchar*, unsigned char);

470

unsigned char atomic_exchange(atomic_uchar*, unsigned char);

471

unsigned char atomic_exchange_explicit(volatile atomic_uchar*, unsigned char,

472

memory_order);

473

unsigned char atomic_exchange_explicit(atomic_uchar*, unsigned char,

474

memory_order);

475

bool atomic_compare_exchange_weak(volatile atomic_uchar*, unsigned char*,

476

unsigned char);

477

bool atomic_compare_exchange_weak(atomic_uchar*, unsigned char*, unsigned char);

478

bool atomic_compare_exchange_strong(volatile atomic_uchar*, unsigned char*,

479

unsigned char);

480

bool atomic_compare_exchange_strong(atomic_uchar*, unsigned char*,

481

unsigned char);

482

bool atomic_compare_exchange_weak_explicit(volatile atomic_uchar*,

483

unsigned char*, unsigned char,

484

memory_order, memory_order);

485

bool atomic_compare_exchange_weak_explicit(atomic_uchar*, unsigned char*,

486

unsigned char, memory_order,

487

memory_order);

488

bool atomic_compare_exchange_strong_explicit(volatile atomic_uchar*,

489

unsigned char*, unsigned char,

490

memory_order, memory_order);

491

bool atomic_compare_exchange_strong_explicit(atomic_uchar*, unsigned char*,

492

unsigned char, memory_order,

493

memory_order);

494

unsigned char atomic_fetch_add(volatile atomic_uchar*, unsigned char);

495

unsigned char atomic_fetch_add(atomic_uchar*, unsigned char);

496

unsigned char atomic_fetch_add_explicit(volatile atomic_uchar*, unsigned char,

497

memory_order);

498

unsigned char atomic_fetch_add_explicit(atomic_uchar*, unsigned char,

499

memory_order);

500

unsigned char atomic_fetch_sub(volatile atomic_uchar*, unsigned char);

501

unsigned char atomic_fetch_sub(atomic_uchar*, unsigned char);

502

unsigned char atomic_fetch_sub_explicit(volatile atomic_uchar*, unsigned char,

503

memory_order);

504

unsigned char atomic_fetch_sub_explicit(atomic_uchar*, unsigned char,

505

memory_order);

506

unsigned char atomic_fetch_and(volatile atomic_uchar*, unsigned char);

507

unsigned char atomic_fetch_and(atomic_uchar*, unsigned char);

508

unsigned char atomic_fetch_and_explicit(volatile atomic_uchar*, unsigned char,

509

memory_order);

510

unsigned char atomic_fetch_and_explicit(atomic_uchar*, unsigned char,

511

memory_order);

512

unsigned char atomic_fetch_or(volatile atomic_uchar*, unsigned char);

513

unsigned char atomic_fetch_or(atomic_uchar*, unsigned char);

514

unsigned char atomic_fetch_or_explicit(volatile atomic_uchar*, unsigned char,

515

memory_order);

516

unsigned char atomic_fetch_or_explicit(atomic_uchar*, unsigned char,

517

memory_order);

518

unsigned char atomic_fetch_xor(volatile atomic_uchar*, unsigned char);

519

unsigned char atomic_fetch_xor(atomic_uchar*, unsigned char);

520

unsigned char atomic_fetch_xor_explicit(volatile atomic_uchar*, unsigned char,

521

memory_order);

522

unsigned char atomic_fetch_xor_explicit(atomic_uchar*, unsigned char,

memory_order);

// atomic_short

typedef struct atomic_short

528

{

529

bool is_lock_free() const volatile;

530

bool is_lock_free() const;

531

void store(short, memory_order = memory_order_seq_cst) volatile;

532

void store(short, memory_order = memory_order_seq_cst);

533

short load(memory_order = memory_order_seq_cst) const volatile;

534

short load(memory_order = memory_order_seq_cst) const;

535

operator short() const volatile;

536

operator short() const;

537

short exchange(short,

538

memory_order = memory_order_seq_cst) volatile;

539

short exchange(short, memory_order = memory_order_seq_cst);

540

bool compare_exchange_weak(short&, short, memory_order,

541

memory_order) volatile;

542

bool compare_exchange_weak(short&, short, memory_order, memory_order);

543

bool compare_exchange_strong(short&, short, memory_order,

544

memory_order) volatile;

545

bool compare_exchange_strong(short&, short, memory_order, memory_order);

546

bool compare_exchange_weak(short&, short,

547

memory_order = memory_order_seq_cst) volatile;

548

bool compare_exchange_weak(short&, short,

549

memory_order = memory_order_seq_cst);

550

bool compare_exchange_strong(short&, short,

551

memory_order = memory_order_seq_cst) volatile;

552

bool compare_exchange_strong(short&, short,

553

memory_order = memory_order_seq_cst);

554

short fetch_add(short, memory_order = memory_order_seq_cst) volatile;

555

short fetch_add(short, memory_order = memory_order_seq_cst);

556

short fetch_sub(short, memory_order = memory_order_seq_cst) volatile;

557

short fetch_sub(short, memory_order = memory_order_seq_cst);

558

short fetch_and(short, memory_order = memory_order_seq_cst) volatile;

559

short fetch_and(short, memory_order = memory_order_seq_cst);

560

short fetch_or(short, memory_order = memory_order_seq_cst) volatile;

561

short fetch_or(short, memory_order = memory_order_seq_cst);

562

short fetch_xor(short, memory_order = memory_order_seq_cst) volatile;

563

short fetch_xor(short, memory_order = memory_order_seq_cst);

564

atomic_short() = default;

565

constexpr atomic_short(short);

566

atomic_short(const atomic_short&) = delete;

567

atomic_short& operator=(const atomic_short&) = delete;

568

atomic_short& operator=(const atomic_short&) volatile = delete;

569

short operator=(short) volatile;

570

short operator=(short);

571

short operator++(int) volatile;

572

short operator++(int);

573

short operator--(int) volatile;

574

short operator--(int);

575

short operator++() volatile;

576

short operator++();

577

short operator--() volatile;

578

short operator--();

579

short operator+=(short) volatile;

580

short operator+=(short);

581

short operator-=(short) volatile;

582

short operator-=(short);

583

short operator&=(short) volatile;

584

short operator&=(short);

585

short operator|=(short) volatile;

586

short operator|=(short);

587

short operator^=(short) volatile;

588

short operator^=(short);

589

} atomic_short;

590

591

bool atomic_is_lock_free(const volatile atomic_short*);

592

bool atomic_is_lock_free(const atomic_short*);

593

void atomic_init(volatile atomic_short*, itype);

594

void atomic_init(atomic_short*, itype);

595

void atomic_store(volatile atomic_short*, short);

596

void atomic_store(atomic_short*, short);

597

void atomic_store_explicit(volatile atomic_short*, short, memory_order);

598

void atomic_store_explicit(atomic_short*, short, memory_order);

599

short atomic_load(const volatile atomic_short*);

600

short atomic_load(const atomic_short*);

601

short atomic_load_explicit(const volatile atomic_short*, memory_order);

602

short atomic_load_explicit(const atomic_short*, memory_order);

603

short atomic_exchange(volatile atomic_short*, short);

604

short atomic_exchange(atomic_short*, short);

605

short atomic_exchange_explicit(volatile atomic_short*, short, memory_order);

606

short atomic_exchange_explicit(atomic_short*, short, memory_order);

607

bool atomic_compare_exchange_weak(volatile atomic_short*, short*, short);

608

bool atomic_compare_exchange_weak(atomic_short*, short*, short);

609

bool atomic_compare_exchange_strong(volatile atomic_short*, short*, short);

610

bool atomic_compare_exchange_strong(atomic_short*, short*, short);

611

bool atomic_compare_exchange_weak_explicit(volatile atomic_short*, short*,

612

short, memory_order, memory_order);

613

bool atomic_compare_exchange_weak_explicit(atomic_short*, short*, short,

614

memory_order, memory_order);

615

bool atomic_compare_exchange_strong_explicit(volatile atomic_short*, short*,

616

short, memory_order, memory_order);

617

bool atomic_compare_exchange_strong_explicit(atomic_short*, short*, short,

618

memory_order, memory_order);

619

short atomic_fetch_add(volatile atomic_short*, short);

620

short atomic_fetch_add(atomic_short*, short);

621

short atomic_fetch_add_explicit(volatile atomic_short*, short, memory_order);

622

short atomic_fetch_add_explicit(atomic_short*, short, memory_order);

623

short atomic_fetch_sub(volatile atomic_short*, short);

624

short atomic_fetch_sub(atomic_short*, short);

625

short atomic_fetch_sub_explicit(volatile atomic_short*, short, memory_order);

626

short atomic_fetch_sub_explicit(atomic_short*, short, memory_order);

627

short atomic_fetch_and(volatile atomic_short*, short);

628

short atomic_fetch_and(atomic_short*, short);

629

short atomic_fetch_and_explicit(volatile atomic_short*, short, memory_order);

630

short atomic_fetch_and_explicit(atomic_short*, short, memory_order);

631

short atomic_fetch_or(volatile atomic_short*, short);

632

short atomic_fetch_or(atomic_short*, short);

633

short atomic_fetch_or_explicit(volatile atomic_short*, short, memory_order);

634

short atomic_fetch_or_explicit(atomic_short*, short, memory_order);

635

short atomic_fetch_xor(volatile atomic_short*, short);

636

short atomic_fetch_xor(atomic_short*, short);

637

short atomic_fetch_xor_explicit(volatile atomic_short*, short, memory_order);

638

short atomic_fetch_xor_explicit(atomic_short*, short, memory_order);

// atomic_ushort

typedef struct atomic_ushort

643

{

644

bool is_lock_free() const volatile;

645

bool is_lock_free() const;

646

void store(unsigned short, memory_order = memory_order_seq_cst) volatile;

647

void store(unsigned short, memory_order = memory_order_seq_cst);

648

unsigned short load(memory_order = memory_order_seq_cst) const volatile;

649

unsigned short load(memory_order = memory_order_seq_cst) const;

650

operator unsigned short() const volatile;

651

operator unsigned short() const;

652

unsigned short exchange(unsigned short,

653

memory_order = memory_order_seq_cst) volatile;

654

unsigned short exchange(unsigned short,

655

memory_order = memory_order_seq_cst);

656

bool compare_exchange_weak(unsigned short&, unsigned short, memory_order,

657

memory_order) volatile;

658

bool compare_exchange_weak(unsigned short&, unsigned short, memory_order,

659

memory_order);

660

bool compare_exchange_strong(unsigned short&, unsigned short, memory_order,

661

memory_order) volatile;

662

bool compare_exchange_strong(unsigned short&, unsigned short, memory_order,

663

memory_order);

664

bool compare_exchange_weak(unsigned short&, unsigned short,

665

memory_order = memory_order_seq_cst) volatile;

666

bool compare_exchange_weak(unsigned short&, unsigned short,

667

memory_order = memory_order_seq_cst);

668

bool compare_exchange_strong(unsigned short&, unsigned short,

669

memory_order = memory_order_seq_cst) volatile;

670

bool compare_exchange_strong(unsigned short&, unsigned short,

671

memory_order = memory_order_seq_cst);

672

unsigned short fetch_add(unsigned short,

673

memory_order = memory_order_seq_cst) volatile;

674

unsigned short fetch_add(unsigned short,

675

memory_order = memory_order_seq_cst);

676

unsigned short fetch_sub(unsigned short,

677

memory_order = memory_order_seq_cst) volatile;

678

unsigned short fetch_sub(unsigned short,

679

memory_order = memory_order_seq_cst);

680

unsigned short fetch_and(unsigned short,

681

memory_order = memory_order_seq_cst) volatile;

682

unsigned short fetch_and(unsigned short,

683

memory_order = memory_order_seq_cst);

684

unsigned short fetch_or(unsigned short,

685

memory_order = memory_order_seq_cst) volatile;

686

unsigned short fetch_or(unsigned short,

687

memory_order = memory_order_seq_cst);

688

unsigned short fetch_xor(unsigned short,

689

memory_order = memory_order_seq_cst) volatile;

690

unsigned short fetch_xor(unsigned short,

691

memory_order = memory_order_seq_cst);

692

atomic_ushort() = default;

693

constexpr atomic_ushort(unsigned short);

694

atomic_ushort(const atomic_ushort&) = delete;

695

atomic_ushort& operator=(const atomic_ushort&) = delete;

696

atomic_ushort& operator=(const atomic_ushort&) volatile = delete;

697

unsigned short operator=(unsigned short) volatile;

698

unsigned short operator=(unsigned short);

699

unsigned short operator++(int) volatile;

700

unsigned short operator++(int);

701

unsigned short operator--(int) volatile;

702

unsigned short operator--(int);

703

unsigned short operator++() volatile;

704

unsigned short operator++();

705

unsigned short operator--() volatile;

706

unsigned short operator--();

707

unsigned short operator+=(unsigned short) volatile;

708

unsigned short operator+=(unsigned short);

709

unsigned short operator-=(unsigned short) volatile;

710

unsigned short operator-=(unsigned short);

711

unsigned short operator&=(unsigned short) volatile;

712

unsigned short operator&=(unsigned short);

713

unsigned short operator|=(unsigned short) volatile;

714

unsigned short operator|=(unsigned short);

715

unsigned short operator^=(unsigned short) volatile;

716

unsigned short operator^=(unsigned short);

717

} atomic_ushort;

718

719

bool atomic_is_lock_free(const volatile atomic_ushort*);

720

bool atomic_is_lock_free(const atomic_ushort*);

721

void atomic_init(volatile atomic_ushort*, itype);

722

void atomic_init(atomic_ushort*, itype);

723

void atomic_store(volatile atomic_ushort*, unsigned short);

724

void atomic_store(atomic_ushort*, unsigned short);

725

void atomic_store_explicit(volatile atomic_ushort*, unsigned short,

726

memory_order);

727

void atomic_store_explicit(atomic_ushort*, unsigned short, memory_order);

728

unsigned short atomic_load(const volatile atomic_ushort*);

729

unsigned short atomic_load(const atomic_ushort*);

730

unsigned short atomic_load_explicit(const volatile atomic_ushort*,

731

memory_order);

732

unsigned short atomic_load_explicit(const atomic_ushort*, memory_order);

733

unsigned short atomic_exchange(volatile atomic_ushort*, unsigned short);

734

unsigned short atomic_exchange(atomic_ushort*, unsigned short);

735

unsigned short atomic_exchange_explicit(volatile atomic_ushort*, unsigned short,

736

memory_order);

737

unsigned short atomic_exchange_explicit(atomic_ushort*, unsigned short,

738

memory_order);

739

bool atomic_compare_exchange_weak(volatile atomic_ushort*, unsigned short*,

740

unsigned short);

741

bool atomic_compare_exchange_weak(atomic_ushort*, unsigned short*,

742

unsigned short);

743

bool atomic_compare_exchange_strong(volatile atomic_ushort*, unsigned short*,

744

unsigned short);

745

bool atomic_compare_exchange_strong(atomic_ushort*, unsigned short*,

746

unsigned short);

747

bool atomic_compare_exchange_weak_explicit(volatile atomic_ushort*,

748

unsigned short*, unsigned short,

749

memory_order, memory_order);

750

bool atomic_compare_exchange_weak_explicit(atomic_ushort*, unsigned short*,

751

unsigned short, memory_order,

752

memory_order);

753

bool atomic_compare_exchange_strong_explicit(volatile atomic_ushort*,

754

unsigned short*, unsigned short,

755

memory_order, memory_order);

756

bool atomic_compare_exchange_strong_explicit(atomic_ushort*, unsigned short*,

757

unsigned short, memory_order,

758

memory_order);

759

unsigned short atomic_fetch_add(volatile atomic_ushort*, unsigned short);

760

unsigned short atomic_fetch_add(atomic_ushort*, unsigned short);

761

unsigned short atomic_fetch_add_explicit(volatile atomic_ushort*,

762

unsigned short, memory_order);

763

unsigned short atomic_fetch_add_explicit(atomic_ushort*, unsigned short,

764

memory_order);

765

unsigned short atomic_fetch_sub(volatile atomic_ushort*, unsigned short);

766

unsigned short atomic_fetch_sub(atomic_ushort*, unsigned short);

767

unsigned short atomic_fetch_sub_explicit(volatile atomic_ushort*,

768

unsigned short, memory_order);

769

unsigned short atomic_fetch_sub_explicit(atomic_ushort*, unsigned short,

770

memory_order);

771

unsigned short atomic_fetch_and(volatile atomic_ushort*, unsigned short);

772

unsigned short atomic_fetch_and(atomic_ushort*, unsigned short);

773

unsigned short atomic_fetch_and_explicit(volatile atomic_ushort*,

774

unsigned short, memory_order);

775

unsigned short atomic_fetch_and_explicit(atomic_ushort*, unsigned short,

776

memory_order);

777

unsigned short atomic_fetch_or(volatile atomic_ushort*, unsigned short);

778

unsigned short atomic_fetch_or(atomic_ushort*, unsigned short);

779

unsigned short atomic_fetch_or_explicit(volatile atomic_ushort*, unsigned short,

780

memory_order);

781

unsigned short atomic_fetch_or_explicit(atomic_ushort*, unsigned short,

782

memory_order);

783

unsigned short atomic_fetch_xor(volatile atomic_ushort*, unsigned short);

784

unsigned short atomic_fetch_xor(atomic_ushort*, unsigned short);

785

unsigned short atomic_fetch_xor_explicit(volatile atomic_ushort*,

786

unsigned short, memory_order);

787

unsigned short atomic_fetch_xor_explicit(atomic_ushort*, unsigned short,

memory_order);

// atomic_int

typedef struct atomic_int

793

{

794

bool is_lock_free() const volatile;

795

bool is_lock_free() const;

796

void store(int, memory_order = memory_order_seq_cst) volatile;

797

void store(int, memory_order = memory_order_seq_cst);

798

int load(memory_order = memory_order_seq_cst) const volatile;

799

int load(memory_order = memory_order_seq_cst) const;

800

operator int() const volatile;

801

operator int() const;

802

int exchange(int,

803

memory_order = memory_order_seq_cst) volatile;

804

int exchange(int, memory_order = memory_order_seq_cst);

805

bool compare_exchange_weak(int&, int, memory_order, memory_order) volatile;

806

bool compare_exchange_weak(int&, int, memory_order, memory_order);

807

bool compare_exchange_strong(int&, int, memory_order,

808

memory_order) volatile;

809

bool compare_exchange_strong(int&, int, memory_order, memory_order);

810

bool compare_exchange_weak(int&, int,

811

memory_order = memory_order_seq_cst) volatile;

812

bool compare_exchange_weak(int&, int, memory_order = memory_order_seq_cst);

813

bool compare_exchange_strong(int&, int,

814

memory_order = memory_order_seq_cst) volatile;

815

bool compare_exchange_strong(int&, int,

816

memory_order = memory_order_seq_cst);

817

int fetch_add(int, memory_order = memory_order_seq_cst) volatile;

818

int fetch_add(int, memory_order = memory_order_seq_cst);

819

int fetch_sub(int, memory_order = memory_order_seq_cst) volatile;

820

int fetch_sub(int, memory_order = memory_order_seq_cst);

821

int fetch_and(int, memory_order = memory_order_seq_cst) volatile;

822

int fetch_and(int, memory_order = memory_order_seq_cst);

823

int fetch_or(int, memory_order = memory_order_seq_cst) volatile;

824

int fetch_or(int, memory_order = memory_order_seq_cst);

825

int fetch_xor(int, memory_order = memory_order_seq_cst) volatile;

826

int fetch_xor(int, memory_order = memory_order_seq_cst);

827

atomic_int() = default;

828

constexpr atomic_int(int);

829

atomic_int(const atomic_int&) = delete;

830

atomic_int& operator=(const atomic_int&) = delete;

831

atomic_int& operator=(const atomic_int&) volatile = delete;

832

int operator=(int) volatile;

833

int operator=(int);

834

int operator++(int) volatile;

835

int operator++(int);

836

int operator--(int) volatile;

837

int operator--(int);

838

int operator++() volatile;

839

int operator++();

840

int operator--() volatile;

841

int operator--();

842

int operator+=(int) volatile;

843

int operator+=(int);

844

int operator-=(int) volatile;

845

int operator-=(int);

846

int operator&=(int) volatile;

847

int operator&=(int);

848

int operator|=(int) volatile;

849

int operator|=(int);

850

int operator^=(int) volatile;

int operator^=(int);

} atomic_int;

bool atomic_is_lock_free(const volatile atomic_int*);

855

bool atomic_is_lock_free(const atomic_int*);

856

void atomic_init(volatile atomic_int*, itype);

857

void atomic_init(atomic_int*, itype);

858

void atomic_store(volatile atomic_int*, int);

859

void atomic_store(atomic_int*, int);

860

void atomic_store_explicit(volatile atomic_int*, int, memory_order);

861

void atomic_store_explicit(atomic_int*, int, memory_order);

862

int atomic_load(const volatile atomic_int*);

863

int atomic_load(const atomic_int*);

864

int atomic_load_explicit(const volatile atomic_int*, memory_order);

865

int atomic_load_explicit(const atomic_int*, memory_order);

866

int atomic_exchange(volatile atomic_int*, int);

867

int atomic_exchange(atomic_int*, int);

868

int atomic_exchange_explicit(volatile atomic_int*, int, memory_order);

869

int atomic_exchange_explicit(atomic_int*, int, memory_order);

870

bool atomic_compare_exchange_weak(volatile atomic_int*, int*, int);

871

bool atomic_compare_exchange_weak(atomic_int*, int*, int);

872

bool atomic_compare_exchange_strong(volatile atomic_int*, int*, int);

873

bool atomic_compare_exchange_strong(atomic_int*, int*, int);

874

bool atomic_compare_exchange_weak_explicit(volatile atomic_int*, int*, int,

875

memory_order, memory_order);

876

bool atomic_compare_exchange_weak_explicit(atomic_int*, int*, int, memory_order,

877

memory_order);

878

bool atomic_compare_exchange_strong_explicit(volatile atomic_int*, int*, int,

879

memory_order, memory_order);

880

bool atomic_compare_exchange_strong_explicit(atomic_int*, int*, int,

881

memory_order, memory_order);

882

int atomic_fetch_add(volatile atomic_int*, int);

883

int atomic_fetch_add(atomic_int*, int);

884

int atomic_fetch_add_explicit(volatile atomic_int*, int, memory_order);

885

int atomic_fetch_add_explicit(atomic_int*, int, memory_order);

886

int atomic_fetch_sub(volatile atomic_int*, int);

887

int atomic_fetch_sub(atomic_int*, int);

888

int atomic_fetch_sub_explicit(volatile atomic_int*, int, memory_order);

889

int atomic_fetch_sub_explicit(atomic_int*, int, memory_order);

890

int atomic_fetch_and(volatile atomic_int*, int);

891

int atomic_fetch_and(atomic_int*, int);

892

int atomic_fetch_and_explicit(volatile atomic_int*, int, memory_order);

893

int atomic_fetch_and_explicit(atomic_int*, int, memory_order);

894

int atomic_fetch_or(volatile atomic_int*, int);

895

int atomic_fetch_or(atomic_int*, int);

896

int atomic_fetch_or_explicit(volatile atomic_int*, int, memory_order);

897

int atomic_fetch_or_explicit(atomic_int*, int, memory_order);

898

int atomic_fetch_xor(volatile atomic_int*, int);

899

int atomic_fetch_xor(atomic_int*, int);

900

int atomic_fetch_xor_explicit(volatile atomic_int*, int, memory_order);

901

int atomic_fetch_xor_explicit(atomic_int*, int, memory_order);

// atomic_uint

typedef struct atomic_uint

906

{

907

bool is_lock_free() const volatile;

908

bool is_lock_free() const;

909

void store(unsigned int, memory_order = memory_order_seq_cst) volatile;

910

void store(unsigned int, memory_order = memory_order_seq_cst);

911

unsigned int load(memory_order = memory_order_seq_cst) const volatile;

912

unsigned int load(memory_order = memory_order_seq_cst) const;

913

operator unsigned int() const volatile;

914

operator unsigned int() const;

915

unsigned int exchange(unsigned int,

916

memory_order = memory_order_seq_cst) volatile;

917

unsigned int exchange(unsigned int, memory_order = memory_order_seq_cst);

918

bool compare_exchange_weak(unsigned int&, unsigned int, memory_order,

919

memory_order) volatile;

920

bool compare_exchange_weak(unsigned int&, unsigned int, memory_order,

921

memory_order);

922

bool compare_exchange_strong(unsigned int&, unsigned int, memory_order,

923

memory_order) volatile;

924

bool compare_exchange_strong(unsigned int&, unsigned int, memory_order,

925

memory_order);

926

bool compare_exchange_weak(unsigned int&, unsigned int,

927

memory_order = memory_order_seq_cst) volatile;

928

bool compare_exchange_weak(unsigned int&, unsigned int,

929

memory_order = memory_order_seq_cst);

930

bool compare_exchange_strong(unsigned int&, unsigned int,

931

memory_order = memory_order_seq_cst) volatile;

932

bool compare_exchange_strong(unsigned int&, unsigned int,

933

memory_order = memory_order_seq_cst);

934

unsigned int fetch_add(unsigned int,

935

memory_order = memory_order_seq_cst) volatile;

936

unsigned int fetch_add(unsigned int, memory_order = memory_order_seq_cst);

937

unsigned int fetch_sub(unsigned int,

938

memory_order = memory_order_seq_cst) volatile;

939

unsigned int fetch_sub(unsigned int, memory_order = memory_order_seq_cst);

940

unsigned int fetch_and(unsigned int,

941

memory_order = memory_order_seq_cst) volatile;

942

unsigned int fetch_and(unsigned int, memory_order = memory_order_seq_cst);

943

unsigned int fetch_or(unsigned int,

944

memory_order = memory_order_seq_cst) volatile;

945

unsigned int fetch_or(unsigned int, memory_order = memory_order_seq_cst);

946

unsigned int fetch_xor(unsigned int,

947

memory_order = memory_order_seq_cst) volatile;

948

unsigned int fetch_xor(unsigned int, memory_order = memory_order_seq_cst);

949

atomic_uint() = default;

950

constexpr atomic_uint(unsigned int);

951

atomic_uint(const atomic_uint&) = delete;

952

atomic_uint& operator=(const atomic_uint&) = delete;

953

atomic_uint& operator=(const atomic_uint&) volatile = delete;

954

unsigned int operator=(unsigned int) volatile;

955

unsigned int operator=(unsigned int);

956

unsigned int operator++(int) volatile;

957

unsigned int operator++(int);

958

unsigned int operator--(int) volatile;

959

unsigned int operator--(int);

960

unsigned int operator++() volatile;

961

unsigned int operator++();

962

unsigned int operator--() volatile;

963

unsigned int operator--();

964

unsigned int operator+=(unsigned int) volatile;

965

unsigned int operator+=(unsigned int);

966

unsigned int operator-=(unsigned int) volatile;

967

unsigned int operator-=(unsigned int);

968

unsigned int operator&=(unsigned int) volatile;

969

unsigned int operator&=(unsigned int);

970

unsigned int operator|=(unsigned int) volatile;

971

unsigned int operator|=(unsigned int);

972

unsigned int operator^=(unsigned int) volatile;

973

unsigned int operator^=(unsigned int);

974

} atomic_uint;

975

976

bool atomic_is_lock_free(const volatile atomic_uint*);

977

bool atomic_is_lock_free(const atomic_uint*);

978

void atomic_init(volatile atomic_uint*, itype);

979

void atomic_init(atomic_uint*, itype);

980

void atomic_store(volatile atomic_uint*, unsigned int);

981

void atomic_store(atomic_uint*, unsigned int);

982

void atomic_store_explicit(volatile atomic_uint*, unsigned int, memory_order);

983

void atomic_store_explicit(atomic_uint*, unsigned int, memory_order);

984

unsigned int atomic_load(const volatile atomic_uint*);

985

unsigned int atomic_load(const atomic_uint*);

986

unsigned int atomic_load_explicit(const volatile atomic_uint*, memory_order);

987

unsigned int atomic_load_explicit(const atomic_uint*, memory_order);

988

unsigned int atomic_exchange(volatile atomic_uint*, unsigned int);

989

unsigned int atomic_exchange(atomic_uint*, unsigned int);

990

unsigned int atomic_exchange_explicit(volatile atomic_uint*, unsigned int,

991

memory_order);

992

unsigned int atomic_exchange_explicit(atomic_uint*, unsigned int, memory_order);

993

bool atomic_compare_exchange_weak(volatile atomic_uint*, unsigned int*,

994

unsigned int);

995

bool atomic_compare_exchange_weak(atomic_uint*, unsigned int*, unsigned int);

996

bool atomic_compare_exchange_strong(volatile atomic_uint*, unsigned int*,

997

unsigned int);

998

bool atomic_compare_exchange_strong(atomic_uint*, unsigned int*, unsigned int);

999

bool atomic_compare_exchange_weak_explicit(volatile atomic_uint*, unsigned int*,

1000

unsigned int, memory_order,

1001

memory_order);

1002

bool atomic_compare_exchange_weak_explicit(atomic_uint*, unsigned int*,

1003

unsigned int, memory_order,

1004

memory_order);

1005

bool atomic_compare_exchange_strong_explicit(volatile atomic_uint*,

1006

unsigned int*, unsigned int,

1007

memory_order, memory_order);

1008

bool atomic_compare_exchange_strong_explicit(atomic_uint*, unsigned int*,

1009

unsigned int, memory_order,

1010

memory_order);

1011

unsigned int atomic_fetch_add(volatile atomic_uint*, unsigned int);

1012

unsigned int atomic_fetch_add(atomic_uint*, unsigned int);

1013

unsigned int atomic_fetch_add_explicit(volatile atomic_uint*, unsigned int,

1014

memory_order);

1015

unsigned int atomic_fetch_add_explicit(atomic_uint*, unsigned int,

1016

memory_order);

1017

unsigned int atomic_fetch_sub(volatile atomic_uint*, unsigned int);

1018

unsigned int atomic_fetch_sub(atomic_uint*, unsigned int);

1019

unsigned int atomic_fetch_sub_explicit(volatile atomic_uint*, unsigned int,

1020

memory_order);

1021

unsigned int atomic_fetch_sub_explicit(atomic_uint*, unsigned int,

1022

memory_order);

1023

unsigned int atomic_fetch_and(volatile atomic_uint*, unsigned int);

1024

unsigned int atomic_fetch_and(atomic_uint*, unsigned int);

1025

unsigned int atomic_fetch_and_explicit(volatile atomic_uint*, unsigned int,

1026

memory_order);

1027

unsigned int atomic_fetch_and_explicit(atomic_uint*, unsigned int,

1028

memory_order);

1029

unsigned int atomic_fetch_or(volatile atomic_uint*, unsigned int);

1030

unsigned int atomic_fetch_or(atomic_uint*, unsigned int);

1031

unsigned int atomic_fetch_or_explicit(volatile atomic_uint*, unsigned int,

1032

memory_order);

1033

unsigned int atomic_fetch_or_explicit(atomic_uint*, unsigned int, memory_order);

1034

unsigned int atomic_fetch_xor(volatile atomic_uint*, unsigned int);

1035

unsigned int atomic_fetch_xor(atomic_uint*, unsigned int);

1036

unsigned int atomic_fetch_xor_explicit(volatile atomic_uint*, unsigned int,

1037

memory_order);

1038

unsigned int atomic_fetch_xor_explicit(atomic_uint*, unsigned int,

memory_order);

// atomic_long

typedef struct atomic_long

1044

{

1045

bool is_lock_free() const volatile;

1046

bool is_lock_free() const;

1047

void store(long, memory_order = memory_order_seq_cst) volatile;

1048

void store(long, memory_order = memory_order_seq_cst);

1049

long load(memory_order = memory_order_seq_cst) const volatile;

1050

long load(memory_order = memory_order_seq_cst) const;

1051

operator long() const volatile;

1052

operator long() const;

1053

long exchange(long,

1054

memory_order = memory_order_seq_cst) volatile;

1055

long exchange(long, memory_order = memory_order_seq_cst);

1056

bool compare_exchange_weak(long&, long, memory_order,

1057

memory_order) volatile;

1058

bool compare_exchange_weak(long&, long, memory_order, memory_order);

1059

bool compare_exchange_strong(long&, long, memory_order,

1060

memory_order) volatile;

1061

bool compare_exchange_strong(long&, long, memory_order, memory_order);

1062

bool compare_exchange_weak(long&, long,

1063

memory_order = memory_order_seq_cst) volatile;

1064

bool compare_exchange_weak(long&, long,

1065

memory_order = memory_order_seq_cst);

1066

bool compare_exchange_strong(long&, long,

1067

memory_order = memory_order_seq_cst) volatile;

1068

bool compare_exchange_strong(long&, long,

1069

memory_order = memory_order_seq_cst);

1070

long fetch_add(long, memory_order = memory_order_seq_cst) volatile;

1071

long fetch_add(long, memory_order = memory_order_seq_cst);

1072

long fetch_sub(long, memory_order = memory_order_seq_cst) volatile;

1073

long fetch_sub(long, memory_order = memory_order_seq_cst);

1074

long fetch_and(long, memory_order = memory_order_seq_cst) volatile;

1075

long fetch_and(long, memory_order = memory_order_seq_cst);

1076

long fetch_or(long, memory_order = memory_order_seq_cst) volatile;

1077

long fetch_or(long, memory_order = memory_order_seq_cst);

1078

long fetch_xor(long, memory_order = memory_order_seq_cst) volatile;

1079

long fetch_xor(long, memory_order = memory_order_seq_cst);

1080

atomic_long() = default;

1081

constexpr atomic_long(long);

1082

atomic_long(const atomic_long&) = delete;

1083

atomic_long& operator=(const atomic_long&) = delete;

1084

atomic_long& operator=(const atomic_long&) volatile = delete;

1085

long operator=(long) volatile;

1086

long operator=(long);

1087

long operator++(int) volatile;

1088

long operator++(int);

1089

long operator--(int) volatile;

1090

long operator--(int);

1091

long operator++() volatile;

1092

long operator++();

1093

long operator--() volatile;

1094

long operator--();

1095

long operator+=(long) volatile;

1096

long operator+=(long);

1097

long operator-=(long) volatile;

1098

long operator-=(long);

1099

long operator&=(long) volatile;

1100

long operator&=(long);

1101

long operator|=(long) volatile;

1102

long operator|=(long);

1103

long operator^=(long) volatile;

1104

long operator^=(long);

1105

} atomic_long;

1106

1107

bool atomic_is_lock_free(const volatile atomic_long*);

1108

bool atomic_is_lock_free(const atomic_long*);

1109

void atomic_init(volatile atomic_long*, itype);

1110

void atomic_init(atomic_long*, itype);

1111

void atomic_store(volatile atomic_long*, long);

1112

void atomic_store(atomic_long*, long);

1113

void atomic_store_explicit(volatile atomic_long*, long, memory_order);

1114

void atomic_store_explicit(atomic_long*, long, memory_order);

1115

long atomic_load(const volatile atomic_long*);

1116

long atomic_load(const atomic_long*);

1117

long atomic_load_explicit(const volatile atomic_long*, memory_order);

1118

long atomic_load_explicit(const atomic_long*, memory_order);

1119

long atomic_exchange(volatile atomic_long*, long);

1120

long atomic_exchange(atomic_long*, long);

1121

long atomic_exchange_explicit(volatile atomic_long*, long, memory_order);

1122

long atomic_exchange_explicit(atomic_long*, long, memory_order);

1123

bool atomic_compare_exchange_weak(volatile atomic_long*, long*, long);

1124

bool atomic_compare_exchange_weak(atomic_long*, long*, long);

1125

bool atomic_compare_exchange_strong(volatile atomic_long*, long*, long);

1126

bool atomic_compare_exchange_strong(atomic_long*, long*, long);

1127

bool atomic_compare_exchange_weak_explicit(volatile atomic_long*, long*, long,

1128

memory_order, memory_order);

1129

bool atomic_compare_exchange_weak_explicit(atomic_long*, long*, long,

1130

memory_order, memory_order);

1131

bool atomic_compare_exchange_strong_explicit(volatile atomic_long*, long*, long,

1132

memory_order, memory_order);

1133

bool atomic_compare_exchange_strong_explicit(atomic_long*, long*, long,

1134

memory_order, memory_order);

1135

long atomic_fetch_add(volatile atomic_long*, long);

1136

long atomic_fetch_add(atomic_long*, long);

1137

long atomic_fetch_add_explicit(volatile atomic_long*, long, memory_order);

1138

long atomic_fetch_add_explicit(atomic_long*, long, memory_order);

1139

long atomic_fetch_sub(volatile atomic_long*, long);

1140

long atomic_fetch_sub(atomic_long*, long);

1141

long atomic_fetch_sub_explicit(volatile atomic_long*, long, memory_order);

1142

long atomic_fetch_sub_explicit(atomic_long*, long, memory_order);

1143

long atomic_fetch_and(volatile atomic_long*, long);

1144

long atomic_fetch_and(atomic_long*, long);

1145

long atomic_fetch_and_explicit(volatile atomic_long*, long, memory_order);

1146

long atomic_fetch_and_explicit(atomic_long*, long, memory_order);

1147

long atomic_fetch_or(volatile atomic_long*, long);

1148

long atomic_fetch_or(atomic_long*, long);

1149

long atomic_fetch_or_explicit(volatile atomic_long*, long, memory_order);

1150

long atomic_fetch_or_explicit(atomic_long*, long, memory_order);

1151

long atomic_fetch_xor(volatile atomic_long*, long);

1152

long atomic_fetch_xor(atomic_long*, long);

1153

long atomic_fetch_xor_explicit(volatile atomic_long*, long, memory_order);

1154

long atomic_fetch_xor_explicit(atomic_long*, long, memory_order);

// atomic_ulong

typedef struct atomic_ulong

1159

{

1160

bool is_lock_free() const volatile;

1161

bool is_lock_free() const;

1162

void store(unsigned long, memory_order = memory_order_seq_cst) volatile;

1163

void store(unsigned long, memory_order = memory_order_seq_cst);

1164

unsigned long load(memory_order = memory_order_seq_cst) const volatile;

1165

unsigned long load(memory_order = memory_order_seq_cst) const;

1166

operator unsigned long() const volatile;

1167

operator unsigned long() const;

1168

unsigned long exchange(unsigned long,

1169

memory_order = memory_order_seq_cst) volatile;

1170

unsigned long exchange(unsigned long, memory_order = memory_order_seq_cst);

1171

bool compare_exchange_weak(unsigned long&, unsigned long, memory_order,

1172

memory_order) volatile;

1173

bool compare_exchange_weak(unsigned long&, unsigned long, memory_order,

1174

memory_order);

1175

bool compare_exchange_strong(unsigned long&, unsigned long, memory_order,

1176

memory_order) volatile;

1177

bool compare_exchange_strong(unsigned long&, unsigned long, memory_order,

1178

memory_order);

1179

bool compare_exchange_weak(unsigned long&, unsigned long,

1180

memory_order = memory_order_seq_cst) volatile;

1181

bool compare_exchange_weak(unsigned long&, unsigned long,

1182

memory_order = memory_order_seq_cst);

1183

bool compare_exchange_strong(unsigned long&, unsigned long,

1184

memory_order = memory_order_seq_cst) volatile;

1185

bool compare_exchange_strong(unsigned long&, unsigned long,

1186

memory_order = memory_order_seq_cst);

1187

unsigned long fetch_add(unsigned long,

1188

memory_order = memory_order_seq_cst) volatile;

1189

unsigned long fetch_add(unsigned long, memory_order = memory_order_seq_cst);

1190

unsigned long fetch_sub(unsigned long,

1191

memory_order = memory_order_seq_cst) volatile;

1192

unsigned long fetch_sub(unsigned long, memory_order = memory_order_seq_cst);

1193

unsigned long fetch_and(unsigned long,

1194

memory_order = memory_order_seq_cst) volatile;

1195

unsigned long fetch_and(unsigned long, memory_order = memory_order_seq_cst);

1196

unsigned long fetch_or(unsigned long,

1197

memory_order = memory_order_seq_cst) volatile;

1198

unsigned long fetch_or(unsigned long, memory_order = memory_order_seq_cst);

1199

unsigned long fetch_xor(unsigned long,

1200

memory_order = memory_order_seq_cst) volatile;

1201

unsigned long fetch_xor(unsigned long, memory_order = memory_order_seq_cst);

1202

atomic_ulong() = default;

1203

constexpr atomic_ulong(unsigned long);

1204

atomic_ulong(const atomic_ulong&) = delete;

1205

atomic_ulong& operator=(const atomic_ulong&) = delete;

1206

atomic_ulong& operator=(const atomic_ulong&) volatile = delete;

1207

unsigned long operator=(unsigned long) volatile;

1208

unsigned long operator=(unsigned long);

1209

unsigned long operator++(int) volatile;

1210

unsigned long operator++(int);

1211

unsigned long operator--(int) volatile;

1212

unsigned long operator--(int);

1213

unsigned long operator++() volatile;

1214

unsigned long operator++();

1215

unsigned long operator--() volatile;

1216

unsigned long operator--();

1217

unsigned long operator+=(unsigned long) volatile;

1218

unsigned long operator+=(unsigned long);

1219

unsigned long operator-=(unsigned long) volatile;

1220

unsigned long operator-=(unsigned long);

1221

unsigned long operator&=(unsigned long) volatile;

1222

unsigned long operator&=(unsigned long);

1223

unsigned long operator|=(unsigned long) volatile;

1224

unsigned long operator|=(unsigned long);

1225

unsigned long operator^=(unsigned long) volatile;

1226

unsigned long operator^=(unsigned long);

1227

} atomic_ulong;

1228

1229

bool atomic_is_lock_free(const volatile atomic_ulong*);

1230

bool atomic_is_lock_free(const atomic_ulong*);

1231

void atomic_init(volatile atomic_ulong*, itype);

1232

void atomic_init(atomic_ulong*, itype);

1233

void atomic_store(volatile atomic_ulong*, unsigned long);

1234

void atomic_store(atomic_ulong*, unsigned long);

1235

void atomic_store_explicit(volatile atomic_ulong*, unsigned long, memory_order);

1236

void atomic_store_explicit(atomic_ulong*, unsigned long, memory_order);

1237

unsigned long atomic_load(const volatile atomic_ulong*);

1238

unsigned long atomic_load(const atomic_ulong*);

1239

unsigned long atomic_load_explicit(const volatile atomic_ulong*, memory_order);

1240

unsigned long atomic_load_explicit(const atomic_ulong*, memory_order);

1241

unsigned long atomic_exchange(volatile atomic_ulong*, unsigned long);

1242

unsigned long atomic_exchange(atomic_ulong*, unsigned long);

1243

unsigned long atomic_exchange_explicit(volatile atomic_ulong*, unsigned long,

1244

memory_order);

1245

unsigned long atomic_exchange_explicit(atomic_ulong*, unsigned long,

1246

memory_order);

1247

bool atomic_compare_exchange_weak(volatile atomic_ulong*, unsigned long*,

1248

unsigned long);

1249

bool atomic_compare_exchange_weak(atomic_ulong*, unsigned long*, unsigned long);

1250

bool atomic_compare_exchange_strong(volatile atomic_ulong*, unsigned long*,

1251

unsigned long);

1252

bool atomic_compare_exchange_strong(atomic_ulong*, unsigned long*,

1253

unsigned long);

1254

bool atomic_compare_exchange_weak_explicit(volatile atomic_ulong*,

1255

unsigned long*, unsigned long,

1256

memory_order, memory_order);

1257

bool atomic_compare_exchange_weak_explicit(atomic_ulong*, unsigned long*,

1258

unsigned long, memory_order,

1259

memory_order);

1260

bool atomic_compare_exchange_strong_explicit(volatile atomic_ulong*,

1261

unsigned long*, unsigned long,

1262

memory_order, memory_order);

1263

bool atomic_compare_exchange_strong_explicit(atomic_ulong*, unsigned long*,

1264

unsigned long, memory_order,

1265

memory_order);

1266

unsigned long atomic_fetch_add(volatile atomic_ulong*, unsigned long);

1267

unsigned long atomic_fetch_add(atomic_ulong*, unsigned long);

1268

unsigned long atomic_fetch_add_explicit(volatile atomic_ulong*, unsigned long,

1269

memory_order);

1270

unsigned long atomic_fetch_add_explicit(atomic_ulong*, unsigned long,

1271

memory_order);

1272

unsigned long atomic_fetch_sub(volatile atomic_ulong*, unsigned long);

1273

unsigned long atomic_fetch_sub(atomic_ulong*, unsigned long);

1274

unsigned long atomic_fetch_sub_explicit(volatile atomic_ulong*, unsigned long,

1275

memory_order);

1276

unsigned long atomic_fetch_sub_explicit(atomic_ulong*, unsigned long,

1277

memory_order);

1278

unsigned long atomic_fetch_and(volatile atomic_ulong*, unsigned long);

1279

unsigned long atomic_fetch_and(atomic_ulong*, unsigned long);

1280

unsigned long atomic_fetch_and_explicit(volatile atomic_ulong*, unsigned long,

1281

memory_order);

1282

unsigned long atomic_fetch_and_explicit(atomic_ulong*, unsigned long,

1283

memory_order);

1284

unsigned long atomic_fetch_or(volatile atomic_ulong*, unsigned long);

1285

unsigned long atomic_fetch_or(atomic_ulong*, unsigned long);

1286

unsigned long atomic_fetch_or_explicit(volatile atomic_ulong*, unsigned long,

1287

memory_order);

1288

unsigned long atomic_fetch_or_explicit(atomic_ulong*, unsigned long,

1289

memory_order);

1290

unsigned long atomic_fetch_xor(volatile atomic_ulong*, unsigned long);

1291

unsigned long atomic_fetch_xor(atomic_ulong*, unsigned long);

1292

unsigned long atomic_fetch_xor_explicit(volatile atomic_ulong*, unsigned long,

1293

memory_order);

1294

unsigned long atomic_fetch_xor_explicit(atomic_ulong*, unsigned long,

memory_order);

// atomic_llong

typedef struct atomic_llong

1300

{

1301

bool is_lock_free() const volatile;

1302

bool is_lock_free() const;

1303

void store(long long, memory_order = memory_order_seq_cst) volatile;

1304

void store(long long, memory_order = memory_order_seq_cst);

1305

long long load(memory_order = memory_order_seq_cst) const volatile;

1306

long long load(memory_order = memory_order_seq_cst) const;

1307

operator long long() const volatile;

1308

operator long long() const;

1309

long long exchange(long long,

1310

memory_order = memory_order_seq_cst) volatile;

1311

long long exchange(long long, memory_order = memory_order_seq_cst);

1312

bool compare_exchange_weak(long long&, long long, memory_order,

1313

memory_order) volatile;

1314

bool compare_exchange_weak(long long&, long long, memory_order,

1315

memory_order);

1316

bool compare_exchange_strong(long long&, long long, memory_order,

1317

memory_order) volatile;

1318

bool compare_exchange_strong(long long&, long long, memory_order,

1319

memory_order);

1320

bool compare_exchange_weak(long long&, long long,

1321

memory_order = memory_order_seq_cst) volatile;

1322

bool compare_exchange_weak(long long&, long long,

1323

memory_order = memory_order_seq_cst);

1324

bool compare_exchange_strong(long long&, long long,

1325

memory_order = memory_order_seq_cst) volatile;

1326

bool compare_exchange_strong(long long&, long long,

1327

memory_order = memory_order_seq_cst);

1328

long long fetch_add(long long,

1329

memory_order = memory_order_seq_cst) volatile;

1330

long long fetch_add(long long, memory_order = memory_order_seq_cst);

1331

long long fetch_sub(long long,

1332

memory_order = memory_order_seq_cst) volatile;

1333

long long fetch_sub(long long, memory_order = memory_order_seq_cst);

1334

long long fetch_and(long long,

1335

memory_order = memory_order_seq_cst) volatile;

1336

long long fetch_and(long long, memory_order = memory_order_seq_cst);

1337

long long fetch_or(long long, memory_order = memory_order_seq_cst) volatile;

1338

long long fetch_or(long long, memory_order = memory_order_seq_cst);

1339

long long fetch_xor(long long,

1340

memory_order = memory_order_seq_cst) volatile;

1341

long long fetch_xor(long long, memory_order = memory_order_seq_cst);

1342

atomic_llong() = default;

1343

constexpr atomic_llong(long long);

1344

atomic_llong(const atomic_llong&) = delete;

1345

atomic_llong& operator=(const atomic_llong&) = delete;

1346

atomic_llong& operator=(const atomic_llong&) volatile = delete;

1347

long long operator=(long long) volatile;

1348

long long operator=(long long);

1349

long long operator++(int) volatile;

1350

long long operator++(int);

1351

long long operator--(int) volatile;

1352

long long operator--(int);

1353

long long operator++() volatile;

1354

long long operator++();

1355

long long operator--() volatile;

1356

long long operator--();

1357

long long operator+=(long long) volatile;

1358

long long operator+=(long long);

1359

long long operator-=(long long) volatile;

1360

long long operator-=(long long);

1361

long long operator&=(long long) volatile;

1362

long long operator&=(long long);

1363

long long operator|=(long long) volatile;

1364

long long operator|=(long long);

1365

long long operator^=(long long) volatile;

1366

long long operator^=(long long);

1367

} atomic_llong;

1368

1369

bool atomic_is_lock_free(const volatile atomic_llong*);

1370

bool atomic_is_lock_free(const atomic_llong*);

1371

void atomic_init(volatile atomic_llong*, itype);

1372

void atomic_init(atomic_llong*, itype);

1373

void atomic_store(volatile atomic_llong*, long long);

1374

void atomic_store(atomic_llong*, long long);

1375

void atomic_store_explicit(volatile atomic_llong*, long long, memory_order);

1376

void atomic_store_explicit(atomic_llong*, long long, memory_order);

1377

long long atomic_load(const volatile atomic_llong*);

1378

long long atomic_load(const atomic_llong*);

1379

long long atomic_load_explicit(const volatile atomic_llong*, memory_order);

1380

long long atomic_load_explicit(const atomic_llong*, memory_order);

1381

long long atomic_exchange(volatile atomic_llong*, long long);

1382

long long atomic_exchange(atomic_llong*, long long);

1383

long long atomic_exchange_explicit(volatile atomic_llong*, long long,

1384

memory_order);

1385

long long atomic_exchange_explicit(atomic_llong*, long long, memory_order);

1386

bool atomic_compare_exchange_weak(volatile atomic_llong*, long long*,

1387

long long);

1388

bool atomic_compare_exchange_weak(atomic_llong*, long long*, long long);

1389

bool atomic_compare_exchange_strong(volatile atomic_llong*, long long*,

1390

long long);

1391

bool atomic_compare_exchange_strong(atomic_llong*, long long*, long long);

1392

bool atomic_compare_exchange_weak_explicit(volatile atomic_llong*, long long*,

1393

long long, memory_order,

1394

memory_order);

1395

bool atomic_compare_exchange_weak_explicit(atomic_llong*, long long*, long long,

1396

memory_order, memory_order);

1397

bool atomic_compare_exchange_strong_explicit(volatile atomic_llong*, long long*,

1398

long long, memory_order,

1399

memory_order);

1400

bool atomic_compare_exchange_strong_explicit(atomic_llong*, long long*,

1401

long long, memory_order,

1402

memory_order);

1403

long long atomic_fetch_add(volatile atomic_llong*, long long);

1404

long long atomic_fetch_add(atomic_llong*, long long);

1405

long long atomic_fetch_add_explicit(volatile atomic_llong*, long long,

1406

memory_order);

1407

long long atomic_fetch_add_explicit(atomic_llong*, long long, memory_order);

1408

long long atomic_fetch_sub(volatile atomic_llong*, long long);

1409

long long atomic_fetch_sub(atomic_llong*, long long);

1410

long long atomic_fetch_sub_explicit(volatile atomic_llong*, long long,

1411

memory_order);

1412

long long atomic_fetch_sub_explicit(atomic_llong*, long long, memory_order);

1413

long long atomic_fetch_and(volatile atomic_llong*, long long);

1414

long long atomic_fetch_and(atomic_llong*, long long);

1415

long long atomic_fetch_and_explicit(volatile atomic_llong*, long long,

1416

memory_order);

1417

long long atomic_fetch_and_explicit(atomic_llong*, long long, memory_order);

1418

long long atomic_fetch_or(volatile atomic_llong*, long long);

1419

long long atomic_fetch_or(atomic_llong*, long long);

1420

long long atomic_fetch_or_explicit(volatile atomic_llong*, long long,

1421

memory_order);

1422

long long atomic_fetch_or_explicit(atomic_llong*, long long, memory_order);

1423

long long atomic_fetch_xor(volatile atomic_llong*, long long);

1424

long long atomic_fetch_xor(atomic_llong*, long long);

1425

long long atomic_fetch_xor_explicit(volatile atomic_llong*, long long,

1426

memory_order);

1427

long long atomic_fetch_xor_explicit(atomic_llong*, long long, memory_order);

// atomic_ullong

typedef struct atomic_ullong

1432

{

1433

bool is_lock_free() const volatile;

1434

bool is_lock_free() const;

1435

void store(unsigned long long,

1436

memory_order = memory_order_seq_cst) volatile;

1437

void store(unsigned long long, memory_order = memory_order_seq_cst);

1438

unsigned long long load(memory_order = memory_order_seq_cst) const volatile;

1439

unsigned long long load(memory_order = memory_order_seq_cst) const;

1440

operator unsigned long long() const volatile;

1441

operator unsigned long long() const;

1442

unsigned long long exchange(unsigned long long,

1443

memory_order = memory_order_seq_cst) volatile;

1444

unsigned long long exchange(unsigned long long,

1445

memory_order = memory_order_seq_cst);

1446

bool compare_exchange_weak(unsigned long long&, unsigned long long,

1447

memory_order, memory_order) volatile;

1448

bool compare_exchange_weak(unsigned long long&, unsigned long long,

1449

memory_order, memory_order);

1450

bool compare_exchange_strong(unsigned long long&, unsigned long long,

1451

memory_order, memory_order) volatile;

1452

bool compare_exchange_strong(unsigned long long&, unsigned long long,

1453

memory_order, memory_order);

1454

bool compare_exchange_weak(unsigned long long&, unsigned long long,

1455

memory_order = memory_order_seq_cst) volatile;

1456

bool compare_exchange_weak(unsigned long long&, unsigned long long,

1457

memory_order = memory_order_seq_cst);

1458

bool compare_exchange_strong(unsigned long long&, unsigned long long,

1459

memory_order = memory_order_seq_cst) volatile;

1460

bool compare_exchange_strong(unsigned long long&, unsigned long long,

1461

memory_order = memory_order_seq_cst);

1462

unsigned long long fetch_add(unsigned long long,

1463

memory_order = memory_order_seq_cst) volatile;

1464

unsigned long long fetch_add(unsigned long long,

1465

memory_order = memory_order_seq_cst);

1466

unsigned long long fetch_sub(unsigned long long,

1467

memory_order = memory_order_seq_cst) volatile;

1468

unsigned long long fetch_sub(unsigned long long,

1469

memory_order = memory_order_seq_cst);

1470

unsigned long long fetch_and(unsigned long long,

1471

memory_order = memory_order_seq_cst) volatile;

1472

unsigned long long fetch_and(unsigned long long,

1473

memory_order = memory_order_seq_cst);

1474

unsigned long long fetch_or(unsigned long long,

1475

memory_order = memory_order_seq_cst) volatile;

1476

unsigned long long fetch_or(unsigned long long,

1477

memory_order = memory_order_seq_cst);

1478

unsigned long long fetch_xor(unsigned long long,

1479

memory_order = memory_order_seq_cst) volatile;

1480

unsigned long long fetch_xor(unsigned long long,

1481

memory_order = memory_order_seq_cst);

1482

atomic_ullong() = default;

1483

constexpr atomic_ullong(unsigned long long);

1484

atomic_ullong(const atomic_ullong&) = delete;

1485

atomic_ullong& operator=(const atomic_ullong&) = delete;

1486

atomic_ullong& operator=(const atomic_ullong&) volatile = delete;

1487

unsigned long long operator=(unsigned long long) volatile;

1488

unsigned long long operator=(unsigned long long);

1489

unsigned long long operator++(int) volatile;

1490

unsigned long long operator++(int);

1491

unsigned long long operator--(int) volatile;

1492

unsigned long long operator--(int);

1493

unsigned long long operator++() volatile;

1494

unsigned long long operator++();

1495

unsigned long long operator--() volatile;

1496

unsigned long long operator--();

1497

unsigned long long operator+=(unsigned long long) volatile;

1498

unsigned long long operator+=(unsigned long long);

1499

unsigned long long operator-=(unsigned long long) volatile;

1500

unsigned long long operator-=(unsigned long long);

1501

unsigned long long operator&=(unsigned long long) volatile;

1502

unsigned long long operator&=(unsigned long long);

1503

unsigned long long operator|=(unsigned long long) volatile;

1504

unsigned long long operator|=(unsigned long long);

1505

unsigned long long operator^=(unsigned long long) volatile;

1506

unsigned long long operator^=(unsigned long long);

1507

} atomic_ullong;

1508

1509

bool atomic_is_lock_free(const volatile atomic_ullong*);

1510

bool atomic_is_lock_free(const atomic_ullong*);

1511

void atomic_init(volatile atomic_ullong*, itype);

1512

void atomic_init(atomic_ullong*, itype);

1513

void atomic_store(volatile atomic_ullong*, unsigned long long);

1514

void atomic_store(atomic_ullong*, unsigned long long);

1515

void atomic_store_explicit(volatile atomic_ullong*, unsigned long long,

1516

memory_order);

1517

void atomic_store_explicit(atomic_ullong*, unsigned long long, memory_order);

1518

unsigned long long atomic_load(const volatile atomic_ullong*);

1519

unsigned long long atomic_load(const atomic_ullong*);

1520

unsigned long long atomic_load_explicit(const volatile atomic_ullong*,

1521

memory_order);

1522

unsigned long long atomic_load_explicit(const atomic_ullong*, memory_order);

1523

unsigned long long atomic_exchange(volatile atomic_ullong*, unsigned long long);

1524

unsigned long long atomic_exchange(atomic_ullong*, unsigned long long);

1525

unsigned long long atomic_exchange_explicit(volatile atomic_ullong*,

1526

unsigned long long, memory_order);

1527

unsigned long long atomic_exchange_explicit(atomic_ullong*, unsigned long long,

1528

memory_order);

1529

bool atomic_compare_exchange_weak(volatile atomic_ullong*, unsigned long long*,

1530

unsigned long long);

1531

bool atomic_compare_exchange_weak(atomic_ullong*, unsigned long long*,

1532

unsigned long long);

1533

bool atomic_compare_exchange_strong(volatile atomic_ullong*,

1534

unsigned long long*, unsigned long long);

1535

bool atomic_compare_exchange_strong(atomic_ullong*, unsigned long long*,

1536

unsigned long long);

1537

bool atomic_compare_exchange_weak_explicit(volatile atomic_ullong*,

1538

unsigned long long*,

1539

unsigned long long, memory_order,

1540

memory_order);

1541

bool atomic_compare_exchange_weak_explicit(atomic_ullong*, unsigned long long*,

1542

unsigned long long, memory_order,

1543

memory_order);

1544

bool atomic_compare_exchange_strong_explicit(volatile atomic_ullong*,

1545

unsigned long long*,

1546

unsigned long long, memory_order,

1547

memory_order);

1548

bool atomic_compare_exchange_strong_explicit(atomic_ullong*,

1549

unsigned long long*,

1550

unsigned long long, memory_order,

1551

memory_order);

1552

unsigned long long atomic_fetch_add(volatile atomic_ullong*,

1553

unsigned long long);

1554

unsigned long long atomic_fetch_add(atomic_ullong*, unsigned long long);

1555

unsigned long long atomic_fetch_add_explicit(volatile atomic_ullong*,

1556

unsigned long long, memory_order);

1557

unsigned long long atomic_fetch_add_explicit(atomic_ullong*, unsigned long long,

1558

memory_order);

1559

unsigned long long atomic_fetch_sub(volatile atomic_ullong*,

1560

unsigned long long);

1561

unsigned long long atomic_fetch_sub(atomic_ullong*, unsigned long long);

1562

unsigned long long atomic_fetch_sub_explicit(volatile atomic_ullong*,

1563

unsigned long long, memory_order);

1564

unsigned long long atomic_fetch_sub_explicit(atomic_ullong*, unsigned long long,

1565

memory_order);

1566

unsigned long long atomic_fetch_and(volatile atomic_ullong*,

1567

unsigned long long);

1568

unsigned long long atomic_fetch_and(atomic_ullong*, unsigned long long);

1569

unsigned long long atomic_fetch_and_explicit(volatile atomic_ullong*,

1570

unsigned long long, memory_order);

1571

unsigned long long atomic_fetch_and_explicit(atomic_ullong*, unsigned long long,

1572

memory_order);

1573

unsigned long long atomic_fetch_or(volatile atomic_ullong*, unsigned long long);

1574

unsigned long long atomic_fetch_or(atomic_ullong*, unsigned long long);

1575

unsigned long long atomic_fetch_or_explicit(volatile atomic_ullong*,

1576

unsigned long long, memory_order);

1577

unsigned long long atomic_fetch_or_explicit(atomic_ullong*, unsigned long long,

1578

memory_order);

1579

unsigned long long atomic_fetch_xor(volatile atomic_ullong*,

1580

unsigned long long);

1581

unsigned long long atomic_fetch_xor(atomic_ullong*, unsigned long long);

1582

unsigned long long atomic_fetch_xor_explicit(volatile atomic_ullong*,

1583

unsigned long long, memory_order);

1584

unsigned long long atomic_fetch_xor_explicit(atomic_ullong*, unsigned long long,

memory_order);

// atomic_char16_t

typedef struct atomic_char16_t

1590

{

1591

bool is_lock_free() const volatile;

1592

bool is_lock_free() const;

1593

void store(char16_t, memory_order = memory_order_seq_cst) volatile;

1594

void store(char16_t, memory_order = memory_order_seq_cst);

1595

char16_t load(memory_order = memory_order_seq_cst) const volatile;

1596

char16_t load(memory_order = memory_order_seq_cst) const;

1597

operator char16_t() const volatile;

1598

operator char16_t() const;

1599

char16_t exchange(char16_t,

1600

memory_order = memory_order_seq_cst) volatile;

1601

char16_t exchange(char16_t, memory_order = memory_order_seq_cst);

1602

bool compare_exchange_weak(char16_t&, char16_t, memory_order,

1603

memory_order) volatile;

1604

bool compare_exchange_weak(char16_t&, char16_t, memory_order, memory_order);

1605

bool compare_exchange_strong(char16_t&, char16_t, memory_order,

1606

memory_order) volatile;

1607

bool compare_exchange_strong(char16_t&, char16_t,

1608

memory_order, memory_order);

1609

bool compare_exchange_weak(char16_t&, char16_t,

1610

memory_order = memory_order_seq_cst) volatile;

1611

bool compare_exchange_weak(char16_t&, char16_t,

1612

memory_order = memory_order_seq_cst);

1613

bool compare_exchange_strong(char16_t&, char16_t,

1614

memory_order = memory_order_seq_cst) volatile;

1615

bool compare_exchange_strong(char16_t&, char16_t,

1616

memory_order = memory_order_seq_cst);

1617

char16_t fetch_add(char16_t, memory_order = memory_order_seq_cst) volatile;

1618

char16_t fetch_add(char16_t, memory_order = memory_order_seq_cst);

1619

char16_t fetch_sub(char16_t, memory_order = memory_order_seq_cst) volatile;

1620

char16_t fetch_sub(char16_t, memory_order = memory_order_seq_cst);

1621

char16_t fetch_and(char16_t, memory_order = memory_order_seq_cst) volatile;

1622

char16_t fetch_and(char16_t, memory_order = memory_order_seq_cst);

1623

char16_t fetch_or(char16_t, memory_order = memory_order_seq_cst) volatile;

1624

char16_t fetch_or(char16_t, memory_order = memory_order_seq_cst);

1625

char16_t fetch_xor(char16_t, memory_order = memory_order_seq_cst) volatile;

1626

char16_t fetch_xor(char16_t, memory_order = memory_order_seq_cst);

1627

atomic_char16_t() = default;

1628

constexpr atomic_char16_t(char16_t);

1629

atomic_char16_t(const atomic_char16_t&) = delete;

1630

atomic_char16_t& operator=(const atomic_char16_t&) = delete;

1631

atomic_char16_t& operator=(const atomic_char16_t&) volatile = delete;

1632

char16_t operator=(char16_t) volatile;

1633

char16_t operator=(char16_t);

1634

char16_t operator++(int) volatile;

1635

char16_t operator++(int);

1636

char16_t operator--(int) volatile;

1637

char16_t operator--(int);

1638

char16_t operator++() volatile;

1639

char16_t operator++();

1640

char16_t operator--() volatile;

1641

char16_t operator--();

1642

char16_t operator+=(char16_t) volatile;

1643

char16_t operator+=(char16_t);

1644

char16_t operator-=(char16_t) volatile;

1645

char16_t operator-=(char16_t);

1646

char16_t operator&=(char16_t) volatile;

1647

char16_t operator&=(char16_t);

1648

char16_t operator|=(char16_t) volatile;

1649

char16_t operator|=(char16_t);

1650

char16_t operator^=(char16_t) volatile;

1651

char16_t operator^=(char16_t);

1652

} atomic_char16_t;

1653

1654

bool atomic_is_lock_free(const volatile atomic_char16_t*);

1655

bool atomic_is_lock_free(const atomic_char16_t*);

1656

void atomic_init(volatile atomic_char16_t*, itype);

1657

void atomic_init(atomic_char16_t*, itype);

1658

void atomic_store(volatile atomic_char16_t*, char16_t);

1659

void atomic_store(atomic_char16_t*, char16_t);

1660

void atomic_store_explicit(volatile atomic_char16_t*, char16_t, memory_order);

1661

void atomic_store_explicit(atomic_char16_t*, char16_t, memory_order);

1662

char16_t atomic_load(const volatile atomic_char16_t*);

1663

char16_t atomic_load(const atomic_char16_t*);

1664

char16_t atomic_load_explicit(const volatile atomic_char16_t*, memory_order);

1665

char16_t atomic_load_explicit(const atomic_char16_t*, memory_order);

1666

char16_t atomic_exchange(volatile atomic_char16_t*, char16_t);

1667

char16_t atomic_exchange(atomic_char16_t*, char16_t);

1668

char16_t atomic_exchange_explicit(volatile atomic_char16_t*, char16_t,

1669

memory_order);

1670

char16_t atomic_exchange_explicit(atomic_char16_t*, char16_t, memory_order);

1671

bool atomic_compare_exchange_weak(volatile atomic_char16_t*, char16_t*,

1672

char16_t);

1673

bool atomic_compare_exchange_weak(atomic_char16_t*, char16_t*, char16_t);

1674

bool atomic_compare_exchange_strong(volatile atomic_char16_t*, char16_t*,

1675

char16_t);

1676

bool atomic_compare_exchange_strong(atomic_char16_t*, char16_t*, char16_t);

1677

bool atomic_compare_exchange_weak_explicit(volatile atomic_char16_t*, char16_t*,

1678

char16_t, memory_order,

1679

memory_order);

1680

bool atomic_compare_exchange_weak_explicit(atomic_char16_t*, char16_t*,

1681

char16_t, memory_order,

1682

memory_order);

1683

bool atomic_compare_exchange_strong_explicit(volatile atomic_char16_t*,

1684

char16_t*, char16_t, memory_order,

1685

memory_order);

1686

bool atomic_compare_exchange_strong_explicit(atomic_char16_t*, char16_t*,

1687

char16_t, memory_order,

1688

memory_order);

1689

char16_t atomic_fetch_add(volatile atomic_char16_t*, char16_t);

1690

char16_t atomic_fetch_add(atomic_char16_t*, char16_t);

1691

char16_t atomic_fetch_add_explicit(volatile atomic_char16_t*, char16_t,

1692

memory_order);

1693

char16_t atomic_fetch_add_explicit(atomic_char16_t*, char16_t, memory_order);

1694

char16_t atomic_fetch_sub(volatile atomic_char16_t*, char16_t);

1695

char16_t atomic_fetch_sub(atomic_char16_t*, char16_t);

1696

char16_t atomic_fetch_sub_explicit(volatile atomic_char16_t*, char16_t,

1697

memory_order);

1698

char16_t atomic_fetch_sub_explicit(atomic_char16_t*, char16_t, memory_order);

1699

char16_t atomic_fetch_and(volatile atomic_char16_t*, char16_t);

1700

char16_t atomic_fetch_and(atomic_char16_t*, char16_t);

1701

char16_t atomic_fetch_and_explicit(volatile atomic_char16_t*, char16_t,

1702

memory_order);

1703

char16_t atomic_fetch_and_explicit(atomic_char16_t*, char16_t, memory_order);

1704

char16_t atomic_fetch_or(volatile atomic_char16_t*, char16_t);

1705

char16_t atomic_fetch_or(atomic_char16_t*, char16_t);

1706

char16_t atomic_fetch_or_explicit(volatile atomic_char16_t*, char16_t,

1707

memory_order);

1708

char16_t atomic_fetch_or_explicit(atomic_char16_t*, char16_t, memory_order);

1709

char16_t atomic_fetch_xor(volatile atomic_char16_t*, char16_t);

1710

char16_t atomic_fetch_xor(atomic_char16_t*, char16_t);

1711

char16_t atomic_fetch_xor_explicit(volatile atomic_char16_t*, char16_t,

1712

memory_order);

1713

char16_t atomic_fetch_xor_explicit(atomic_char16_t*, char16_t, memory_order);

// atomic_char32_t

typedef struct atomic_char32_t

1718

{

1719

bool is_lock_free() const volatile;

1720

bool is_lock_free() const;

1721

void store(char32_t, memory_order = memory_order_seq_cst) volatile;

1722

void store(char32_t, memory_order = memory_order_seq_cst);

1723

char32_t load(memory_order = memory_order_seq_cst) const volatile;

1724

char32_t load(memory_order = memory_order_seq_cst) const;

1725

operator char32_t() const volatile;

1726

operator char32_t() const;

1727

char32_t exchange(char32_t,

1728

memory_order = memory_order_seq_cst) volatile;

1729

char32_t exchange(char32_t, memory_order = memory_order_seq_cst);

1730

bool compare_exchange_weak(char32_t&, char32_t, memory_order,

1731

memory_order) volatile;

1732

bool compare_exchange_weak(char32_t&, char32_t, memory_order, memory_order);

1733

bool compare_exchange_strong(char32_t&, char32_t, memory_order,

1734

memory_order) volatile;

1735

bool compare_exchange_strong(char32_t&, char32_t,

1736

memory_order, memory_order);

1737

bool compare_exchange_weak(char32_t&, char32_t,

1738

memory_order = memory_order_seq_cst) volatile;

1739

bool compare_exchange_weak(char32_t&, char32_t,

1740

memory_order = memory_order_seq_cst);

1741

bool compare_exchange_strong(char32_t&, char32_t,

1742

memory_order = memory_order_seq_cst) volatile;

1743

bool compare_exchange_strong(char32_t&, char32_t,

1744

memory_order = memory_order_seq_cst);

1745

char32_t fetch_add(char32_t, memory_order = memory_order_seq_cst) volatile;

1746

char32_t fetch_add(char32_t, memory_order = memory_order_seq_cst);

1747

char32_t fetch_sub(char32_t, memory_order = memory_order_seq_cst) volatile;

1748

char32_t fetch_sub(char32_t, memory_order = memory_order_seq_cst);

1749

char32_t fetch_and(char32_t, memory_order = memory_order_seq_cst) volatile;

1750

char32_t fetch_and(char32_t, memory_order = memory_order_seq_cst);

1751

char32_t fetch_or(char32_t, memory_order = memory_order_seq_cst) volatile;

1752

char32_t fetch_or(char32_t, memory_order = memory_order_seq_cst);

1753

char32_t fetch_xor(char32_t, memory_order = memory_order_seq_cst) volatile;

1754

char32_t fetch_xor(char32_t, memory_order = memory_order_seq_cst);

1755

atomic_char32_t() = default;

1756

constexpr atomic_char32_t(char32_t);

1757

atomic_char32_t(const atomic_char32_t&) = delete;

1758

atomic_char32_t& operator=(const atomic_char32_t&) = delete;

1759

atomic_char32_t& operator=(const atomic_char32_t&) volatile = delete;

1760

char32_t operator=(char32_t) volatile;

1761

char32_t operator=(char32_t);

1762

char32_t operator++(int) volatile;

1763

char32_t operator++(int);

1764

char32_t operator--(int) volatile;

1765

char32_t operator--(int);

1766

char32_t operator++() volatile;

1767

char32_t operator++();

1768

char32_t operator--() volatile;

1769

char32_t operator--();

1770

char32_t operator+=(char32_t) volatile;

1771

char32_t operator+=(char32_t);

1772

char32_t operator-=(char32_t) volatile;

1773

char32_t operator-=(char32_t);

1774

char32_t operator&=(char32_t) volatile;

1775

char32_t operator&=(char32_t);

1776

char32_t operator|=(char32_t) volatile;

1777

char32_t operator|=(char32_t);

1778

char32_t operator^=(char32_t) volatile;

1779

char32_t operator^=(char32_t);

1780

} atomic_char32_t;

1781

1782

bool atomic_is_lock_free(const volatile atomic_char32_t*);

1783

bool atomic_is_lock_free(const atomic_char32_t*);

1784

void atomic_init(volatile atomic_char32_t*, itype);

1785

void atomic_init(atomic_char32_t*, itype);

1786

void atomic_store(volatile atomic_char32_t*, char32_t);

1787

void atomic_store(atomic_char32_t*, char32_t);

1788

void atomic_store_explicit(volatile atomic_char32_t*, char32_t, memory_order);

1789

void atomic_store_explicit(atomic_char32_t*, char32_t, memory_order);

1790

char32_t atomic_load(const volatile atomic_char32_t*);

1791

char32_t atomic_load(const atomic_char32_t*);

1792

char32_t atomic_load_explicit(const volatile atomic_char32_t*, memory_order);

1793

char32_t atomic_load_explicit(const atomic_char32_t*, memory_order);

1794

char32_t atomic_exchange(volatile atomic_char32_t*, char32_t);

1795

char32_t atomic_exchange(atomic_char32_t*, char32_t);

1796

char32_t atomic_exchange_explicit(volatile atomic_char32_t*, char32_t,

1797

memory_order);

1798

char32_t atomic_exchange_explicit(atomic_char32_t*, char32_t, memory_order);

1799

bool atomic_compare_exchange_weak(volatile atomic_char32_t*, char32_t*,

1800

char32_t);

1801

bool atomic_compare_exchange_weak(atomic_char32_t*, char32_t*, char32_t);

1802

bool atomic_compare_exchange_strong(volatile atomic_char32_t*, char32_t*,

1803

char32_t);

1804

bool atomic_compare_exchange_strong(atomic_char32_t*, char32_t*, char32_t);

1805

bool atomic_compare_exchange_weak_explicit(volatile atomic_char32_t*, char32_t*,

1806

char32_t, memory_order,

1807

memory_order);

1808

bool atomic_compare_exchange_weak_explicit(atomic_char32_t*, char32_t*,

1809

char32_t, memory_order,

1810

memory_order);

1811

bool atomic_compare_exchange_strong_explicit(volatile atomic_char32_t*,

1812

char32_t*, char32_t, memory_order,

1813

memory_order);

1814

bool atomic_compare_exchange_strong_explicit(atomic_char32_t*, char32_t*,

1815

char32_t, memory_order,

1816

memory_order);

1817

char32_t atomic_fetch_add(volatile atomic_char32_t*, char32_t);

1818

char32_t atomic_fetch_add(atomic_char32_t*, char32_t);

1819

char32_t atomic_fetch_add_explicit(volatile atomic_char32_t*, char32_t,

1820

memory_order);

1821

char32_t atomic_fetch_add_explicit(atomic_char32_t*, char32_t, memory_order);

1822

char32_t atomic_fetch_sub(volatile atomic_char32_t*, char32_t);

1823

char32_t atomic_fetch_sub(atomic_char32_t*, char32_t);

1824

char32_t atomic_fetch_sub_explicit(volatile atomic_char32_t*, char32_t,

1825

memory_order);

1826

char32_t atomic_fetch_sub_explicit(atomic_char32_t*, char32_t, memory_order);

1827

char32_t atomic_fetch_and(volatile atomic_char32_t*, char32_t);

1828

char32_t atomic_fetch_and(atomic_char32_t*, char32_t);

1829

char32_t atomic_fetch_and_explicit(volatile atomic_char32_t*, char32_t,

1830

memory_order);

1831

char32_t atomic_fetch_and_explicit(atomic_char32_t*, char32_t, memory_order);

1832

char32_t atomic_fetch_or(volatile atomic_char32_t*, char32_t);

1833

char32_t atomic_fetch_or(atomic_char32_t*, char32_t);

1834

char32_t atomic_fetch_or_explicit(volatile atomic_char32_t*, char32_t,

1835

memory_order);

1836

char32_t atomic_fetch_or_explicit(atomic_char32_t*, char32_t, memory_order);

1837

char32_t atomic_fetch_xor(volatile atomic_char32_t*, char32_t);

1838

char32_t atomic_fetch_xor(atomic_char32_t*, char32_t);

1839

char32_t atomic_fetch_xor_explicit(volatile atomic_char32_t*, char32_t,

1840

memory_order);

1841

char32_t atomic_fetch_xor_explicit(atomic_char32_t*, char32_t, memory_order);

// atomic_wchar_t

typedef struct atomic_wchar_t

1846

{

1847

bool is_lock_free() const volatile;

1848

bool is_lock_free() const;

1849

void store(wchar_t, memory_order = memory_order_seq_cst) volatile;

1850

void store(wchar_t, memory_order = memory_order_seq_cst);

1851

wchar_t load(memory_order = memory_order_seq_cst) const volatile;

1852

wchar_t load(memory_order = memory_order_seq_cst) const;

1853

operator wchar_t() const volatile;

1854

operator wchar_t() const;

1855

wchar_t exchange(wchar_t,

1856

memory_order = memory_order_seq_cst) volatile;

1857

wchar_t exchange(wchar_t, memory_order = memory_order_seq_cst);

1858

bool compare_exchange_weak(wchar_t&, wchar_t, memory_order,

1859

memory_order) volatile;

1860

bool compare_exchange_weak(wchar_t&, wchar_t, memory_order, memory_order);

1861

bool compare_exchange_strong(wchar_t&, wchar_t, memory_order,

1862

memory_order) volatile;

1863

bool compare_exchange_strong(wchar_t&, wchar_t, memory_order, memory_order);

1864

bool compare_exchange_weak(wchar_t&, wchar_t,

1865

memory_order = memory_order_seq_cst) volatile;

1866

bool compare_exchange_weak(wchar_t&, wchar_t,

1867

memory_order = memory_order_seq_cst);

1868

bool compare_exchange_strong(wchar_t&, wchar_t,

1869

memory_order = memory_order_seq_cst) volatile;

1870

bool compare_exchange_strong(wchar_t&, wchar_t,

1871

memory_order = memory_order_seq_cst);

1872

wchar_t fetch_add(wchar_t, memory_order = memory_order_seq_cst) volatile;

1873

wchar_t fetch_add(wchar_t, memory_order = memory_order_seq_cst);

1874

wchar_t fetch_sub(wchar_t, memory_order = memory_order_seq_cst) volatile;

1875

wchar_t fetch_sub(wchar_t, memory_order = memory_order_seq_cst);

1876

wchar_t fetch_and(wchar_t, memory_order = memory_order_seq_cst) volatile;

1877

wchar_t fetch_and(wchar_t, memory_order = memory_order_seq_cst);

1878

wchar_t fetch_or(wchar_t, memory_order = memory_order_seq_cst) volatile;

1879

wchar_t fetch_or(wchar_t, memory_order = memory_order_seq_cst);

1880

wchar_t fetch_xor(wchar_t, memory_order = memory_order_seq_cst) volatile;

1881

wchar_t fetch_xor(wchar_t, memory_order = memory_order_seq_cst);

1882

atomic_wchar_t() = default;

1883

constexpr atomic_wchar_t(wchar_t);

1884

atomic_wchar_t(const atomic_wchar_t&) = delete;

1885

atomic_wchar_t& operator=(const atomic_wchar_t&) = delete;

1886

atomic_wchar_t& operator=(const atomic_wchar_t&) volatile = delete;

1887

wchar_t operator=(wchar_t) volatile;

1888

wchar_t operator=(wchar_t);

1889

wchar_t operator++(int) volatile;

1890

wchar_t operator++(int);

1891

wchar_t operator--(int) volatile;

1892

wchar_t operator--(int);

1893

wchar_t operator++() volatile;

1894

wchar_t operator++();

1895

wchar_t operator--() volatile;

1896

wchar_t operator--();

1897

wchar_t operator+=(wchar_t) volatile;

1898

wchar_t operator+=(wchar_t);

1899

wchar_t operator-=(wchar_t) volatile;

1900

wchar_t operator-=(wchar_t);

1901

wchar_t operator&=(wchar_t) volatile;

1902

wchar_t operator&=(wchar_t);

1903

wchar_t operator|=(wchar_t) volatile;

1904

wchar_t operator|=(wchar_t);

1905

wchar_t operator^=(wchar_t) volatile;

1906

wchar_t operator^=(wchar_t);

1907

} atomic_wchar_t;

1908

1909

bool atomic_is_lock_free(const volatile atomic_wchar_t*);

1910

bool atomic_is_lock_free(const atomic_wchar_t*);

1911

void atomic_init(volatile atomic_wchar_t*, itype);

1912

void atomic_init(atomic_wchar_t*, itype);

1913

void atomic_store(volatile atomic_wchar_t*, wchar_t);

1914

void atomic_store(atomic_wchar_t*, wchar_t);

1915

void atomic_store_explicit(volatile atomic_wchar_t*, wchar_t, memory_order);

1916

void atomic_store_explicit(atomic_wchar_t*, wchar_t, memory_order);

1917

wchar_t atomic_load(const volatile atomic_wchar_t*);

1918

wchar_t atomic_load(const atomic_wchar_t*);

1919

wchar_t atomic_load_explicit(const volatile atomic_wchar_t*, memory_order);

1920

wchar_t atomic_load_explicit(const atomic_wchar_t*, memory_order);

1921

wchar_t atomic_exchange(volatile atomic_wchar_t*, wchar_t);

1922

wchar_t atomic_exchange(atomic_wchar_t*, wchar_t);

1923

wchar_t atomic_exchange_explicit(volatile atomic_wchar_t*,

1924

wchar_t, memory_order);

1925

wchar_t atomic_exchange_explicit(atomic_wchar_t*, wchar_t, memory_order);

1926

bool atomic_compare_exchange_weak(volatile atomic_wchar_t*, wchar_t*, wchar_t);

1927

bool atomic_compare_exchange_weak(atomic_wchar_t*, wchar_t*, wchar_t);

1928

bool atomic_compare_exchange_strong(volatile atomic_wchar_t*, wchar_t*,

1929

wchar_t);

1930

bool atomic_compare_exchange_strong(atomic_wchar_t*, wchar_t*, wchar_t);

1931

bool atomic_compare_exchange_weak_explicit(volatile atomic_wchar_t*, wchar_t*,

1932

wchar_t, memory_order, memory_order);

1933

bool atomic_compare_exchange_weak_explicit(atomic_wchar_t*, wchar_t*, wchar_t,

1934

memory_order, memory_order);

1935

bool atomic_compare_exchange_strong_explicit(volatile atomic_wchar_t*, wchar_t*,

1936

wchar_t, memory_order,

1937

memory_order);

1938

bool atomic_compare_exchange_strong_explicit(atomic_wchar_t*, wchar_t*, wchar_t,

1939

memory_order, memory_order);

1940

wchar_t atomic_fetch_add(volatile atomic_wchar_t*, wchar_t);

1941

wchar_t atomic_fetch_add(atomic_wchar_t*, wchar_t);

1942

wchar_t atomic_fetch_add_explicit(volatile atomic_wchar_t*, wchar_t,

1943

memory_order);

1944

wchar_t atomic_fetch_add_explicit(atomic_wchar_t*, wchar_t, memory_order);

1945

wchar_t atomic_fetch_sub(volatile atomic_wchar_t*, wchar_t);

1946

wchar_t atomic_fetch_sub(atomic_wchar_t*, wchar_t);

1947

wchar_t atomic_fetch_sub_explicit(volatile atomic_wchar_t*, wchar_t,

1948

memory_order);

1949

wchar_t atomic_fetch_sub_explicit(atomic_wchar_t*, wchar_t, memory_order);

1950

wchar_t atomic_fetch_and(volatile atomic_wchar_t*, wchar_t);

1951

wchar_t atomic_fetch_and(atomic_wchar_t*, wchar_t);

1952

wchar_t atomic_fetch_and_explicit(volatile atomic_wchar_t*, wchar_t,

1953

memory_order);

1954

wchar_t atomic_fetch_and_explicit(atomic_wchar_t*, wchar_t, memory_order);

1955

wchar_t atomic_fetch_or(volatile atomic_wchar_t*, wchar_t);

1956

wchar_t atomic_fetch_or(atomic_wchar_t*, wchar_t);

1957

wchar_t atomic_fetch_or_explicit(volatile atomic_wchar_t*, wchar_t,

1958

memory_order);

1959

wchar_t atomic_fetch_or_explicit(atomic_wchar_t*, wchar_t, memory_order);

1960

wchar_t atomic_fetch_xor(volatile atomic_wchar_t*, wchar_t);

1961

wchar_t atomic_fetch_xor(atomic_wchar_t*, wchar_t);

1962

wchar_t atomic_fetch_xor_explicit(volatile atomic_wchar_t*, wchar_t,

1963

memory_order);

1964

wchar_t atomic_fetch_xor_explicit(atomic_wchar_t*, wchar_t, memory_order);

1965

1966

// Atomics for standard typedef types

1967

1968

typedef atomic_schar atomic_int_least8_t;

1969

typedef atomic_uchar atomic_uint_least8_t;

1970

typedef atomic_short atomic_int_least16_t;

1971

typedef atomic_ushort atomic_uint_least16_t;

1972

typedef atomic_int atomic_int_least32_t;

1973

typedef atomic_uint atomic_uint_least32_t;

1974

typedef atomic_llong atomic_int_least64_t;

1975

typedef atomic_ullong atomic_uint_least64_t;

1976

1977

typedef atomic_schar atomic_int_fast8_t;

1978

typedef atomic_uchar atomic_uint_fast8_t;

1979

typedef atomic_short atomic_int_fast16_t;

1980

typedef atomic_ushort atomic_uint_fast16_t;

1981

typedef atomic_int atomic_int_fast32_t;

1982

typedef atomic_uint atomic_uint_fast32_t;

1983

typedef atomic_llong atomic_int_fast64_t;

1984

typedef atomic_ullong atomic_uint_fast64_t;

1985

1986

typedef atomic_long atomic_intptr_t;

1987

typedef atomic_ulong atomic_uintptr_t;

1988

typedef atomic_ulong atomic_size_t;

1989

typedef atomic_long atomic_ptrdiff_t;

1990

typedef atomic_llong atomic_intmax_t;

1991

typedef atomic_ullong atomic_uintmax_t;

// address types

typedef struct atomic_address

1996

{

1997

bool is_lock_free() const volatile;

1998

bool is_lock_free() const;

1999

void store(void*, memory_order = memory_order_seq_cst) volatile;

2000

void store(void*, memory_order = memory_order_seq_cst);

2001

void* load(memory_order = memory_order_seq_cst) const volatile;

2002

void* load(memory_order = memory_order_seq_cst) const;

2003

operator void*() const volatile;

2004

operator void*() const;

2005

void* exchange(void*, memory_order = memory_order_seq_cst) volatile;

2006

void* exchange(void*, memory_order = memory_order_seq_cst);

2007

bool compare_exchange_weak(void*&, void*, memory_order,

2008

memory_order) volatile;

2009

bool compare_exchange_weak(void*&, void*, memory_order, memory_order);

2010

bool compare_exchange_strong(void*&, void*, memory_order,

2011

memory_order) volatile;

2012

bool compare_exchange_strong(void*&, void*, memory_order, memory_order);

2013

bool compare_exchange_weak(void*&, void*,

2014

memory_order = memory_order_seq_cst) volatile;

2015

bool compare_exchange_weak(void*&, void*,

2016

memory_order = memory_order_seq_cst);

2017

bool compare_exchange_strong(void*&, void*,

2018

memory_order = memory_order_seq_cst) volatile;

2019

bool compare_exchange_strong(void*&, void*,

2020

memory_order = memory_order_seq_cst);

2021

bool compare_exchange_weak(const void*&, const void*,

2022

memory_order, memory_order) volatile;

2023

bool compare_exchange_weak(const void*&, const void*, memory_order,

2024

memory_order);

2025

bool compare_exchange_strong(const void*&, const void*, memory_order,

2026

memory_order) volatile;

2027

bool compare_exchange_strong(const void*&, const void*, memory_order,

2028

memory_order);

2029

bool compare_exchange_weak(const void*&, const void*,

2030

memory_order = memory_order_seq_cst) volatile;

2031

bool compare_exchange_weak(const void*&, const void*,

2032

memory_order = memory_order_seq_cst);

2033

bool compare_exchange_strong(const void*&, const void*,

2034

memory_order = memory_order_seq_cst) volatile;

2035

bool compare_exchange_strong(const void*&, const void*,

2036

memory_order = memory_order_seq_cst);

2037

void* fetch_add(ptrdiff_t, memory_order = memory_order_seq_cst) volatile;

2038

void* fetch_add(ptrdiff_t, memory_order = memory_order_seq_cst);

2039

void* fetch_sub(ptrdiff_t, memory_order = memory_order_seq_cst) volatile;

2040

void* fetch_sub(ptrdiff_t, memory_order = memory_order_seq_cst);

2041

atomic_address() = default;

2042

constexpr atomic_address(void*);

2043

atomic_address(const atomic_address&) = delete;

2044

atomic_address& operator=(const atomic_address&) = delete;

2045

atomic_address& operator=(const atomic_address&) volatile = delete;

2046

void* operator=(const void*) volatile;

2047

void* operator=(const void*);

2048

void* operator+=(ptrdiff_t) volatile;

2049

void* operator+=(ptrdiff_t);

2050

void* operator-=(ptrdiff_t) volatile;

2051

void* operator-=(ptrdiff_t);

2052

} atomic_address;

2053

2054

bool atomic_is_lock_free(const volatile atomic_address*);

2055

bool atomic_is_lock_free(const atomic_address*);

2056

void atomic_init(volatile atomic_address*, void*);

2057

void atomic_init(atomic_address*, void*);

2058

void atomic_store(volatile atomic_address*, void*);

2059

void atomic_store(atomic_address*, void*);

2060

void atomic_store_explicit(volatile atomic_address*, void*, memory_order);

2061

void atomic_store_explicit(atomic_address*, void*, memory_order);

2062

void* atomic_load(const volatile atomic_address*);

2063

void* atomic_load(const atomic_address*);

2064

void* atomic_load_explicit(const volatile atomic_address*, memory_order);

2065

void* atomic_load_explicit(const atomic_address*, memory_order);

2066

void* atomic_exchange(volatile atomic_address*, void*);

2067

void* atomic_exchange(atomic_address*, void*);

2068

void* atomic_exchange_explicit(volatile atomic_address*, void*, memory_order);

2069

void* atomic_exchange_explicit(atomic_address*, void*, memory_order);

2070

bool atomic_compare_exchange_weak(volatile atomic_address*, void**, void*);

2071

bool atomic_compare_exchange_weak(atomic_address*, void**, void*);

2072

bool atomic_compare_exchange_strong(volatile atomic_address*, void**, void*);

2073

bool atomic_compare_exchange_strong(atomic_address*, void**, void*);

2074

bool atomic_compare_exchange_weak_explicit(volatile atomic_address*, void**,

2075

void*, memory_order, memory_order);

2076

bool atomic_compare_exchange_weak_explicit(atomic_address*, void**, void*,

2077

memory_order, memory_order);

2078

bool atomic_compare_exchange_strong_explicit(volatile atomic_address*, void**,

2079

void*, memory_order, memory_order);

2080

bool atomic_compare_exchange_strong_explicit(atomic_address*, void**, void*,

2081

memory_order, memory_order);

2082

void* atomic_fetch_add(volatile atomic_address*, ptrdiff_t);

2083

void* atomic_fetch_add(atomic_address*, ptrdiff_t);

2084

void* atomic_fetch_add_explicit(volatile atomic_address*, ptrdiff_t,

2085

memory_order);

2086

void* atomic_fetch_add_explicit(atomic_address*, ptrdiff_t, memory_order);

2087

void* atomic_fetch_sub(volatile atomic_address*, ptrdiff_t);

2088

void* atomic_fetch_sub(atomic_address*, ptrdiff_t);

2089

void* atomic_fetch_sub_explicit(volatile atomic_address*, ptrdiff_t,

2090

memory_order);

2091

void* atomic_fetch_sub_explicit(atomic_address*, ptrdiff_t, memory_order);

// generic types

template <class T>

struct atomic

{

bool is_lock_free() const volatile;

2099

bool is_lock_free() const;

2100

void store(T, memory_order = memory_order_seq_cst) volatile;

2101

void store(T, memory_order = memory_order_seq_cst);

2102

T load(memory_order = memory_order_seq_cst) const volatile;

2103

T load(memory_order = memory_order_seq_cst) const;

2104

operator T() const volatile;

2105

operator T() const;

2106

T exchange(T, memory_order = memory_order_seq_cst) volatile;

2107

T exchange(T, memory_order = memory_order_seq_cst);

2108

bool compare_exchange_weak(T&, T, memory_order, memory_order) volatile;

2109

bool compare_exchange_weak(T&, T, memory_order, memory_order);

2110

bool compare_exchange_strong(T&, T, memory_order, memory_order) volatile;

2111

bool compare_exchange_strong(T&, T, memory_order, memory_order);

2112

bool compare_exchange_weak(T&, T,

2113

memory_order = memory_order_seq_cst) volatile;

2114

bool compare_exchange_weak(T&, T, memory_order = memory_order_seq_cst);

2115

bool compare_exchange_strong(T&, T,

2116

memory_order = memory_order_seq_cst) volatile;

2117

bool compare_exchange_strong(T&, T, memory_order = memory_order_seq_cst);

atomic() = default;

constexpr atomic(T);

atomic(const atomic&) = delete;

2122

atomic& operator=(const atomic&) = delete;

2123

atomic& operator=(const atomic&) volatile = delete;

2124

T operator=(T) volatile;

T operator=(T);

};

template <>

struct atomic<bool>

: public atomic_bool

{

atomic() = default;

constexpr atomic(bool);

2134

atomic(const atomic&) = delete;

2135

atomic& operator=(const atomic&) = delete;

2136

atomic& operator=(const atomic&) volatile = delete;

2137

bool operator=(bool) volatile;

2138

bool operator=(bool);

2139

operator bool() const volatile;

2140

operator bool() const;

};

template <>

struct atomic<char>

: public atomic_char

{

atomic() = default;

constexpr atomic(char);

2149

atomic(const atomic&) = delete;

2150

atomic& operator=(const atomic&) = delete;

2151

atomic& operator=(const atomic&) volatile = delete;

2152

char operator=(char) volatile;

2153

char operator=(char);

2154

operator char() const volatile;

2155

operator char() const;

};

template <>

struct atomic<signed char>

2160

: public atomic_schar

2161

{

2162

atomic() = default;

2163

constexpr atomic(signed char);

2164

atomic(const atomic&) = delete;

2165

atomic& operator=(const atomic&) = delete;

2166

atomic& operator=(const atomic&) volatile = delete;

2167

signed char operator=(signed char) volatile;

2168

signed char operator=(signed char);

2169

operator signed char() const volatile;

2170

operator signed char() const;

};

template <>

struct atomic<unsigned char>

2175

: public atomic_uchar

2176

{

2177

atomic() = default;

2178

constexpr atomic(unsigned char);

2179

atomic(const atomic&) = delete;

2180

atomic& operator=(const atomic&) = delete;

2181

atomic& operator=(const atomic&) volatile = delete;

2182

unsigned char operator=(unsigned char) volatile;

2183

unsigned char operator=(unsigned char);

2184

operator unsigned char() const volatile;

2185

operator unsigned char() const;

};

template <>

struct atomic<short>

: public atomic_short

2191

{

2192

atomic() = default;

2193

constexpr atomic(short);

2194

atomic(const atomic&) = delete;

2195

atomic& operator=(const atomic&) = delete;

2196

atomic& operator=(const atomic&) volatile = delete;

2197

short operator=(short) volatile;

2198

short operator=(short);

2199

operator short() const volatile;

2200

operator short() const;

};

template <>

struct atomic<unsigned short>

2205

: public atomic_ushort

2206

{

2207

atomic() = default;

2208

constexpr atomic(unsigned short);

2209

atomic(const atomic&) = delete;

2210

atomic& operator=(const atomic&) = delete;

2211

atomic& operator=(const atomic&) volatile = delete;

2212

unsigned short operator=(unsigned short) volatile;

2213

unsigned short operator=(unsigned short);

2214

operator unsigned short() const volatile;

2215

operator unsigned short() const;

};

template <>

struct atomic<int>

: public atomic_int

{

atomic() = default;

constexpr atomic(int);

2224

atomic(const atomic&) = delete;

2225

atomic& operator=(const atomic&) = delete;

2226

atomic& operator=(const atomic&) volatile = delete;

2227

int operator=(int) volatile;

2228

int operator=(int);

2229

operator int() const volatile;

2230

operator int() const;

};

template <>

struct atomic<unsigned int>

: public atomic_uint

{

atomic() = default;

constexpr atomic(unsigned int);

2239

atomic(const atomic&) = delete;

2240

atomic& operator=(const atomic&) = delete;

2241

atomic& operator=(const atomic&) volatile = delete;

2242

unsigned int operator=(unsigned int) volatile;

2243

unsigned int operator=(unsigned int);

2244

operator unsigned int() const volatile;

2245

operator unsigned int() const;

};

template <>

struct atomic<long>

: public atomic_long

{

atomic() = default;

constexpr atomic(long);

2254

atomic(const atomic&) = delete;

2255

atomic& operator=(const atomic&) = delete;

2256

atomic& operator=(const atomic&) volatile = delete;

2257

long operator=(long) volatile;

2258

long operator=(long);

2259

operator long() const volatile;

2260

operator long() const;

};

template <>

struct atomic<unsigned long>

2265

: public atomic_ulong

2266

{

2267

atomic() = default;

2268

constexpr atomic(unsigned long);

2269

atomic(const atomic&) = delete;

2270

atomic& operator=(const atomic&) = delete;

2271

atomic& operator=(const atomic&) volatile = delete;

2272

unsigned long operator=(unsigned long) volatile;

2273

unsigned long operator=(unsigned long);

2274

operator unsigned long() const volatile;

2275

operator unsigned long() const;

};

template <>

struct atomic<long long>

2280

: public atomic_llong

2281

{

2282

atomic() = default;

2283

constexpr atomic(long long);

2284

atomic(const atomic&) = delete;

2285

atomic& operator=(const atomic&) = delete;

2286

atomic& operator=(const atomic&) volatile = delete;

2287

long long operator=(long long) volatile;

2288

long long operator=(long long);

2289

operator long long() const volatile;

2290

operator long long() const;

};

template <>

struct atomic<unsigned long long>

2295

: public atomic_ullong

2296

{

2297

atomic() = default;

2298

constexpr atomic(unsigned long long);

2299

atomic(const atomic&) = delete;

2300

atomic& operator=(const atomic&) = delete;

2301

atomic& operator=(const atomic&) volatile = delete;

2302

unsigned long long operator=(unsigned long long) volatile;

2303

unsigned long long operator=(unsigned long long);

2304

operator unsigned long long() const volatile;

2305

operator unsigned long long() const;

};

template <>

struct atomic<char16_t>

2310

: public atomic_char16_t

2311

{

2312

atomic() = default;

2313

constexpr atomic(char16_t);

2314

atomic(const atomic&) = delete;

2315

atomic& operator=(const atomic&) = delete;

2316

atomic& operator=(const atomic&) volatile = delete;

2317

char16_t operator=(char16_t) volatile;

2318

char16_t operator=(char16_t);

2319

operator char16_t() const volatile;

2320

operator char16_t() const;

};

template <>

struct atomic<char32_t>

2325

: public atomic_char32_t

2326

{

2327

atomic() = default;

2328

constexpr atomic(char32_t);

2329

atomic(const atomic&) = delete;

2330

atomic& operator=(const atomic&) = delete;

2331

atomic& operator=(const atomic&) volatile = delete;

2332

char32_t operator=(char32_t) volatile;

2333

char32_t operator=(char32_t);

2334

operator char32_t() const volatile;

2335

operator char32_t() const;

};

template <>

struct atomic<wchar_t>

2340

: public atomic_wchar_t

2341

{

2342

atomic() = default;

2343

constexpr atomic(wchar_t);

2344

atomic(const atomic&) = delete;

2345

atomic& operator=(const atomic&) = delete;

2346

atomic& operator=(const atomic&) volatile = delete;

2347

wchar_t operator=(wchar_t) volatile;

2348

wchar_t operator=(wchar_t);

2349

operator wchar_t() const volatile;

2350

operator wchar_t() const;

};

template <class T>

struct atomic<T*>

: public atomic_address

2356

{

2357

void store(T*, memory_order = memory_order_seq_cst) volatile;

2358

void store(T*, memory_order = memory_order_seq_cst);

2359

T* load(memory_order = memory_order_seq_cst) const volatile;

2360

T* load(memory_order = memory_order_seq_cst) const;

2361

operator T*() const volatile;

2362

operator T*() const;

2363

T* exchange(T*, memory_order = memory_order_seq_cst) volatile;

2364

T* exchange(T*, memory_order = memory_order_seq_cst);

2365

bool compare_exchange_weak(T*&, T*, memory_order, memory_order) volatile;

2366

bool compare_exchange_weak(T*&, T*, memory_order, memory_order);

2367

bool compare_exchange_strong(T*&, T*, memory_order, memory_order) volatile;

2368

bool compare_exchange_strong(T*&, T*, memory_order, memory_order);

2369

bool compare_exchange_weak(T*&, T*,

2370

memory_order = memory_order_seq_cst) volatile;

2371

bool compare_exchange_weak(T*&, T*, memory_order = memory_order_seq_cst);

2372

bool compare_exchange_strong(T*&, T*,

2373

memory_order = memory_order_seq_cst) volatile;

2374

bool compare_exchange_strong(T*&, T*, memory_order = memory_order_seq_cst);

2375

T* fetch_add(ptrdiff_t, memory_order = memory_order_seq_cst) volatile;

2376

T* fetch_add(ptrdiff_t, memory_order = memory_order_seq_cst);

2377

T* fetch_sub(ptrdiff_t, memory_order = memory_order_seq_cst) volatile;

2378

T* fetch_sub(ptrdiff_t, memory_order = memory_order_seq_cst);

2379

atomic() = default;

2380

constexpr atomic(T*);

2381

atomic(const atomic&) = delete;

2382

atomic& operator=(const atomic&) = delete;

2383

atomic& operator=(const atomic&) volatile = delete;

2384

T* operator=(T*) volatile;

2385

T* operator=(T*);

2386

T* operator++(int) volatile;

2387

T* operator++(int);

2388

T* operator--(int) volatile;

2389

T* operator--(int);

2390

T* operator++() volatile;

2391

T* operator++();

2392

T* operator--() volatile;

2393

T* operator--();

2394

T* operator+=(ptrdiff_t) volatile;

2395

T* operator+=(ptrdiff_t);

2396

T* operator-=(ptrdiff_t) volatile;

2397

T* operator-=(ptrdiff_t);

};

// fences

void atomic_thread_fence(memory_order);

2403

void atomic_signal_fence(memory_order);

} // std

*/

#include <__config>

#pragma GCC system_header

2412

2413

_LIBCPP_BEGIN_NAMESPACE_STD

2414

2415

2416

_LIBCPP_END_NAMESPACE_STD

2417

2418

#endif // _LIBCPP_ATOMIC