The following issues were found

src/third_party/mozjs-60/extract/js/src/jit/arm64/AtomicOperations-arm64.h
1 issues
memcpy - Does not check for buffer overflows when copying to destination
Security

Line: 169 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)

Reported by FlawFinder.

src/third_party/boost/boost/log/detail/function_traits.hpp
1 issues
char - Statically-sized arrays can be improperly restricted, leading to potential overflows or other issues
Security

Line: 60 Column: 13 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 FunT, int ArityV = FunT::arity >
        struct checker
        {

Reported by FlawFinder.

src/third_party/boost/boost/system/detail/errc.hpp
1 issues
system - This causes a new program to execute and is difficult to use safely
Security

Line: 19 Column: 11 CWE codes: 78
Suggestion: try using a library call that implements the same functionality if available 

              namespace boost
{

namespace system
{

namespace errc
{

Reported by FlawFinder.

src/third_party/mozjs-60/extract/js/src/jit/arm64/vixl/Globals-vixl.h
1 issues
char - Statically-sized arrays can be improperly restricted, leading to potential overflows or other issues
Security

Line: 86 Column: 11 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 

              // we can switch to a different implemention.
#define VIXL_CONCAT(a, b) a##b
#define VIXL_STATIC_ASSERT_LINE(line, condition) \
  typedef char VIXL_CONCAT(STATIC_ASSERT_LINE_, line)[(condition) ? 1 : -1] \
  __attribute__((unused))
#define VIXL_STATIC_ASSERT(condition) \
    VIXL_STATIC_ASSERT_LINE(__LINE__, condition)

template <typename T1>

Reported by FlawFinder.

src/third_party/mozjs-60/extract/js/src/jit/arm64/vixl/Instrument-vixl.h
1 issues
char - Statically-sized arrays can be improperly restricted, leading to potential overflows or other issues
Security

Line: 69 Column: 3 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 

                CounterType type();

 private:
  char name_[kCounterNameMaxLength];
  uint64_t count_;
  bool enabled_;
  CounterType type_;
};

Reported by FlawFinder.

src/third_party/mozjs-60/extract/js/src/jit/arm64/vixl/Logic-vixl.cpp
1 issues
There is an unknown macro here somewhere. Configuration is required. If NEON_FP3SAME_LIST is a macro then please configure it.
Error

Line: 3900 

                }                                                              \
  return dst;                                                    \
}
NEON_FP3SAME_LIST(DEFINE_NEON_FP_VECTOR_OP)
#undef DEFINE_NEON_FP_VECTOR_OP


LogicVRegister Simulator::fnmul(VectorFormat vform,
                                LogicVRegister dst,

Reported by Cppcheck.

src/third_party/boost/boost/locale/formatting.hpp
1 issues
memcpy - Does not check for buffer overflows when copying to destination
Security

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

                                  // if ptr = 0 it does not matter what is value of size
                    size = sizeof(Char)*(end - s+1);
                    ptr = new char[size];
                    memcpy(ptr,s,size);
                }

                template<typename Char>
                std::basic_string<Char> get() const
                {

Reported by FlawFinder.

src/third_party/mozjs-60/extract/js/src/jit/arm64/vixl/MozInstructions-vixl.cpp
1 issues
memcpy - Does not check for buffer overflows when copying to destination
Security

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

                uint32_t new_mask = (1 << (msb+1)) - (1 << lsb);
  uint32_t keep_mask = ~new_mask;
  me = (me & keep_mask) | ((value << lsb) & new_mask);
  memcpy(this, &me, sizeof(me));
}


} // namespace vixl

Reported by FlawFinder.

src/third_party/mozjs-60/extract/js/src/jit/arm64/vixl/Utils-vixl.h
1 issues
printf - If format strings can be influenced by an attacker, they can be exploited
Security

Line: 40 Column: 25 CWE codes: 134
Suggestion: Use a constant for the format specification 

              // Macros for compile-time format checking.
#if defined(__GNUC__)
#define PRINTF_CHECK(format_index, varargs_index) \
  __attribute__((format(printf, format_index, varargs_index)))
#else
#define PRINTF_CHECK(format_index, varargs_index)
#endif

// Check number width.

Reported by FlawFinder.

src/third_party/mozjs-60/extract/js/src/jit/mips-shared/AtomicOperations-mips-shared.h
1 issues
memcpy - Does not check for buffer overflows when copying to destination
Security

Line: 490 Column: 7 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)
{

Reported by FlawFinder.