Programação em Baixo Nível: C, Assembly e execução de programas na arquitetura Intel 64

Conheça a linguagem Assembly e a arquitetura do Intel 64, torne-se proficiente em C e entenda como os programas são compilados e executados até o nível das instruções de máquina, permitindo-lhe escrever um código robusto e de alto desempenho.

Por: R$ 95,00

Preço a vista: R$ 95,00

+-
Comprar
Opções de Parcelamento:
  • à vista R$ 95,00
Outras formas de pagamento

Quem viu este produto , comprou

  • Visual Studio C# Fundamentos, Programação com ASP.Net, Windows Forms e Web Services

    A linguagem de programação C# é de simples aprendizado e utilização, porém extremamente poderosa e com inúmeros recursos. Aliada ao ambiente de desenvolvimento, Microsoft Visual Studio, oferece uma plataforma eficiente e de grande produtividade no desenvolvimento dos mais diversos tipos de aplicações. ... Ler mais +

    QUERO VER
  • C: Manual de Referência

    Este manual de referência definitivo, best-seller na sua edição em inglês, oferece uma descrição completa da linguagem C, as bibliotecas de tempo de execução e um estilo de programação C que enfatiza a correção, a portabilidade e a manutenção. C: manual de referência é um livro único que descreve todos os detalhes de C - antigos e atuais - com a maior clareza para o leitor. É uma referência indispensável a todos os programadores e implementadores de C. ... Ler mais +

    QUERO VER
  • Começando a Programar em C++ Para Leigos

    Programe com facilidade (e diversão!) com este guia sobre a famosa linguagem C++ Então, você sonha com a excitante vida de um programador? Com este livro, você poderá fazer isso acontecer! Ainda que mal saiba o que é programação, é possível aprender a “falar” a linguagem C++. Instale e use o compilador, trabalhe com loops, entenda objetos e classes, livre-se de bugs e escreva programas reais, que funcionam. Está tudo nestas páginas! ... Ler mais +

    QUERO VER
  • Use a Cabeça! C# - 2ª Edição

    O Use a Cabeça! C# – 2ª Edição é uma experiência completa de aprendizagem para a programação com C#, .NET Framework e IDE Visual Studio. Construído para ser assimilado rapidamente pela sua mente, este livro cobre o C# & .NET 4.0 e o Visual Studio 2010, e ensina tudo, desde a herança até a serialização. Você consultará seus dados com o LINQ, desenhará gráficos e animação e aprenderá as classes e a programação orientada a objetos, tudo através do desenvolvimento de jogos, fazendo projetos práticos e resolvendo quebra-cabeças. Você será um programador C# sólido e terá muita diversão no caminho ... Ler mais +

    QUERO VER
  • Programando em C: Fundamentos - Inclui o padrão ISO C99 - Volume 1

    A linguagem C é antiga, mas ainda é uma das linguagens de programação mais populares. Além de ser uma excelente linguagem para programação de baixo nível e de sistemas, C tem servido como base para a maioria das linguagens populares em uso corrente: C++, Java, PHP, C# e outras. Além disso, programas bem escritos em C têm desempenhos comparáveis apenas aos equivalentes escritos em assembly. Este livro apresenta todas as novidades introduzidas pelo padrão ISO/IEC 9899:1999 (C99), incluindo a última correção técnica, publicada em 2004. ... Ler mais +

    QUERO VER
  • Curso de Programação em Linguagem C

    Este livro foi formatado para simplificar o aprendizado de programação em computadores, ao exprimir uma linguagem menos formal em comparação à literatura tradicional e ao explorar a programação com um encadeamento de ensino diferente do habitual. Tradicionalmente, as estruturas de dados e de controle de uma linguagem de programação são ensinadas ao estudante para ele começar a escrever cada um de seus programas como uma única unidade de processamento de informações. Somente após esta forma de programar tornar-se habitual, é apresentada a ele a técnica de divisão de um programa em subprogramas, a qual é extremamente interessante e eficaz. ... Ler mais +

    QUERO VER
  • Migrando de C para C++ Guia Prático de Programação

    O objetivo deste livro é traduzir a complexidade associada aos conceitos presentes em C++ em termos familiares ao programador, de forma que ele possa colocar em uso efetivo todos os recursos desta linguagem. Enfatizando o aspecto prático, nada menos que 141 programas de exemplo completos e diversos trechos de código são utilizados para clarificar a exposição teórica. O livro trata não só da programação orientada a objetos, o conceito mais comumente associado a C++, mas também inclui uma abrangente cobertura da STL, Standard Template Library. A apresentação de outros recursos da linguagem, tais como a biblioteca de E/S de dados, manipulação numérica com valarrays, ponteiros inteligentes, tratamento de exceções, funções inline, funções template etc, não poderia estar ausente num livro sobre C++.... ... Ler mais +

    QUERO VER
  • Programação em Linguagem C

    A linguagem C é muito utilizada na área de programação. O livro Programação em linguagem C oferece mais de 200 códigos-fontes, distribuídos entre exemplos e exercícios de fixação. ... Ler mais +

    QUERO VER
  • Estrutura de Dados e Algoritmos Usando C - Fundamentos e Aplicações

    O objetivo deste livro é apresentar as estruturas de dados mais utilizadas na computação, a partir de uma abordagem prática, implementando as operações primitivas de cada estrutura, bem como suas aplicações na computação. Ele dá ênfase ao ensino prático da programação de computadores, e aborda listas, pilhas, filas, recursividade, árvores, grafos e pesquisa de dados. Utilizamos a linguagem C para a solução e implementação dos algoritmos necessários à solução dos problemas apresentados, e por ela ser de fácil aprendizado. O livro procura atender às demandas de cursos de graduação nas mais diversas áreas técnico-científicas como Engenharia da Computação e Ciência da Computação, Análise de Sistemas, Sistemas de Informações e cursos avançados de programação de computadores. Os pré-requisitos para estudar este livro são conhecimentos básicos em linguagem C e lógica de programação. Apresentamos algumas soluções em forma de pseudocódigo e em seguida a solução em linguagem C. ... Ler mais +

    QUERO VER

Quem viu este produto , também se interessou

  • Ciência da Computação - Uma Visão Abrangente - 11ª Edição

    VITRINE Os Livros mais Vendidos !

    Conhecido por oferecer uma cobertura ampla e uma clara exposição do vasto e dinâmico campo da ciência da computação, o livro mais conhecido da área chega à décima primeira edição atualizado e ampliado para incluir as tecnologias mais atuais ... Ler mais +

    QUERO VER
  • Blockchain Básico: Uma introdução não técnica em 25 passos

    Em 25 passos concisos, você conhecerá o básico sobre a tecnologia do blockchain. Nenhuma fórmula matemática, código de programa ou jargão de ciência da computação será usado. Não são necessários conhecimentos prévios sobre ciência da computação, matemática, programação ou criptografia, pois a terminologia é explicada por meio de figuras, analogias e metáforas. ... Ler mais +

    QUERO VER
  • Carregador Portátil 2 Portas USB 12000mAh Prata - Maxprint 6012182

    Acabamento Sofisticado e Design Elegante com superfície texturizada em alumínio. Alta Capacidade de Carregamento, até 3 cargas completas. Também carrega 2 dispositivos simultaneamente. ... Ler mais +

    QUERO VER
  • Construindo uma Aplicação Web Completa com PHP e MySQL

    Este livro oferece ao leitor o conhecimento necessário para desenvolver aplicações para a internet utilizando o servidor web Apache, o servidor de banco de dados MySQL e a linguagem PHP. Com uma linguagem simples e objetiva e capítulos repletos de figuras e exercícios, a obra proporciona fácil entendimento acerca dos fundamentos de gestão de projeto, dos conceitos de HTML e do processo de instalação do Apache, MySQL e PHP no ambiente Windows. Você será capaz de desenvolver um projeto de aplicação para uma rede de hotéis, da concepção à implantação. ... Ler mais +

    QUERO VER
  • INDISPONÍVEL Data Smart - Usando Data Science para transformar informação em insight

    Não quero te desiludir, mas os cientistas de dados não são feiticeiros místicos usuários da arte da magia. Data science é algo que você pode fazer. De verdade. Este livro mostra técnicas significativas, como elas funcionam, como usá-las, e como elas trazem benefícios para o seu negócio, seja ele pequeno ou grande. Não é apenas trabalhar com códigos ou tecnologias de base de dados. É transformar seus dados brutos em insight para que você possa operá-los da forma mais rápida e prática possível. Erga as mangas e vamos lá. ... Ler mais +

    QUERO VER
  • TDD com Python - Siga o bode dos testes: usando Django, Selenium e JavaScript

    Ao conduzir você pelo desenvolvimento de uma verdadeira aplicação web do início ao fim, a segunda edição deste guia “mão na massa” mostra as vantagens práticas do TDD (Test-Driven Development, ou Desenvolvimento Orientado a Testes) com Python. Você aprenderá a escrever e a executar testes antes de construir cada parte de sua aplicação, e então desenvolverá a quantidade mínima de código necessária para que os testes passem. O resultado? Um código limpo, que funcionará. ... Ler mais +

    QUERO VER
  • Criando projetos com Arduino para a Internet das Coisas - Experimentos com aplicações do mundo real

    Criando projetos com Arduino para a Internet das Coisas: experimentos com aplicações do mundo real é exatamente o que você precisa. Escrito por um desenvolvedor de software e arquiteto de soluções que cansou de procurar e reunir várias lições sobre desenvolvimento com Arduino enquanto aprendia por conta própria tudo sobre o assunto, este livro fornece uma base incrivelmente sólida de desenvolvimento de dispositivos baseados em Arduino, a partir da qual você pode seguir em qualquer direção de acordo com suas necessidades e desejos específicos de desenvolvimento. ... Ler mais +

    QUERO VER
  • Manual de projetos do Arduino - 25 projetos práticos para começar

    O Manual de projetos do Arduino é uma coleção de projetos de eletrônica para iniciantes que usam a placa de baixo custo Arduino. Com apenas alguns componentes, um Arduino e um computador, você aprenderá a construir e programar desde espetáculos de luzes e jogos clássicos de fliperama até um sistema ultrassônico de segurança. ... Ler mais +

    QUERO VER
  • Introdução à linguagem Lua

    Este livro apresenta a linguagem Lua de maneira básica e introdutória para leitores e estudantes de programação que não possuem conhecimentos prévios da linguagem. ... Ler mais +

    QUERO VER
  • CSS Grid Layout: Criando layouts CSS profissionais

    A criação de Layout CSS sempre foi uma tarefa trabalhosa, mas agora os profissionais têm uma ferramenta poderosa ao seu alcance, o CSS Grid Layout, uma nova especificação do W3C, que veio para resolver praticamente todos os problemas de posicionamento na tela. Utilizando um novo método de layout CSS, bidimensional, com linhas e colunas, mais simples e muito mais fácil de usar, permite controlar o tamanho e a posição dos componentes da interface e seus conteúdos. Não será mais necessário inflar a marcação HTML com elementos desnecessários para a criação de layouts CSS. ... Ler mais +

    QUERO VER
  • *ESGOTADO*Manual de DevOps: Como obter agilidade, confiabilidade e segurança em organizações tecnológicas

    A convergência de vários movimentos importantes em gestão e tecnologia prepararam o terreno para o movimento DevOps, que resulta da aplicação dos princípios mais confiáveis da manufatura física e da liderança no fluxo de valor de TI. Em Manual de Devops você verá que as organizações que adotam os princípios e práticas Lean melhoram significativamente a produtividade da fábrica, os tempos de execução para o cliente, a qualidade do produto e a satisfação do cliente, permitindo que vençam no mercado. Entenda melhor o potencial da revolução DevOps e como as organizações de alto desempenho ampliam as chances de exceder metas de lucratividade, participação de mercado e produtividade. ... Ler mais +

    QUERO VER
  • Limpa Tela + Flanela especial Microfibra - Reliza

    Todos

    Kit de limpeza especializado para todos os tipos de telas.Usado em telas de televisores , monitora , notebooks , Tablet , celulares e smartphones , lentes de óculos e de capacetes , vidros , acrílicos e superfícies similares . ... Ler mais +

    QUERO VER
  • Internet das Coisas com ESP8266, Arduino e Raspberry Pi

    A Internet das Coisas (Internet of Things - IoT), está se tornando realidade. Os módulos de hardware para implementar IoT já estão disponíveis a um custo factível para aplicação. Um microcontrolador, em particular, o ESP8266, virou uma opção extremamente interessante devido a seu custo muito reduzido e aos seus recursos, suficientes para diversas aplicações de IoT. ... Ler mais +

    QUERO VER
  • Avaliação de segurança de redes

    Qual é o nível de segurança de sua rede? A melhor maneira de descobrir é atacá-la usando as mesmas táticas que os invasores empregam, de modo a identificar e explorar seus pontos fracos. ... Ler mais +

    QUERO VER
  • Carregador de Viagem Ultra Rápido para Tablets e Smartphones - Samsung EP-TA20BWBUGBR

    O carregador de viagens EP-TA20 da Samsung possui a função Carregamento Rápido, que carrega seu Smartphone em muito menos tempo que um carregador comum! Ideal para quem está sempre em movimento e não tem muito tempo para esperar o celular recarregar. Esta função é compatível apenas com os modelos de Smartphones e Tablets premium, mas com os outros portáteis ele funciona como um carregador comum. ... Ler mais +

    QUERO VER
  • Como usar uma protoboard

    Uma protoboard é uma base plástica usada para construir circuitos. Os furos na parte superior da protoboard dão acesso a grampos nas faixas metálicas que conduzem a corrente elétrica. Ao inserir fios e componentes eletrônicos nos furos, é possível construir uma variedade infinita de circuitos. E, uma vez que a protoboard não usa solda, você pode, com facilidade, mover os componentes ou mesmo desfazer completamente o circuito e reutilizar sua protoboard para construir um novo circuito. ... Ler mais +

    QUERO VER
  • White Hat Linux: Análise de vulnerabilidades e técnicas de defesas com software livre

    Sabemos que a informação gera conhecimento e nesse sentido devemos proteger as informações de ataques de pessoas mal intencionadas. Empresas e órgãos governamentais sofrem ataques diariamente e cada vez mais se torna necessário que tenham profissionais qualificados para a proteção das informações. Mas como proteger, se nem sei como o ataque funciona? O livro traz tudo o que você precisa saber para iniciar seus estudos na área de segurança da informação de forma simples e didática. ... Ler mais +

    QUERO VER
  • Data Science para Programadores - Um Guia Completo Utilizando a Linguagem Python

    Um guia para estudantes e profissionais, utilizando a linguagem Python em todo o seu potencial. Você aprenderá os conceitos e fundamentos estatísticos que auxiliarão seu trabalho analítico. As bibliotecas são apresentadas de maneira prática, focando no que é mais importante para o seu trabalho do dia a dia. O livro apresenta um ferramental completo para você iniciar neste mercado lucrativo que a Data Science possibilita. ... Ler mais +

    QUERO VER
  • Exploração de Vulnerabilidades em Redes TCP/IP - 3ª Edição Revisada e Ampliada

    O livro Exploração de Vulnerabilidades em Redes TCP/IP foi idealizado com o objetivo de ser uma contribuição na formação de profissionais de segurança computacional dos novos tempos. Em um passado remoto, era comum instalar um servidor e simplesmente esquecer dele, já que o acesso era exclusivo à LAN da corporação. Com o advento da internet, tudo mudou: uma vez na internet, um servidor está ao alcance do mundo. ... Ler mais +

    QUERO VER
  • Descrição
    Programação em Baixo Nível: C, Assembly e execução de programas na arquitetura Intel 64

    Conheça a linguagem Assembly e a arquitetura do Intel 64, torne-se proficiente em C e entenda como os programas são compilados e executados até o nível das instruções de máquina, permitindo-lhe escrever um código robusto e de alto desempenho.

    Programação em baixo nível explica a arquitetura do Intel 64 como resultado da evolução da arquitetura de von Neumann. O livro o ensina a usar a versão mais recente da linguagem C (C11) e a linguagem Assembly desde o básico. Todo o caminho, do código-fonte à execução do programa, incluindo a geração de arquivos-objeto ELF, além das ligações estática e dinâmica, será discutido. Há exemplos de código e exercícios, junto com as melhores práticas de programação. Os recursos de otimização e os limites dos compiladores modernos serão analisados, permitindo-lhe promover um equilíbrio entre a legibilidade do programa e o desempenho.

    O uso de diversas técnicas para ganho de desempenho, por exemplo, instruções SSE e pre-fetching, será demonstrado. Assuntos relevantes em ciência da computação, como os modelos de computação e as gramáticas formais, também serão tratados, explicando-se sua importância prática.

    Programação em baixo nível ensina os programadores a:

    escrever livremente em linguagem Assembly;
    compreender o modelo de programação do Intel 64;
    escrever um código robusto e fácil de manter em C11;
    acompanhar o processo de compilação e decifrar as listagens em Assembly;
    depurar erros em código Assembly compilado;
    usar modelos de computação apropriados para reduzir drasticamente a complexidade dos programas;
    escrever códigos críticos quanto ao desempenho;
    compreender o impacto de um modelo de memória fraco em aplicações com várias threads.
  • Sobre o Autor
  • Especificação

    Características

    Tipo de LivroLivro Físico

    Especificações

    Sobre o AutorIgor Zhirkov

    Igor Zhirkov ministra seu muito bem-sucedido curso “Linguagens de programação de sistemas” na ITMO University (Universidade de Tecnologia da Informação, Mecânica e Ótica) de São Petersburgo, seis vezes vencedora do ACM-ICPC Intercollegiate World Programming Championship (Campeonato Mundial de Programação entre Universidades ACM-ICPC). Estudou na Saint Petersburg Academic University (Universidade Acadêmica de São Petersburgo) e recebeu seu título de mestrado da ITMO University. Atualmente faz pesquisas em refatorações comprovadas em C como parte de sua tese de doutorado e na formalização de uma biblioteca de Bulk Synchronous Parallelism em C no IMT Atlantique, em Nantes, na França. Seus principais interesses são: programação em baixo nível, teoria de linguagens de programação e teoria de tipos.
    Informações TécnicasSumário
    Sobre o autor .........................................................................................................................15
    Sobre o revisor técnico............................................................................................................16
    Agradecimentos.....................................................................................................................17
    Introdução.............................................................................................................................19

    Parte I • Linguagem Assembly e arquitetura de computadores..................... 23

    Capítulo 1 • Básico sobre arquitetura de computadores...........................................................24
    1.1 Arquitetura do núcleo ................................................................................................ 24
    1.1.1 Modelo de computação ....................................................................................... 24
    1.1.2 Arquitetura de von Neumann..............................................................................25
    1.2 Evolução.................................................................................................................... 27
    1.2.1 Desvantagens da arquitetura de von Neumann.................................................... 27
    1.2.2 Arquitetura Intel 64............................................................................................28
    1.2.3 Extensões da arquitetura ....................................................................................29
    1.3 Registradores............................................................................................................. 31
    1.3.1 Registradores de propósito geral..........................................................................33
    1.3.2 Outros registradores........................................................................................... 37
    1.3.3 Registradores de sistema .....................................................................................38
    1.4 Anéis de proteção.......................................................................................................39
    1.5 Pilha de hardware ......................................................................................................40
    1.6 Resumo ..................................................................................................................... 42

    Capítulo 2 • Linguagem Assembly ..........................................................................................44
    2.1 Configurando o ambiente...........................................................................................44
    2.1.1 Trabalhando com os códigos de exemplo.............................................................45
    2.2 Escrevendo “Hello, world”.........................................................................................45
    2.2.1 Entrada e saída básicas.......................................................................................45
    2.2.2 Estrutura do programa ....................................................................................... 47
    6 Programação em Baixo Nível
    2.2.3 Instruções básicas ..............................................................................................49
    2.3 Exemplo: exibindo o conteúdo de registradores.......................................................... 51
    2.3.1 Rótulos locais.....................................................................................................53
    2.3.2 Endereçamento relativo ......................................................................................54
    2.3.3 Ordem de execução ............................................................................................55
    2.4 Chamadas de função..................................................................................................56
    2.5 Trabalhando com dados.............................................................................................60
    2.5.1 Endianness.........................................................................................................60
    2.5.2 Strings................................................................................................................63
    2.5.3 Pré-processamento de constantes........................................................................63
    2.5.4 Ponteiros e diferentes tipos de endereçamento .....................................................63
    2.6 Exemplo: calculando o tamanho de uma string ..........................................................65
    2.7 Exercício: biblioteca de entrada/saída .........................................................................68
    2.7.1 Autoavaliação ..................................................................................................... 70
    2.8 Resumo .....................................................................................................................71

    Capítulo 3 • Legado................................................................................................................74
    3.1 Modo real .................................................................................................................. 74
    3.2 Modo protegido......................................................................................................... 76
    3.3 Segmentação mínima em modo longo......................................................................... 81
    3.4 Acessando partes de registradores ..............................................................................83
    3.4.1 Um comportamento inesperado ..........................................................................83
    3.4.2 CISC e RISC.......................................................................................................83
    3.4.3 Explicação..........................................................................................................85
    3.5 Resumo .....................................................................................................................85

    Capítulo 4 • Memória virtual ..................................................................................................86
    4.1 Caching .....................................................................................................................86
    4.2 Motivação..................................................................................................................87
    4.3 Espaços de endereçamento.........................................................................................88
    4.4 Recursos....................................................................................................................89
    4.5 Exemplo: acessando um endereço proibido................................................................. 91
    4.6 Eficiência...................................................................................................................93
    4.7 Implementação ..........................................................................................................94
    4.7.1 Estrutura dos endereços virtuais..........................................................................94
    4.7.2 Tradução de endereços em detalhes.....................................................................95
    4.7.3 Tamanhos de página ...........................................................................................98
    4.8 Mapeamento de memória...........................................................................................99
    4.9 Exemplo: mapeando um arquivo na memória ........................................................... 100
    4.9.1 Nomes mnemônicos para constantes................................................................. 100
    4.9.2 Exemplo completo ............................................................................................ 102
    4.10 Resumo.................................................................................................................. 104

    Capítulo 5 • Pipeline de compilação......................................................................................106
    5.1 Pré-processador........................................................................................................ 107
    5.1.1 Substituições simples ........................................................................................ 107
    5.1.2 Substituições com argumentos.......................................................................... 109
    5.1.3 Substituição condicional simples....................................................................... 110
    5.1.4 Condicionais sobre a definição .......................................................................... 111
    5.1.5 Condicionais sobre a identidade de textos ......................................................... 112
    5.1.6 Condicionais sobre o tipo de argumento............................................................ 113
    5.1.7 Ordem de avaliação: define, xdefine, assign ....................................................... 114
    5.1.8 Repetição.......................................................................................................... 116
    5.1.9 Exemplo: calculando números primos............................................................... 117
    5.1.10 Rótulos em macros.......................................................................................... 119
    5.1.11 Conclusão....................................................................................................... 120
    5.2 Tradução ................................................................................................................. 120
    5.3 Ligação.................................................................................................................... 121
    5.3.1 ELF (Executable and Linkable Format) ............................................................. 121
    5.3.2 Arquivos-objeto relocáveis................................................................................125
    5.3.3 Arquivos-objeto executáveis.............................................................................. 130
    5.3.4 Bibliotecas dinâmicas........................................................................................ 131
    5.3.5 Loader.............................................................................................................. 137
    5.4 Exercício: dicionário................................................................................................. 139
    5.5 Resumo ................................................................................................................... 142

    Capítulo 6 • Interrupções e chamadas de sistema..................................................................144
    6.1 Entrada e saída ........................................................................................................ 144
    6.1.1 O registrador TR e o Task State Segment ........................................................... 146
    6.2 Interrupções............................................................................................................ 147
    6.3 Chamadas de sistema............................................................................................... 152
    6.3.1 Registradores específicos de modelo.................................................................. 153
    6.3.2 syscall e sysret .................................................................................................. 153
    6.4 Resumo ................................................................................................................... 155

    Capítulo 7 • Modelos de computação ....................................................................................157
    7.1 Máquinas de estado finitas ....................................................................................... 157
    7.1.1 Definição .......................................................................................................... 157
    7.1.2 Exemplo: paridade de bits ................................................................................. 159
    7.1.3 Implementação em linguagem Assembly............................................................ 160
    7.1.4 Importância prática ........................................................................................... 163
    7.1.5 Expressões regulares......................................................................................... 164
    7.2 Máquina de Forth .................................................................................................... 168
    7.2.1 Arquitetura....................................................................................................... 169
    7.2.2 Trace de um exemplo de programa em Forth ..................................................... 171
    8 Programação em Baixo Nível
    7.2.3 Dicionário ........................................................................................................ 172
    7.2.4 Como as palavras são implementadas................................................................ 172
    7.2.5 Compilador ...................................................................................................... 178
    7.3 Exercício: compilador e interpretador de Forth.......................................................... 179
    7.3.1 Dicionário estático e interpretador..................................................................... 180
    7.3.2 Compilação ...................................................................................................... 184
    7.3.3 Forth com bootstrap ......................................................................................... 185
    7.4 Resumo.................................................................................................................... 188

    Parte II • A linguagem de programação C....................................................190

    Capítulo 8 • Básico da linguagem C.......................................................................................191
    8.1 Introdução............................................................................................................... 192
    8.2 Estrutura do programa............................................................................................. 193
    8.2.1 Tipos de dados ................................................................................................. 196
    8.3 Controle de fluxo..................................................................................................... 197
    8.3.1 if ...................................................................................................................... 197
    8.3.2 while ................................................................................................................ 199
    8.3.3 for.................................................................................................................... 199
    8.3.4 goto.................................................................................................................. 201
    8.3.5 switch .............................................................................................................. 202
    8.3.6 Exemplo: divisor............................................................................................... 203
    8.3.7 Exemplo: é um número de Fibonacci?................................................................204
    8.4 Instruções e expressões............................................................................................ 205
    8.4.1 Tipos de instrução ............................................................................................206
    8.4.2 Construindo expressões....................................................................................208
    8.5 Funções...................................................................................................................209
    8.6 Pré-processador ....................................................................................................... 212
    8.7 Resumo ................................................................................................................... 214

    Capítulo 9 • Sistema de tipos................................................................................................ 215
    9.1 Sistema básico de tipos em C.................................................................................... 215
    9.1.1 Tipos numéricos ............................................................................................... 216
    9.1.2 Casting de tipo ................................................................................................. 218
    9.1.3 Tipo booleano .................................................................................................. 219
    9.1.4 Conversões implícitas........................................................................................ 219
    9.1.5 Ponteiros .......................................................................................................... 221
    9.1.6 Arrays...............................................................................................................223
    9.1.7 Arrays como argumentos de função...................................................................225
    9.1.8 Inicializadores designados em arrays.................................................................226
    9.1.9 Aliases de tipo .................................................................................................. 227
    9.1.10 Revendo a função main ...................................................................................228
    9.1.11 Operador sizeof...............................................................................................229
    9.1.12 Tipos const ..................................................................................................... 231
    9.1.13 Strings ............................................................................................................233
    9.1.14 Tipos função ...................................................................................................234
    9.1.15 Escrevendo um bom código.............................................................................236
    9.1.16 Exercício: produto escalar................................................................................ 242
    9.1.17 Exercício: verificador de número primo............................................................ 243
    9.2 Tipos com tags......................................................................................................... 243
    9.2.1 Estruturas ........................................................................................................ 243
    9.2.2 Uniões.............................................................................................................. 246
    9.2.3 Estruturas e uniões anônimas........................................................................... 248
    9.2.4 Enumerações.................................................................................................... 249
    9.3 Tipos de dados nas linguagens de programação ........................................................250
    9.3.1 Espécies de tipagem ..........................................................................................250
    9.3.2 Polimorfismo .................................................................................................... 253
    9.4 Polimorfismo in C ....................................................................................................254
    9.4.1 Polimorfismo paramétrico ................................................................................. 255
    9.4.2 Inclusão............................................................................................................257
    9.4.3 Sobrecarga........................................................................................................258
    9.4.4 Coerções...........................................................................................................260
    9.5 Resumo ...................................................................................................................260

    Capítulo 10 • Estrutura do código .........................................................................................262
    10.1 Declarações e definições......................................................................................... 262
    10.1.1 Declarações de função.....................................................................................263
    10.1.2 Declarações de estrutura .................................................................................265
    10.2 Acessando código a partir de outros arquivos .........................................................266
    10.2.1 Funções de outros arquivos.............................................................................266
    10.2.2 Dados em outros arquivos...............................................................................268
    10.2.3 Arquivos de cabeçalho.................................................................................... 270
    10.3 A biblioteca-padrão................................................................................................ 272
    10.4 Pré-processador...................................................................................................... 275
    10.4.1 Guarda de inclusão ......................................................................................... 277
    10.4.2 Por que o pré-processador é maléfico?.............................................................. 279
    10.5 Exemplo: soma de um array dinâmico .................................................................... 281
    10.5.1 Uma espiada na alocação dinâmica de memória............................................... 281
    10.5.2 Exemplo .........................................................................................................282
    10.6 Exercício: lista ligada..............................................................................................283
    10.6.1 Exercício.........................................................................................................283
    10.7 Palavra reservada static...........................................................................................286
    10.8 Ligação .................................................................................................................. 287
    10.9 Resumo .................................................................................................................288

    Capítulo 11 • Memória..........................................................................................................290
    11.1 Revendo os ponteiros .............................................................................................290
    11.1.1 Por que precisamos de ponteiros?.....................................................................290
    11.1.2 Aritmética de ponteiros................................................................................... 291
    11.1.3 Tipo void* ........................................................... 293
    11.1.4 NULL............................................................................................................. 293
    11.1.5 Uma palavrinha sobre ptrdiff_t .......................................................................294
    11.1.6 Ponteiros de função......................................................................................... 295
    11.2 Modelo de memória ............................................................................................... 297
    11.2.1 Alocação de memória......................................................................................298
    11.3 Arrays e ponteiros.................................................................................................. 301
    11.3.1 Detalhes da sintaxe ......................................................................................... 302
    11.4 Strings literais ........................................................................................................ 303
    11.4.1 String Interning...............................................................................................306
    11.5 Modelos de dados ..................................................................................................306
    11.6 Streams de dados ...................................................................................................308
    11.7 Exercício: funções de alta ordem e listas.................................................................. 312
    11.7.1 Funções de alta ordem comuns........................................................................ 312
    11.7.2 Exercício......................................................................................................... 313
    11.8 Resumo.................................................................................................................. 315

    Capítulo 12 • Sintaxe, semântica e pragmática...................................................................... 317
    12.1 O que é uma linguagem de programação?............................................................... 317
    12.2 Sintaxe e gramáticas formais.................................................................................. 318
    12.2.1 Exemplo: números naturais............................................................................. 320
    12.2.2 Exemplo: aritmética simples ........................................................................... 321
    12.2.3 Descida recursiva ........................................................................................... 322
    12.2.4 Exemplo: aritmética com prioridades .............................................................. 326
    12.2.5 Exemplo: linguagem imperativa simples.......................................................... 327
    12.2.6 Hierarquia de Chomsky.................................................................................. 328
    12.2.7 Árvore de sintaxe abstrata............................................................................... 329
    12.2.8 Análise lexical ................................................................................................ 330
    12.2.9 Resumo sobre o parsing.................................................................................. 330
    12.3 Semântica.............................................................................................................. 330
    12.3.1 Comportamento indefinido............................................................................. 331
    12.3.2 Comportamento não especificado................................................................... 334
    12.3.3 Comportamento definido pela implementação ................................................ 334
    12.3.4 Pontos de sequência ........................................................................................ 335
    12.4 Pragmática............................................................................................................. 336
    12.4.1 Alinhamento................................................................................................... 336
    12.4.2 Preenchimento de estruturas de dados............................................................. 337
    12.5 Alinhamento no C11.............................................................................................. 341
    12.6 Resumo ................................................................................................................. 342

    Capítulo 13 • Boas práticas de programação..........................................................................344
    13.1 Fazendo escolhas ...................................................................................................344
    13.2 Elementos do código ..............................................................................................346
    13.2.1 Nomenclatura em geral...................................................................................346
    13.2.2 Estrutura de arquivos ..................................................................................... 347
    13.2.3 Tipos.............................................................................................................. 347
    13.2.4. Variáveis........................................................................................................349
    13.2.5 Sobre variáveis globais.................................................................................... 350
    13.2.6 Funções.......................................................................................................... 351
    13.3 Arquivos e documentação ...................................................................................... 351
    13.4 Encapsulamento..................................................................................................... 353
    13.5 Imutabilidade......................................................................................................... 358
    13.6 Asserções............................................................................................................... 359
    13.7 Tratamento de erros............................................................................................... 359
    13.8 Sobre a alocação de memória.................................................................................. 363
    13.9 Sobre a flexibilidade ............................................................................................... 363
    13.10 Exercício: rotação de imagem................................................................................ 365
    13.10.1 Formato de arquivo BMP...............................................................................366
    13.10.2 Arquitetura ................................................................................................... 367
    13.11 Exercício: alocador de memória personalizado ...................................................... 369
    13.12 Resumo................................................................................................................ 373

    Parte III • Entre o C e o Assembly................................................................374

    Capítulo 14 • Detalhes sobre a tradução................................................................................375
    14.1 Sequência de chamadas de função .......................................................................... 375
    14.1.1 Registradores XMM ........................................................................................ 375
    14.1.2 Convenção de chamadas ................................................................................. 376
    14.1.3 Exemplo: uma função simples e sua pilha ........................................................ 379
    14.1.4 Zona vermelha ................................................................................................ 382
    14.1.5 Número variável de argumentos ......................................................................383
    14.1.6 vprintf e seus companheiros............................................................................384
    14.2 volatile...................................................................................................................385
    14.2.1 Alocação de memória em modo preguiçoso .....................................................386
    14.2.2 Código gerado ................................................................................................ 387
    14.3 Jumps não locais – setjmp ......................................................................................388
    14.3.1 volatile e setjmp .............................................................................................. 390
    14.4 inline ..................................................................................................................... 394
    14.5 restrict ................................................................................................................... 395
    14.6 Aliasing rigoroso .................................................................................................... 398
    14.7 Problemas de segurança.......................................................................................... 399
    14.7.1 Stack buffer overrun (transbordamento de buffer na pilha) ............................... 399
    12 Programação em Baixo Nível
    14.7.2 return-to-libc ..................................................................................................400
    14.7.3 Vulnerabilidades de formatação de saída.......................................................... 401
    14.8 Mecanismos de proteção ........................................................................................403
    14.8.1 Cookie de segurança .......................................................................................404
    14.8.2 Address Space Layout Randomization (Randomização do Layout do Espaço de
    Endereçamento)...................................................................................................404
    14.8.3 DEP................................................................................................................404
    14.9 Resumo..................................................................................................................405

    Capítulo 15 • Objetos compartilhados e modelos de código ...................................................407
    15.1 Carga dinâmica......................................................................................................407
    15.2 Relocações e PIC.................................................................................................... 410
    15.3 Exemplo: biblioteca dinâmica em C........................................................................ 410
    15.4 GOT e PLT ............................................................................................................ 412
    15.4.1 Acessando variáveis externas........................................................................... 412
    15.4.2 Chamando funções externas........................................................................... 415
    15.4.3 Exemplo de PLT.............................................................................................. 418
    15.5 Pré-carga ............................................................................................................... 420
    15.6 Resumo sobre o endereçamento de símbolos........................................................... 422
    15.7 Exemplos............................................................................................................... 422
    15.7.1 Chamando uma função ................................................................................... 423
    15.7.2 Sobre vários linkers dinâmicos ........................................................................ 425
    15.7.3 Acessando uma variável externa ...................................................................... 426
    15.7.4 Exemplo completo em Assembly...................................................................... 428
    15.7.5 Misturando C e Assembly ............................................................................... 429
    15.8 Quais objetos são ligados?...................................................................................... 431
    15.9 Otimizações........................................................................................................... 435
    15.10 Modelos de código ............................................................................................... 439
    15.10.1 Modelo de código pequeno (sem PIC)............................................................ 441
    15.10.2 Modelo de código grande (sem PIC)............................................................... 442
    15.10.3 Modelo de código médio (sem PIC) ...............................................................443
    15.10.4 Modelo de código pequeno com PIC..............................................................444
    15.10.5 Modelo de código grande com PIC ................................................................445
    15.10.6 Modelo de código médio com PIC .................................................................448
    15.11 Resumo................................................................................................................ 451

    Capítulo 16 • Desempenho ...................................................................................................453
    16.1 Otimizações........................................................................................................... 453
    16.1.1 Mito sobre linguagens rápidas ......................................................................... 454
    16.1.2 Conselhos gerais............................................................................................. 455
    16.1.3 Omitindo o ponteiro do stack frame ................................................................ 457
    16.1.4 Recursão de cauda........................................................................................... 459
    16.1.5 Eliminação de subexpressões comuns..............................................................463
    16.1.6 Propagação de constantes................................................................................464
    16.1.7 Otimização de valores de retorno (nomeados)..................................................466
    16.1.8 Influência da previsão de desvio ......................................................................469
    16.1.9 Influência das unidades de execução................................................................ 470
    16.1.10 Agrupando leituras e escritas no código ......................................................... 472
    16.2 Caching ................................................................................................................. 472
    16.2.1 Como usar o cache de modo eficaz?................................................................. 472
    16.2.2 Prefetching ..................................................................................................... 474
    16.2.3 Exemplo: busca binária com prefetching ......................................................... 475
    16.2.4 Ignorando o cache........................................................................................... 479
    16.2.5 Exemplo: inicialização de matriz.....................................................................480
    16.3 Classe de instruções SIMD.....................................................................................483
    16.4 Extensões SSE e AVX .............................................................................................484
    16.4.1 Exercício: filtro sépia ....................................................................................... 487
    16.5 Resumo ................................................................................................................. 492

    Capítulo 17 • Multithreading................................................................................................494
    17.1 Processos e threads.................................................................................................494
    17.2 O que deixa o multithreading complicado? ............................................................. 495
    17.3 Ordem de execução ................................................................................................496
    17.4 Modelos de memória fortes e fracos.........................................................................498
    17.5 Exemplo de reordenação.........................................................................................499
    17.6 O que é e o que não é volátil ................................................................................... 502
    17.7 Barreiras de memória.............................................................................................. 503
    17.8 Introdução à pthreads............................................................................................. 505
    17.8.1 Quando usar multithreading ...........................................................................506
    17.8.2 Criando threads.............................................................................................. 507
    17.8.3 Gerenciando threads....................................................................................... 512
    17.8.4 Exemplo: fatoração distribuída ........................................................................ 513
    17.8.5 Mutexes.......................................................................................................... 518
    17.8.6 Deadlocks....................................................................................................... 522
    17.8.7 Livelocks......................................................................................................... 523
    17.8.8 Variáveis de condição ...................................................................................... 525
    17.8.9 Spinlocks........................................................................................................ 528
    17.9 Semáforos .............................................................................................................. 530
    17.10 Quão robusto é o Intel 64? .................................................................................... 533
    17.11 O que é uma programação sem lock?..................................................................... 537
    17.12 Modelo de memória do C11 ..................................................................................540
    17.12.1 Visão geral.....................................................................................................540
    17.12.2 Atômicos....................................................................................................... 541
    17.12.3 Ordenações de memória no C11 .................................................................... 542
    17.12.4 Operações.....................................................................................................544
    17.13 Resumo ................................................................................................................546

    Apêndice A • Usando o gdb...................................................................................................549
    Apêndice B • Usando o Make................................................................................................558
    Apêndice C • Chamadas de sistema.......................................................................................564
    Apêndice D • Informações sobre testes de desempenho ........................................................571
    Bibliografia.......................................................................................................................... 574

    Informações Técnicas

    Nº de páginas:576
    Origem:Nacional
    Editora:Editora Novatec
    Idioma:Português
    Edição:1ª Edição
    Ano:2018
    ISBN:9788575226674
    Encadernação:Brochura
    Autor:Igor Zhirkov
  • Informações

Avaliação técnica sobre o livro

Olá! Seja Bem Vindo (a)!

Eu sou o Moderninho , o Mascote da Ciência Moderna Online!
Além de bonito, o novo site tem Minhas Dicas :) #ficaadica

A 1ª Dica é -> Deixe aqui seu contato para receber nossas
NOVIDADES, PROMOÇÕES E CUPONS DE DESCONTOS ;)

Navegue SEM Moderação!