Line: 346 Column: 18 CWE codes: 126

              #undef LIROP
    };
    const char* name = names[op];
    size_t len = strlen(name);
    for (size_t i = 0; i < len; i++)
        out.printf("%c", tolower(name[i]));
}

void

            

Line: 309 Column: 22 CWE codes: 119 120
Suggestion: Perform bounds checking, use functions that limit length, or ensure that the size is larger than the maximum possible length

                             , l_data, l_merged, l_block, use_internal_buf, common_xbuf, xbuf, comp, is_merge_left);
         }
         else{
            unsigned char uint_keys[256];
            adaptive_sort_combine_blocks
               ( uint_keys, less(), !use_internal_buf || is_merge_left ? first : first-l_block
               , l_data, l_merged, l_block, use_internal_buf, common_xbuf, xbuf, comp, is_merge_left);
            }
      }

            

Line: 70 Column: 17 CWE codes: 119 120
Suggestion: Perform bounds checking, use functions that limit length, or ensure that the size is larger than the maximum possible length

              };

typedef char yes_type;            
struct no_type{ char dummy[2]; }; 

template<typename T>
no_type is_private_type(T const &);

yes_type is_private_type(private_type const &);

            

Line: 40 Column: 16 CWE codes: 119 120
Suggestion: Perform bounds checking, use functions that limit length, or ensure that the size is larger than the maximum possible length

              {                                                                       \
private:                                                                \
   using yes = char;                                                    \
   struct no { char x[2]; };                                            \
                                                                        \
   template <typename U>                                                \
   static yes test(typename U::name* = nullptr);                        \
                                                                        \
   template <typename U>                                                \

            

Line: 238 Column: 5 CWE codes: 120
Suggestion: Make sure destination can always hold the source data

              {
    MOZ_ASSERT(!((char*)dest <= (char*)src && (char*)src < (char*)dest+nbytes));
    MOZ_ASSERT(!((char*)src <= (char*)dest && (char*)dest < (char*)src+nbytes));
    memcpy(dest, src, nbytes);
}

inline void
js::jit::AtomicOperations::memmoveSafeWhenRacy(void* dest, const void* src, size_t nbytes)
{

            

Line: 68 Column: 22 CWE codes: 119 120
Suggestion: Perform bounds checking, use functions that limit length, or ensure that the size is larger than the maximum possible length

              {
private:
    typedef char yes_type;
    struct no_type { char dummy[2]; };

    template< typename U >
    static yes_type check_spirit_classic_parser(spirit::classic::parser< U > const&);
    static no_type check_spirit_classic_parser(...);
    static T& get_T();

            

Line: 35 Column: 11 CWE codes: 134
Suggestion: Use a constant format string for syslog

              
namespace sinks {

namespace syslog {

    //! Syslog record levels
    enum level
    {
        emergency = 0,                //!< Equivalent to LOG_EMERG in syslog API

            

Line: 115 Column: 34 CWE codes: 134
Suggestion: Make format string constant

                          val = static_cast< uint32_t >(c);
        }

        int n = boost::log::aux::swprintf(buf, N, format, val);
        if (n < 0)
        {
            n = 0;
            buf[0] = L'\0';
        }

            

Line: 34 Column: 5 CWE codes: 120
Suggestion: Make sure destination can always hold the source data

              
    uint64_t imm = high16 << 48;
    double d;
    memcpy(&d, &imm, 8);
    return d;
}


// These register names are defined in a way to match the native disassembler

            

Line: 30 Column: 8

                  cdefgh = value & 0x3f
    return (a << 31) | (B << 30) | (rep(b, 8) << 22) | cdefgh << 16

print '/* THIS FILE IS AUTOMATICALLY GENERATED BY gen-double-encode-table.py.  */'
for i in range(256):
    print '  { 0x%08x, { %d, %d, 0 } },' % (encodeDouble(i), i & 0xf, i >> 4)