SpiderMonkey é o mecanismo JavaScript e WebAssembly da Mozilla, escrito em C++ e Rust. No BLFS, o código-fonte do SpiderMonkey é retirado do Firefox.
Esse pacote é conhecido por construir e funcionar corretamente usando uma plataforma LFS 12.4.
Transferência (HTTP): https://archive.mozilla.org/pub/firefox/releases/140.2.0esr/source/firefox-140.2.0esr.source.tar.xz
Soma de verificação MD5 da transferência: 64773387a541a2ed5c1ce9f247469ba3
Tamanho da transferência: 602 MB
Espaço em disco estimado exigido: 4,7 GB (48 MB instalado depois de remover 38 MB de bibliotecas estáticas; adicionar 30 MB para os testes principais e 27 MB para os testes jit)
Tempo de construção estimado: 1,8 UPC (com paralelismo=4; adicionar 0,5 UPC para os testes principais e 2,1 UPC para os testes jit)
Cbindgen-0.29.0, ICU-77.1, Which-2.23
LLVM-20.1.8 (com Clang, exigido para sistemas de 32 bits sem recursos de SSE2)
          
            Se você estiver construindo esse pacote em um sistema de 32 bits
            e o Clang não estiver instalado ou você estiver substituindo a
            opção padrão do compilador com a variável de ambiente
            CXX, por favor, leia primeiro a seção
            Explicações do Comando.
          
          
            Ao contrário da maioria dos outros pacotes no BLFS, as instruções
            abaixo exigem que você desempacote firefox-140.2.0esr.tar.xz e mude para o
            diretório firefox-140.2.0.
          
            Extrair o tarball reconfigurará as permissões do diretório atual
            para 0755, se você tiver permissão para fazer isso. Se você fizer
            isso em um diretório onde o bit sticky estiver configurado, como
            /tmp, ela terminará com mensagens
            de erro:
          
              tar: .: Cannot utime: Operation not permitted
              tar: .: Cannot change mode to rwxr-xr-t: Operation not permitted
              tar: Exiting with failure status due to previous errors
            
            Isso finaliza com situação diferente de zero, mas NÃO significa que existe um problema
            real. Não desempacote como o(a) usuário(a) root em um diretório onde o bit sticky
            estiver configurado - isso irá desconfigurá-lo.
          
Instale SpiderMonkey executando os seguintes comandos:
          
            Se você estiver compilando esse pacote em chroot, você precisa
            assegurar que /dev/shm esteja
            montado. Se você não fizer isso, a configuração do Python falhará com um informe de
            rastreamento reverso referenciando /usr/lib/pythonN.N/multiprocessing/synchronize.py.
            Como o(a) usuário(a) root,
            execute:
          
mountpoint -q /dev/shm || mount -t tmpfs devshm /dev/shm
Compilar o código C++ respeita $MAKEFLAGS e o padrão é 'j1'; o código do rust usará todos os processadores.
mkdir obj &&
cd    obj &&
../js/src/configure --prefix=/usr            \
                    --disable-debug-symbols  \
                    --disable-jemalloc       \
                    --enable-readline        \
                    --enable-rust-simd       \
                    --with-intl-api          \
                    --with-system-icu        \
                    --with-system-zlib       &&
make
        Para executar a suíte de teste SpiderMonkey, emita:
make -C js/src check-jstests \
     JSTESTS_EXTRA_ARGS="--timeout 300 --wpt=disabled" | tee jstest.log
        
          Como nós estamos construindo com o ICU do sistema, 24 testes (de um
          total de mais de 50.000) são conhecidos por falharem. A lista de
          testes falhos pode ser extraída via grep 'UNEXPECTED-FAIL'
          jstest.log. Passe a opção -c para grep se você quiser somente o
          número total de testes falhos.
        
A suíte de teste é executada com todos os núcleos de CPU disponíveis: mesmo em um cgroup com menos núcleos atribuídos, ela ainda tenta gerar tantas tarefas de teste quanto o número de todos os núcleos no sistema; felizmente, o núcleo ainda não executará essas tarefas em núcleos não atribuídos ao cgroup, de forma que o uso da CPU ainda é controlado.
Para executar a suíte de teste JIT, emita o seguinte comando:
make -C js/src check-jit-test
          Assim como a suíte de teste do SpiderMonkey, o número de tarefas de
          teste é o mesmo que o número de todos os núcleos de CPU no sistema,
          mesmo se um cgroup for usado. Para piorar as coisas, alguns casos
          de teste podem usar até 4 GB de memória do sistema, de forma que o
          pico de uso de memória possivelmente seja muito grande se tua CPU
          tiver vários núcleos. Executar a suíte de teste JIT sem memória
          suficiente possivelmente invoque o OOM killer do núcleo e cause
          problemas de estabilidade. Se você não tiver memória de sistema
          suficiente disponível, posponha JITTEST_EXTRA_ARGS=-j ao comando e substitua
          NN pelo número de tarefas
          de teste que tua memória de sistema disponível consiga conter. Por
          exemplo, se você tiver 15 GB de memória de sistema disponível e 4
          núcleos de CPU, posponha JITTEST_EXTRA_ARGS=-j3 para executar a suíte de
          teste com 3 tarefas paralelas de forma que o uso de memória não
          exceda 12 GB.
        
          Um problema no processo de instalação faz com que qualquer programa em execução que se vincule à biblioteca compartilhada do SpiderMonkey (por exemplo, GNOME Shell) trave se o SpiderMonkey for reinstalado, atualizado ou rebaixado sem uma mudança do número da versão principal (140 em 140.2.0). Para contornar esse problema, remova a versão antiga da biblioteca compartilhada do SpiderMonkey antes da instalação:
rm -fv /usr/lib/libmozjs-140.so
          Agora, como o(a) usuário(a) root:
        
make install && rm -v /usr/lib/libjs_static.ajs && sed -i '/@NSPR_CFLAGS@/d' /usr/bin/js140-config
          Ainda como o(a) usuário(a) root,
          corrija um problema com um dos cabeçalhos instalados:
        
sed '$i#define XP_UNIX' -i /usr/include/mozjs-140/js-config.h
          --disable-debug-symbols:
          Não gere símbolos de depuração, pois eles são muito grandes e a
          maioria dos(as) usuários(as) não precisará deles. Remova-o se você
          quiser depurar o SpiderMonkey.
        
          --disable-jemalloc: Essa
          chave desabilita o alocador de memória interna usado no
          SpiderMonkey. jemalloc destina-se somente para o ambiente do
          navegador Firefox. Para outros aplicativos que usam o SpiderMonkey,
          o aplicativo pode travar à medida que os itens alocados no alocador
          jemalloc forem liberados no alocador do sistema (glibc).
        
          --enable-readline: Essa
          chave habilita suporte Readline na interface de linha de comando do
          SpiderMonkey.
        
          --enable-rust-simd: Essa
          chave habilita otimização do SIMD na caixa encoding_rs enviada.
        
          --with-intl-api: Isso
          habilita as funções de internacionalização exigidas pelo
          Gjs.
        
          --with-system-*: Esses
          parâmetros permitem que o sistema de construção use versões de
          sistema das bibliotecas acima. Eles são necessários para
          estabilidade.
        
rm -v /usr/lib/libjs_static.ajs: Remove uma grande biblioteca estática que não é usada por nenhum pacote do BLFS.
sed -i '/@NSPR_CFLAGS@/d' /usr/bin/js140-config: Impede que js140-config use CFLAGS defeituosas.
          : O BLFS costumava preferir usar gcc e g++ em
          vez dos padrões do fluxo de desenvolvimento dos programas
          clang. Com o lançamento do gcc-12
          a construção demora mais tempo com gcc e g++, principalmente por
          causa de avisos extras, e é maior. Passe essas variáveis de
          ambiente para o conjunto de comandos sequenciais de configuração se
          você desejar continuar a usar gcc, g++ (exportando-as e
          desconfigurando-as depois da instalação ou simplesmente
          acrescentando-as antes do comando ../js/src/configure). Se você
          estiver construindo em um sistema de 32 bits, veja também abaixo.
        CC=gcc
          CXX=g++
          : Use SSE2 em vez de 387 para operações
          de ponto flutuante de precisão dupla. É necessário ao GCC para
          satisfazer as expectativas dos(as) desenvolvedores(as) do fluxo de
          desenvolvimento (Mozilla) com aritmética de ponto flutuante. Use-o
          se você estiver construindo esse pacote em um sistema de 32 bits
          com GCC (se o Clang não estiver instalado ou o GCC for especificado
          explicitamente). Observe que isso fará com que o SpiderMonkey trave
          em um processador sem capacidade SSE2. Se você estiver executando o
          sistema em um processador tão antigo, o Clang será estritamente
          necessário. Essa configuração não é necessária em sistemas de 64
          bits porque todos os processadores x86 de 64 bits suportam SSE2 e
          os compiladores de 64 bits (ambos, Clang e GCC) usam SSE2 por
          padrão.
        CXXFLAGS="-msse2
          -mfpmath=sse"