The following issues were found

src/third_party/mozjs-60/extract/js/src/jit/x64/CodeGenerator-x64.h
1 issues
access - This usually indicates a security flaw. If an attacker can change anything along the path between the call to access() and the file's actual use (e.g., by moving files), the attacker can exploit the race condition
Security

Line: 29 Column: 50 CWE codes: 362/367!
Suggestion: Set up the correct permissions (e.g., using setuid()) and try to open the file directly 

                  void storeUnboxedValue(const LAllocation* value, MIRType valueType,
                           Operand dest, MIRType slotType);

    void wasmStore(const wasm::MemoryAccessDesc& access, const LAllocation* value, Operand dstAddr);
    template <typename T> void emitWasmLoad(T* ins);
    template <typename T> void emitWasmStore(T* ins);

  public:
    CodeGeneratorX64(MIRGenerator* gen, LIRGraph* graph, MacroAssembler* masm);

Reported by FlawFinder.

src/third_party/mozjs-60/extract/js/src/jit/x86-shared/AssemblerBuffer-x86-shared.cpp
1 issues
char - Statically-sized arrays can be improperly restricted, leading to potential overflows or other issues
Security

Line: 52 Column: 5 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 

              {
    // Buffer to hold the formatted string. Note that this may contain
    // '%' characters, so do not pass it directly to printf functions.
    char buf[200];

    int i = VsprintfLiteral(buf, fmt, va);
    if (i > -1) {
        if (printer)
            printer->printf("%s\n", buf);

Reported by FlawFinder.

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

Line: 254 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.

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

Line: 363 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.

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

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

                  void executableCopy(void* dst)
    {
        const unsigned char* src = m_formatter.buffer();
        memcpy(dst, src, size());
    }
    MOZ_MUST_USE bool appendRawCode(const uint8_t* code, size_t numBytes)
    {
        return m_formatter.append(code, numBytes);
    }

Reported by FlawFinder.

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

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

                  static int compare(const char* lhs, const char* rhs, std::size_t n)
    { return std::strncmp(lhs, rhs, n); }
    static char* copy(char *dest, const char *src, std::size_t n)
    { return static_cast<char*>(std::memcpy(dest, src, n)); }
    static char* move(char *dest, const char *src, std::size_t n)
    { return static_cast<char*>(std::memmove(dest, src, n)); }
    static const char* find(const char* s, std::size_t n, const char& c)
    { return (const char*) (const void*) std::memchr(s, c, n); }
    static char to_char_type(const int& c) { return c; }

Reported by FlawFinder.

src/third_party/mozjs-60/extract/js/src/jit/x86-shared/Lowering-x86-shared.cpp
1 issues
Uninitialized variable: lir
Error

Line: 945 CWE codes: 908 

                      MOZ_CRASH("Unknown SIMD kind when doing a shuffle");
    }

    if (!lir)
        return;

    for (unsigned i = 0; i < ins->numVectors(); i++) {
        MOZ_ASSERT(IsSimdType(ins->vector(i)->type()));
        lir->setOperand(i, useRegister(ins->vector(i)));

Reported by Cppcheck.

src/third_party/boost/boost/iostreams/detail/buffer.hpp
1 issues
read - Check buffer boundaries if used in a loop including recursive loops
Security

Line: 114 Column: 24 CWE codes: 120 20 

                          );
        set(0, keep);
        std::streamsize result = 
            iostreams::read(src, this->data() + keep, this->size() - keep);
        if (result != -1)
            this->set(0, keep + result);
        return result == -1 ?
            traits_type::eof() :
                result == 0 ?

Reported by FlawFinder.

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

Line: 309 Column: 23 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:
  alignas(T) unsigned char result_[sizeof(T)];
  bool has_result_ = false;
};

template <typename Executor>
class awaitable_frame<void, Executor>

Reported by FlawFinder.

src/third_party/boost/boost/io/detail/ostream_guard.hpp
1 issues
setstate - This function is not sufficiently random for security-related functions such as key and nonce creation
Security

Line: 26 Column: 18 CWE codes: 327
Suggestion: Use a more secure technique for acquiring random values 

              
    ~ostream_guard() BOOST_NOEXCEPT_IF(false) {
        if (os_) {
            os_->setstate(std::basic_ostream<Char, Traits>::badbit);
        }
    }

    void release() BOOST_NOEXCEPT {
        os_ = 0;

Reported by FlawFinder.