FM / 4.4.4

/usr/include/c++/4.4.4/

/usr/include/c++/4.4.4

Name	Size	Mode	Actions
backward/	-	0755	rm
bits/	-	0755	rm
debug/	-	0755	rm
ext/	-	0755	rm
parallel/	-	0755	rm
tr1/	-	0755	rm
tr1_impl/	-	0755	rm
x86_64-redhat-linux/	-	0755	rm
algorithm	2528	0644	edit dl rm
array	1861	0644	edit dl rm
bitset	38246	0644	edit dl rm
c++0x_warning.h	1441	0644	edit dl rm
cassert	1691	0644	edit dl rm
ccomplex	1425	0644	edit dl rm
cctype	2862	0644	edit dl rm
cerrno	1813	0644	edit dl rm
cfenv	1872	0644	edit dl rm
cfloat	2046	0644	edit dl rm
chrono	21125	0644	edit dl rm
cinttypes	2151	0644	edit dl rm
ciso646	1513	0644	edit dl rm
climits	1956	0644	edit dl rm
clocale	1996	0644	edit dl rm
cmath	15560	0644	edit dl rm
complex	42262	0644	edit dl rm
complex.h	1374	0644	edit dl rm
condition_variable	6208	0644	edit dl rm
csetjmp	2040	0644	edit dl rm
csignal	1946	0644	edit dl rm
cstdarg	1935	0644	edit dl rm
cstdatomic	24336	0644	edit dl rm
cstdbool	1412	0644	edit dl rm
cstddef	1830	0644	edit dl rm
cstdint	2374	0644	edit dl rm
cstdio	4812	0644	edit dl rm
cstdlib	5723	0644	edit dl rm
cstring	3261	0644	edit dl rm
ctgmath	1327	0644	edit dl rm
ctime	2211	0644	edit dl rm
cwchar	6538	0644	edit dl rm
cwctype	3294	0644	edit dl rm
cxxabi-forced.h	1631	0644	edit dl rm
cxxabi.h	19106	0644	edit dl rm
deque	2658	0644	edit dl rm
exception	4856	0644	edit dl rm
exception_defines.h	1648	0644	edit dl rm
exception_ptr.h	4355	0644	edit dl rm
fenv.h	1888	0644	edit dl rm
forward_list	1480	0644	edit dl rm
fstream	29267	0644	edit dl rm
functional	2658	0644	edit dl rm
initializer_list	1987	0644	edit dl rm
iomanip	8696	0644	edit dl rm
ios	1658	0644	edit dl rm
iosfwd	6017	0644	edit dl rm
iostream	2654	0644	edit dl rm
istream	28304	0644	edit dl rm
iterator	2639	0644	edit dl rm
limits	45520	0644	edit dl rm
list	2588	0644	edit dl rm
locale	1480	0644	edit dl rm
map	2479	0644	edit dl rm
memory	3356	0644	edit dl rm
mutex	18380	0644	edit dl rm
new	3735	0644	edit dl rm
numeric	2808	0644	edit dl rm
ostream	18442	0644	edit dl rm
queue	2507	0644	edit dl rm
random	2086	0644	edit dl rm
ratio	9176	0644	edit dl rm
regex	2002	0644	edit dl rm
set	2479	0644	edit dl rm
sstream	18876	0644	edit dl rm
stack	2431	0644	edit dl rm
stdatomic.h	7263	0644	edit dl rm
stdexcept	4247	0644	edit dl rm
streambuf	28107	0644	edit dl rm
string	2021	0644	edit dl rm
system_error	9434	0644	edit dl rm
tgmath.h	1368	0644	edit dl rm
thread	6562	0644	edit dl rm
tuple	21068	0644	edit dl rm
typeinfo	7170	0644	edit dl rm
type_traits	17152	0644	edit dl rm
unordered_map	2448	0644	edit dl rm
unordered_set	2448	0644	edit dl rm
utility	3320	0644	edit dl rm
valarray	36486	0644	edit dl rm
vector	2698	0644	edit dl rm

Edit: /usr/include/c++/4.4.4/cstdatomic (24336B)

// -*- C++ -*- header.

// Copyright (C) 2008, 2009
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// <http://www.gnu.org/licenses/>.

/** @file cstdatomic
 *  This is a Standard C++ Library file.  You should @c #include this file
 *  in your programs, rather than any of the "*.h" implementation files.
 *
 *  This is the C++ version of the Standard C Library header @c stdatomic.h,
 *  and its contents are (mostly) the same as that header, but are all
 *  contained in the namespace @c std (except for names which are defined
 *  as macros in C).
 */

// Based on "C++ Atomic Types and Operations" by Hans Boehm and Lawrence Crowl.
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2427.html

#ifndef _GLIBCXX_STDATOMIC
#define _GLIBCXX_STDATOMIC 1

#pragma GCC system_header

#ifndef __GXX_EXPERIMENTAL_CXX0X__
# include <c++0x_warning.h>
#endif

#include <stdatomic.h>
#include <cstddef>

_GLIBCXX_BEGIN_NAMESPACE(std)

/**
   * @addtogroup atomics
   * @{
   */

/// kill_dependency
  template<typename _Tp>
    inline _Tp 
    kill_dependency(_Tp __y)
    {
      _Tp ret(__y);
      return ret;
    }

inline memory_order
  __calculate_memory_order(memory_order __m)
  {
    const bool __cond1 = __m == memory_order_release;
    const bool __cond2 = __m == memory_order_acq_rel;
    memory_order __mo1(__cond1 ? memory_order_relaxed : __m);
    memory_order __mo2(__cond2 ? memory_order_acquire : __mo1);
    return __mo2;
  }

//
  // Three nested namespaces for atomic implementation details.
  // 
  // The nested namespace inlined into std:: is determined by the value
  // of the _GLIBCXX_ATOMIC_PROPERTY macro and the resulting
  // ATOMIC_*_LOCK_FREE macros. See file stdatomic.h.
  //
  // 0 == __atomic0 == Never lock-free
  // 1 == __atomic1 == Best available, sometimes lock-free
  // 2 == __atomic2 == Always lock-free
#include <bits/atomic_0.h>
#include <bits/atomic_2.h>

/// atomic
  /// 29.4.3, Generic atomic type, primary class template.
  template<typename _Tp>
    struct atomic
    {
    private:
      _Tp _M_i;

public:
      atomic() = default;
      ~atomic() = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;

atomic(_Tp __i) : _M_i(__i) { }

operator _Tp() const volatile;

_Tp 
      operator=(_Tp __i) volatile { store(__i); return __i; }

bool 
      is_lock_free() const volatile;

void 
      store(_Tp, memory_order = memory_order_seq_cst) volatile;

_Tp 
      load(memory_order = memory_order_seq_cst) const volatile;

_Tp 
      exchange(_Tp __i, memory_order = memory_order_seq_cst) volatile;

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

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

bool 
      compare_exchange_weak(_Tp&, _Tp, 
			    memory_order = memory_order_seq_cst) volatile;

bool 
      compare_exchange_strong(_Tp&, _Tp, 
			      memory_order = memory_order_seq_cst) volatile;
    };

/// Partial specialization for pointer types.
  template<typename _Tp> 
    struct atomic<_Tp*> : atomic_address
    {
      atomic() = default;
      ~atomic() = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;

atomic(_Tp* __v) : atomic_address(__v) { }

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

_Tp* 
      load(memory_order = memory_order_seq_cst) const volatile;

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

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

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

bool 
      compare_exchange_weak(_Tp*&, _Tp*, 
			    memory_order = memory_order_seq_cst) volatile;

bool 
      compare_exchange_strong(_Tp*&, _Tp*, 
			      memory_order = memory_order_seq_cst) volatile;

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

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

operator _Tp*() const volatile
      { return load(); }

_Tp* 
      operator=(_Tp* __v) volatile 
      { 
	store(__v); 
	return __v; 
      }

_Tp* 
      operator++(int) volatile { return fetch_add(1); }

_Tp* 
      operator--(int) volatile { return fetch_sub(1); }

_Tp* 
      operator++() volatile { return fetch_add(1) + 1; }

_Tp* 
      operator--() volatile { return fetch_sub(1) - 1; }

_Tp* 
      operator+=(ptrdiff_t __d) volatile 
      { return fetch_add(__d) + __d; }

_Tp* 
      operator-=(ptrdiff_t __d) volatile 
      { return fetch_sub(__d) - __d; }
    };

/// Explicit specialization for void*
  template<> 
    struct atomic<void*> : public atomic_address
    {
      typedef void* 			__integral_type;
      typedef atomic_address 		__base_type;