Where 0×08048000 ELF address came from?

Reading some ELF [1] and linux memory managing papers [2] I noticed the use of address 0×08048000 for the start of linear address but no one told why this address was chosen. Until now I didn’t find an reasonably explanation, below are some links about what I was reading and commenting about this misteriousssss number:

http://flint.cs.yale.edu/cs422/doc/ELF_Format.pdf

http://duartes.org/gustavo/blog/post/anatomy-of-a-program-in-memory

http://stackoverflow.com/questions/7187981/whats-the-memory-before-0×08048000-used-for-in-32-bit-machine

http://forum.osdev.org/viewtopic.php?f=13&t=24474

Linux Assembler Tutorial

Abaixo segue um pequeno tutorial sobre ferramentas de programação (“assembler”) em linux. Achei o texto simples, direto e helpful então vale a pena compartilhar.

JT.

========================================================================
LINUX ASSEMBLER TUTORIAL

by

Robin Miyagi

@

http://www.geocities.com/SiliconValley/Ridge/2544/

========================================================================

start@: Thu Feb 03 02:14:37 UTC 2000

update: Fri Jul 30 23:52:23 UTC 2000

update: Fri Sep 15 22:39:17 UTC 2000 :

– This tutorial now explains Linux assembler in terms of the GNU
assembler `as’.

– Information about Binutils programs such as Objdump, and ld.
Discussion on Debugging and `gdb’ is added.

update: Thu Jan 11 20:13:06 UTC 2001 :

========================================================================

* Introduction
————————————————————————

When programming in assembler for Linux (or any other Unix variant
for that matter), it is important to remember that Linux is a
protected mode operating system (on i386 machines, Linux operates
the CPU in protected mode). This means that ordinary user mode
processes are not allowed to do certain things, such as access DMA,
or access IO ports. Writing Linux kernel modules on the other hand
(which operate in kernel mode), are allowed to access hardware
directly (Read the Assembler-HOWTO on my assembler page for more
information on this issue). User mode processes may access hardware
using device files. Device files actually access kernel modules
which access hardware directly. This file will be restricted to
user mode operation. See my pages on kernel module programming.

Please email me comments and suggestions regarding this tutorial at
penguin@dccnet.com .

* System Calls
————————————————————————

In programming in assembler for DOS you probably made use of
software interrupts, especially the int 0×21 functions which were
the DOS system calls. In Linux, system calls are made via int 0×80.
The sytem call number is passed via register EAX, and the parameters
to the system call are passed via the remaining registers. This
discussion only applies if there are no more than five parameters
passed to the system call. If there are more than 5 parameters.
The parameters must be located in memory (e.g. on the stack), and
EBX must contain the address of the beginning of the parameters.

If you would like a list of the system call numbers, look at the
contents of /usr/include/asm/unistd.h. If you would like
information about a specific system call (e.g. write ()), type `man
2 write’ at the prompt. Section 2 of the linux man pages covers
sytem calls.

If you look at the contents of /usr/include/asm/unistd.h, you will
see the following line near the top of the file;

#define __NR_write 4

This indicates that register EAX must be set to 4 in order to call
the write () system call. Now, if you execute the following
command;

$ man 2 write

you get the following function description (under the SYNOPSIS
heading).

ssize_t write(int fd, const void *buf, size_t count);

This indicates that ebx is equal to the file descriptor of the file
you want to write to, ecx is a pointer of the string you want to
write, and edx contains the length of the string. If there were 2
more parameters to this system call, they would be placed in esi,
and edi respectively.

How do I know the file discriptor for stdout is 1. If you look at
your /dev directory, you will notice that /dev/stdout is a symbolic
link that points to /proc/self/fd/1. Therefore stdout is file
descriptor 1.

I leave looking up the _exit system call as an exercise.

In linux, system calls are processed by the kernel.

* GNU Assembler
————————————————————————

On most Linux systems, you will usually find the GNU C compiler
(gcc). This compiler uses an assembler called `as’ as a back-end.
This means that the C compiler translates the C code into assembler,
which in turn is assembled by `as’ to an object file (*.o).

`As’ uses the AT&T syntax. Experienced intel syntax assembler
programmers find AT&T `really weird’. It is really no more or no
less difficult than intel syntax. I switched over to `as’ because
there is less ambiguity, works better with the standard GNU/Linux
programs such as gdb (supports the gstabs format), objdump (objdump
dissassembles code in `as’ syntax). In short, it is a standard
component of a GNU Linux system with programming tools installed. I
will explain debugging and objdump later in this tutorial.

If you would like more information about `as’ look in the info
documentation under as (e.g. type `info as’ at the shell prompt).
Also look in the info documentation on the Binutils package (this
package contains such programming tools as objdump, ld, etc.).

** GNU assembler v.s. Intel Syntax
————————————————————————

Since most assembler documentation for the i386 platform is written
using intel syntax, some comparison between the 2 formats is in
order. Here is a summarized list of the differences;

– In `as’ the source comes before the the destination, opposite to
the intel syntax.

– The opcodes are suffixed with a letter indicating the size of
the opperands (e.g. `l’ for dword, `w’ for word, `b’ for byte).

– Immediate values must be prefixed with a `$’, and registers must
be prefixed with a `%’.

– Effective addresses use the General syntax
DISP(BASE,INDEX,SCALE). A concrete example would be;

movl mem_location(%ebx,%ecx,4), %eax

Which is equivelent to the following in intel syntax;

mov eax, [eax + ecx*4 + mem_location]

Now for an example illustrating the difference (intel version in
comments);

movl %eax, %ebx # mov %ebx, %eax
movw $0x3c4a, %ax

Now for our little program;
————————————————————————
## hello-world.s

## by Robin Miyagi
## http://www.geocities.com/SiliconValley/Ridge/2544/

## Compile Instructions:
## ————————————————————-
## as -o hello-world.o hello-world.s
## ld -o hello-world -O0 hello-world.o

## This file is a basic demonstration of the GNU assembler,
## `as’.

## This program displays a friendly string on the screen using
## the write () system call
########################################################################
.section .data
hello:
.ascii “Hello, world!\n”
hello_len:
.long . – hello
########################################################################
.section .text
.globl _start

_start:
## display string using write () system call
xorl %ebx, %ebx # %ebx = 0
movl $4, %eax # write () system call
xorl %ebx, %ebx # %ebx = 0
incl %ebx # %ebx = 1, fd = stdout
leal hello, %ecx # %ecx —> hello
movl hello_len, %edx # %edx = count
int $0×80 # execute write () system call

## terminate program via _exit () system call
xorl %eax, %eax # %eax = 0
incl %eax # %eax = 1 system call _exit ()
xorl %ebx, %ebx # %ebx = 0 normal program return code
int $0×80 # execute system call _exit ()

————————————————————————

In the above program, notice the use of `#’ to start comments. `As’
also supports the `/* C comment *’ syntax. If you use the C comment
syntax, it works exactly the same as for C (multiple lines, as well
as inline commenting). I always use the `#’ comment syntax, as this
works better with emacs’ asm-mode. The double `##’ is allowed but
not neccessary (this is only because of a quirk of emacs asm-mode).

Notice the names of the sections .text, and .data. these are used
in ELF files to tell the linker where the code and data segments
are. There is also the .bss section to store uninitialized data.
It is only these sections that occupy memory durring program
execution.

* Accessing Command Line Arguments and Environment Variables

When an ELF executable starts running, the command line arguments
and environment variables are available on the stack. In assembler
this means that you may access these via the pointer stored in ESP
when the program starts execution. See the documentation on my
assembler programming page relating to the ELF binary format.

So how is this data arranged on the stack? Quite simple really.
The number of command line arguments (including the name of the
program) are stored as an integer at [esp]. Then, at [esp+4] a
pointer to the first command line argument (which is the name of the
program) is stored. If there were any additional command line
parameters, their pointers would be stored in [esp+8], [esp+12],
etc. After all the command line argument pointers, comes a NULL
pointer. After the NULL pointer are all the pointers to the
environment variables, and then finally a NULL pointer to indicate
the end of the environment variables have been reached.

A summary of the initial ELF stack is shown below;

(%esp) argc, count of arguments (integer)
4(%esp) char *argv (pointer to first command line argument)
… pointers to the rest of the command line arguments
?(%esp) NULL pointer
… pointers to environment variables
??(%esp) NULL pointer

Now for our little program;
————————————————————————
## stack-param.s ###############################################

## Robin Miyagi ################################################
## http://www.geocities.com/SiliconValley/Ridge/2544/ ##########

## This file shows how one can access command line parameters
## via the stack at process start up. This behavior is defined
## in the ELF specification.

## Compile Instructions:
## ————————————————————-
## as -o stack-param.o stack-param.s
## ld -O0 -o stack-param stack-param.o
########################################################################
.section .data

new_line_char:
.byte 0x0a
########################################################################
.section .text

.globl _start

.align 4
_start:
movl %esp, %ebp # store %esp in %ebp
again:
addl $4, %esp # %esp —> next parameter on stack
movl (%esp), %eax # move next parameter into %eax
testl %eax, %eax # %eax (parameter) == NULL pointer?
jz end_again # get out of loop if yes
call putstring # output parameter to stdout.
jmp again # repeat loop
end_again:
xorl %eax, %eax # %eax = 0
incl %eax # %eax = 1, system call _exit ()
xorl %ebx, %ebx # %ebx = 0, normal program exit.
int $0×80 # execute _exit () system call

## prints string to stdout
putstring: .type @function
pushl %ebp
movl %esp, %ebp
movl 8(%ebp), %ecx
xorl %edx, %edx
count_chars:
movb (%ecx,%edx,$1), %al
testb %al, %al
jz done_count_chars
incl %edx
jmp count_chars
done_count_chars:
movl $4, %eax
xorl %ebx, %ebx
incl %ebx
int $0×80
movl $4, %eax
leal new_line_char, %ecx
xorl %edx, %edx
incl %edx
int $0×80
movl %ebp, %esp
popl %ebp
ret

————————————————————————

* The Binutils Package
————————————————————————

Binutils stands for binary utilities, and includes a lot of tools
useful to programmers, especially durring debugging.

I will now address some of these utilities.

** Objdump
————————————————————————

Objdump diplays information about 1 or more object files. For
example, to see information about param-stack, type the following
command at shell prompt (be sure working directory contains
param-stack);

objdump -x param-stack | less

Since the information is likely to span more than one screen, the
output of objdump is piped to the standard input of the paging
command `less’. the option `-x’ tells objdump to display the
numeric information in hexadecimal. Here is the output of the above
command;

—————————————————————-
stack-param: file format elf32-i386
stack-param
architecture: i386, flags 0×00000112:
EXEC_P, HAS_SYMS, D_PAGED
start address 0×08048074

Program Header:
LOAD off 0×00000000 vaddr 0×08048000 paddr 0×08048000 align 2**12
filesz 0x000000be memsz 0x000000be flags r-x
LOAD off 0x000000c0 vaddr 0x080490c0 paddr 0x080490c0 align 2**12
filesz 0×00000001 memsz 0×00000004 flags rw-

Sections:
Idx Name Size VMA LMA File off Algn
0 .text 0000004a 08048074 08048074 00000074 2**2
CONTENTS, ALLOC, LOAD, READONLY, CODE
1 .data 00000001 080490c0 080490c0 000000c0 2**2
CONTENTS, ALLOC, LOAD, DATA
2 .bss 00000000 080490c4 080490c4 000000c4 2**2
ALLOC
SYMBOL TABLE:
08048074 l d .text 00000000
080490c0 l d .data 00000000
080490c4 l d .bss 00000000
00000000 l d *ABS* 00000000
00000000 l d *ABS* 00000000
00000000 l d *ABS* 00000000
080490c0 l .data 00000000 new_line_char
08048076 l .text 00000000 again
08048087 l .text 00000000 end_again
0804808e l .text 00000000 putstring
08048096 l .text 00000000 count_chars
080480a0 l .text 00000000 done_count_chars
00000000 F *UND* 00000000
080480be g O *ABS* 00000000 _etext
08048074 g .text 00000000 _start
080490c1 g O *ABS* 00000000 __bss_start
080490c1 g O *ABS* 00000000 _edata
080490c4 g O *ABS* 00000000 _end

—————————————————————-

Notice the Information provided from the program header (ELF files
have header information at the beginning of the file giving
information to the kernel on how to load the file into memory etc.).

ELF files also contain information about the sections (contained in
section tables). Notice that the .text section contains 0x4a bytes
of information, is located 0×74 bytes into the file, and is aligned
at a 4 byte boundary (4 == 2 ** 2), has memory allocated to it
(ALLOC), is readoly, and contains code (the segment selector cs for
this process points to this section (handled by the operating
system)).

Information about the symbols is also provided. All this
information is used by debuggers and other programming tools to
examine binary files.

Objdump can also be used to dissasemble binary executables. Typeing
the following command will dissassemble the file to standard output
(this does nothing to the actual file, as objdump only reads from
the file);

objdump -d stack-param | less

Here is the output of the above command;

—————————————————————-
stack-param: file format elf32-i386

Disassembly of section .text:

08048074 :
8048074: 89 e5 movl %esp,%ebp

08048076 :
8048076: 83 c4 04 addl $0×4,%esp
8048079: 8b 04 24 movl (%esp,1),%eax
804807c: 85 c0 testl %eax,%eax
804807e: 74 07 je 8048087
8048080: e8 09 00 00 00 call 804808e
8048085: eb ef jmp 8048076

08048087 :
8048087: 31 c0 xorl %eax,%eax
8048089: 40 incl %eax
804808a: 31 db xorl %ebx,%ebx
804808c: cd 80 int $0×80

0804808e :
804808e: 55 pushl %ebp
804808f: 89 e5 movl %esp,%ebp
8048091: 8b 4d 08 movl 0×8(%ebp),%ecx
8048094: 31 d2 xorl %edx,%edx

08048096 :
8048096: 8a 04 11 movb (%ecx,%edx,1),%al
8048099: 84 c0 testb %al,%al
804809b: 74 03 je 80480a0
804809d: 42 incl %edx
804809e: eb f6 jmp 8048096

080480a0 :
80480a0: b8 04 00 00 00 movl $0×4,%eax
80480a5: 31 db xorl %ebx,%ebx
80480a7: 43 incl %ebx
80480a8: cd 80 int $0×80
80480aa: b8 04 00 00 00 movl $0×4,%eax
80480af: 8d 0d c0 90 04 08 leal 0x80490c0,%ecx
80480b5: 31 d2 xorl %edx,%edx
80480b7: 42 incl %edx
80480b8: cd 80 int $0×80
80480ba: 89 ec movl %ebp,%esp
80480bc: 5d popl %ebp
80480bd: c3 ret
—————————————————————-

The `-d’ tells objdump to disassemble sections that are expected to
contain code (usually the .text section). Using the `-D’ option
will disassemble all sections. Objdump was able to give the names
of labels in the code because of the information contained in the
symbols table.

The first column displays the virtual memory address for each line
of code. The second column displays the machine code corresponding
to its respective assembler line of code, and finally the code in
assembler is contained in the 3rd column.

For more information look in the info documentation system.

** Getting the amount of memory used with size
————————————————————————

If you do an `ls -l stack-param’ you get the following

-rwxrwxr-x 1 robin robin 932 Sep 15 18:21 stack-param

This tells you that the file is 932 bytes long. However this file
also contains header tables, section tables, symbol tables etc. The
amount of memory that this program will use durring run time will be
less than this. To find out actual memory use, type the following;

size stack-param

The above will result in the following output;

text data bss dec hex filename
74 1 0 75 4b stack-param

This tells you that .text occupies 74 bytes, and .data occupies one
byte, for a total of 75 bytes memory use.

** Getting rid of symbol information with strip
————————————————————————

The strip command can be used to get rid of the symbol information.
With no options, this command only strips symbols that are not used
for debugging. With the `–stip-all’ option provided, it will strip
all symbol information, including those used for debugging. I
recommend not doing this, as this makes the files harder to analyse
with the standard programming tools. This command is used only if
file size is of paramount importance.

* debugging and gdb
————————————————————————

Perhaps the most difficult aspect of programming is debugging.
Quite often the error that caused the program to terminate
abnormally is not at the line where the program terminated (the
example later on will show this).

Program that exits with SIG_SEGV
————————————————————————
## stack-param-error.s #########################################

## Robin Miyagi ################################################
## http://www.geocities.com/SiliconValley/Ridge/2544/ ##########

## This file shows how one can access command line parameters
## via the stack at process start up. This behavior is defined
## in the ELF specification.

## Compile Instructions:
## ————————————————————-
## as –gstabs -o stack-param-error.o stack-param-error.s
## ld -O0 -o stack-param-error stack-param-error.o
########################################################################
.section .data

new_line_char:
.byte 0x0a
########################################################################
.section .text

.globl _start

.align 4
_start:
movl %esp, %ebp # store %esp in %ebp
again:
addl $4, %esp # %esp —> next parameter on stack
leal (%esp), %eax # move next parameter into %eax
testl %eax, %eax # %eax (parameter) == NULL pointer?
jz end_again # get out of loop if yes
call putstring # output parameter to stdout.
jmp again # repeat loop
end_again:
xorl %eax, %eax # %eax = 0
incl %eax # %eax = 1, system call _exit ()
xorl %ebx, %ebx # %ebx = 0, normal program exit.
int $0×80 # execute _exit () system call

## prints string to stdout
putstring: .type @function
pushl %ebp
movl %esp, %ebp
movl 8(%ebp), %ecx
xorl %edx, %edx
count_chars:
movb (%ecx,%edx,$1), %al
testb %al, %al
jz done_count_chars
incl %edx
jmp count_chars
done_count_chars:
movl $4, %eax
xorl %ebx, %ebx
incl %ebx
int $0×80
movl $4, %eax
leal new_line_char, %ecx
xorl %edx, %edx
incl %edx
int $0×80
movl %ebp, %esp
popl %ebp
ret
————————————————————————

Notice that the above program is assembled with the `–gstabs’
option of `as’. This make as put debugging information in output
file, such as the original source file, debugging symbols etc.
Using `objdump -x stack-param-error | less’ will show you the
inclusion of debugging symbols.

Now to find out where our error occurred type the following command;

gdb stack-param-error

this will get you to the gdb prompt `(gdb)’;

(gdb) run eat my shorts
/home/robin/programming/asm-tut/stack-param-error
eat
my
shorts
Program recieved SIGSEGV, segmentation fault
count_chars () at stack-param-error.s:47

47 movb (%ecx,%edx,$1), %al
Current language: auto; currently asm
(gdb) q
[~]$ _

(gdb will output more than this, I just wanted to highlight what
is important).

This tells us that the segmentation fault occured at line 47 of
param-stack-error.s. However the problem was caused in line 29. If
you look at line 29 of stack-param.s, you will see that this line
reads `movl (%esp), %eax’. This is due to the way intel i386 opcode
lea handles NULL pointers. EAX was never loaded with 0 on a null
pointer (just some invalid pointer), which caused line 47 to access
an area of memory not available to this process (hence the
segmentation fault). The loop in _start () never stopped normally,
as the condition for breaking out of the loop is eax being 0, which
never happened.

Debugging is an art that comes with practice. For more information
about gdb, look in the info pages (e.g. `info gdb’). You can also
type `help’ at the (gdb) prompt.

The only reason gdb was able to tell you what line number in the
source code the error occured is that the debugging symbols and
source code was included in the output file (recall that we used the
`–gstabs’ option).

——————————————————————–
Comments and suggestions

========================================================================

You are free to make verbatim copies of this file, providing that this
notice is preserved.

O ensino/aprendizagem de leitura

por Jáder vanderlei Muniz de Souza

            A leitura é basicamente um processo de representação. Como esse processo envolve o sentido da visão, ler é, na sua essência, olhar para uma coisa e ver outra. A leitura não se dá por acesso direto à realidade, mas por intermediação de outros elementos da realidade. Nessa triangulação da leitura o elemento intermediário funciona como um espelho; mostra um segmento do mundo que normalmente nada tem a ver com sua consistência física. Ler é, portanto, reconhecer o mundo através de espelhos. Como esses espelhos oferecem imagens fragmentadas do mundo, a verdadeira leitura só é possível quando se tem um conhecimento prévio desse mundo.

Embora a leitura, na concepção mais comum do termo, processa-se através da língua, também é possível a leitura através de sinais não-linguísticos. Pode-se ler tristeza nos olhos de alguém, a sorte não mão de uma pessoa ou o passado de um povo nas ruínas de uma cidade. Não se lê, portanto, apenas a palavra escrita mas também o próprio mundo que nos cerca.

O processo de triangulação, no entanto, é o mesmo. Ao fazermos a leitura sociológica de uma rua da cidade olhamos para as casas, o calçamento, as pessoas, mas vemos a realidade sociológica refletida por essa rua.

O segundo elemento da realidade não está em relação unívoca com o primeiro. Sendo o primeiro elemento um espelho, a visão a ser dada por esse espelho, depende da posição da pessoa em relação ao espelho. Diferentes posições refletem diferentes segmentos da realidade. Numa leitura do mundo, o objeto para o qual se olha funciona como um espelho. Se o objeto for, por exemplo, uma casa, vai oferecer tantas leituras quantas forem as posições de cada um dos observadores em relação à casa. O arquiteto fará uma leitura arquitetônica, o sociólogo uma leitura sociológica, o ladrão uma leitura estratégica, e assim por diante.

Sem triangulação não há leitura. Às vezes, no entanto, a triangulação não é possível. Quando o leitor diz “li mas não entendi”, ele ficou apenas no primeiro elemento da realidade; olhou mas não viu. Ouve tentativa de leitura mas não ouve leitura.

Entre o leitor e o que ele vê através da leitura pode haver mais de um espelho. Ocorre então que aquilo que é percebido é um reflexo do reflexo da realidade. Esse parece ser principalmente o caso da leitura de uma obra literária, que pode implicar não apenas reflexos de reflexos mas verdadeiro encadeamentos de reflexos. Na leitura de um poema, por exemplo, um determinado segmento da realidade (um dos possíveis significados do poema) pode ser refletido através de vários espelhos até chegar à percepção do leitor.

Primordialmente, na sua concepção mais geral e fundamental, ler é usar segmentos da realidade para chegar a outros segmentos. Dentro dessa acepção, tanto a palavra escrita como outros objetos podem ser lidos, desde que sirvam como elementos intermediários, indicadores de outros elementos. Esse processo de triangulação, de acesso indireto à realidade, é a condição básica para que o ato da leitura ocorra.

 

• Perspectivas de leitura:

ü  Leitura como extração de significado do texto

Um dos axiomas da leitura é de que ler implica significado, sendo significado aquele segmento da realidade a que se chega através de um outro segmento. O significado pode estar em vários lugares, mas ao se usar o verbo extrair, põe-se o significado dentro do texto. Uma analogia que parece refletir adequadamente esta acepção de leitura é a de que o texto é uma mina, possivelmente com inúmeros corredores subterrâneos, cheia de riquezas, mas que precisa ser persistentemente explorada pelo leitor.

Essa leitura extração-de-significado está associada a idéia de que o texto tem um significado preciso, exato e completo, que o leitor-minerador pode obter através do esforço e da persistência. Como o texto contém o significado, esse texto precisa ser apreendido pelo leitor na sua íntegra. A leitura deve ser cuidadosa, com consulta ao dicionário sempre que uma palavra desconhecida for encontrada e anotação da palavra para revisões posteriores e enriquecimento do vocabulário. Frases de compreensão difícil devem ser lidas e relidas até que a compreensão fique clara.

A adivinhação de palavras novas pelo contexto deve ser evitada porque a leitura é um processo exato e a compreensão não comporta aproximações. O texto está cheio de armadilhas para o leitor impulsivo que não sabe parar e refletir diante dos vocábulos que só são semelhantes na aparência ou de figuras de linguagem que precisam ser reconhecidas para que se possa apreciar a beleza do texto. Tudo que o texto contém precisa ser detectado e analisado para que o seu verdadeiro significado possa ser extraído.

Erros de leitura oral são vistos como provas de deficiência em leitura. A leitura é um processo linear que se desenvolve palavra por palavra. O significado é extraído – vai-se acumulando – à medida em que essas palavras vão sendo processadas.

O aspecto visual da leitura – o papel dos olhos – é de extrema importância nesta acepção de leitura. O significado vai do texto ao leitor, através dos olhos. Nenhuma palavra é entendida antes de ser vista. O raciocínio do leitor é comandado pela informação que entra pelos olhos.

O leitor está subordinado ao texto, que é o pólo mais importante da leitura. Se o texto for rico, o leitor se enriquecerá com ele, aumentará seu conhecimento de tudo porque o texto é mundo. Se o texto for pobre, mina sem ouro, o leitor perderá seu tempo, porque nada há para extrair.

O leitor-minerador tem no entanto muito a ganhar, porque há uma riqueza incalculável nos livros tudo que ele de melhor produziu o pensamento humano está registrado na permanência da palavra escrita.

A compreensão é o resultado do ato da leitura. O valor da leitura só pode ser medido depois que a leitura terminou. A ênfase não está no processe da compreensão, na construção do significado, mas no produto final dessa compreensão.

A leitura é um processe ascendente. A compreensão sobe do texto ao leitor na medida exata em que o leitor vai avançando no texto. As letras vão formando palavras, as palavras frases e as frases parágrafos. O texto é processa do literalmente da esquerda para a direita e de cima para baixo.

A concepção da leitura como um processo de extração tem, no entanto, sérias limitações. O verbo extrair, em primeiro lugar, não reflete o que  realmente acontece na leitura. O leitor não extrai um conteúdo do texto, como se o texto fosse uma mina que se esvazia com a mineração. O conteúdo não se transfere do texto para o leitor, mas antes se reproduz no leitor, sem deixar de permanecer no texto. Conceptualmente, não teríamos portanto uma extração, mas uma cópia.

Na realidade, o texto não possui um conteúdo mas reflete-o como um espelho. Assim como não há qualquer identidade física entre o material de que é feito o espelho e o material que ele reflete, não existe também uma relação unívoca entre o texto e o conteúdo. Um mesmo texto pode refletir vários conteúdos, como vários textos podem também refletir um só conteúdo.

 

 

ü  Leitura com atribuição de significado ao texto

            A acepção de que ler é atribuir significado, põe a origem do significado não no texto mas no leitor. O mesmo texto pode provocar em cada leitor e mesmo em cada leitura uma visão diferente da realidade.

A visão da realidade provocada pela presença do texto depende da bagagem de experiências prévias que o leitor traz para a leitura. O texto não contém a realidade, reflete apenas segmentos da realidade, entremeados de inúmeras lacunas, que o leitor vai preenchendo com o conhecimento prévio que possui do mundo.

A qualidade do ato da leitura não é medida pela qualidade intrínseca do texto, mas pela qualidade da reação do leitor. A riqueza da leitura não está necessariamente nas grandes obras clássicas, mas na experiência do leitor ao processar o texto. O significado não está na mensagem do texto mas na série de acontecimentos que o texto desencadeia na mente do leitor.

Ler não implica necessariamente apreender a mensagem na sua íntegra. A leitura pode ser lenta e cuidadosa como rápida e superficial, com ou sem consulta ao dicionário. A adivinhação de palavras desconhecidas pelo contexto é incentivada. Ao encontrar uma frase de com preensão difícil, o leitor não deve parar e reler, mas ler adiante; provavelmente entendendo a frase ao chegar ao fim do parágrafo.

Erros de leitura oral são interpretados do ponto de vista qualitativo e considerados apenas como desvios. Não importa cometer muitos erros; o que imteressa é o tipo de erro cometido. Se no texto, por exemplo, estiver escrito “gatinho” e o leitor ler “bichinho” mantendo a coerência interpretativa, considera-se que a qualidade da leitura não é prejudicada.

A leitura não é interpretada como um procedimento linear, onde o significado é construído palavra por palavra, mas como um procedimento de levantamento de hipóteses. O que o leitor processa da página escrita é o mínimo necessário para confirmar ou rejeitar hipóteses.

Os olhos não vêem o que realmente está escrito na pagina, mas apenas determinadas informações pedidas pelo cérebro. A compreensão não começa pelo que esta na frente dos olhos, mas pelo que esta atrás deles. A palavra “nós”, por exemplo, poderá ser entendida como plural de “nó” ou como pronome pessoal, dependendo do que o cérebro mandou o olho buscar, baseado naturalmente no contexto em que se encontra a palavra.

A compreensão não é um produto final, acabado, mas um processo que se desenvolve no momento em que a leitura é realizada. A ênfase não está na dimensão espacial e permanente do texto mas no aspecto temporal e mutável do ato da leitura. O interesse do pesquisador ou do professor não está no produto final da leitura, na compreensão extraída do texto, mas principalmente em como se dá essa compreensão, que estratégias, que recursos, que voltas o leitor dá para atribuir um significado ao texto.

A leitura é um processo descendente; desce do leitor ao texto. A compreensão começa com o estabelecimento do tópico, sugerido no primeiro contato com o texto, ainda em termos gerais. Usando os traços mais salientes da pagina a ser lida – título, gráficos, ilustrações, nome do autor, etc. – o leitor levanta uma série de hipóteses e começa a testá-las, desde o nível do discurso até o nível grafofonêmico, passando pelos níveis sintático e lexicais.

A acepção da leitura como um ato de atribuição de significado também tem seus problemas. Teoricamente, parece haver um paradoxo quanto à quantidade de informação fornecida pelo texto, que pode ser a mais ou menos, mas dificilmente na quantidade certa.

Há informação a mais quando o texto parece oferecer mais do que o leitor precisa. Diz-se que o texto é redundante. Ler com eficiência neste caso é saber explorar a redundância do texto, processando apenas a informação necessária para confirmar ou rejeitar as hipóteses inicialmente levantadas.

Há informação a menos quando o texto é visto como uma seqüência de lacunas. Existe muito conhecimento comum entre o escritor e o leitor, e o escritor capitaliza em cima desse conhecimento no momento em que produz o texto, deixando muita coisa para ser preenchida pelo leitor. Ler é neste caso preencher essas lacunas deixadas pelo escritor.

Dentro dessa mesma concepção de leitura com atribuição de significado há portanto duas concepções antagônicas de texto. Há os que vêem o texto como uma fonte de redundâncias e os que o percebem cheio de lacunas. A cada uma dessas visões corresponde também uma visão diferente de leitura: um processo altamente seletivo quando a informação é redundante e extremamente construtivo quando a informação é truncada. Em ambos os casos o papel do leitor no entanto é mais ou menos o mesmo. Quer ele use apenas parte da informação fornecida pelo texto, quer ele preencha as lacunas deixadas pelo mesmo, a obtenção do significado se dá sempre por força de sua contribuição. Num caso o leitor contribui com aquilo que o texto não tem; no outro com aquilo que o texto já tem, preferindo no entanto usar sua contribuição pessoal em vez da informação redundante do texto.

O pressuposto de que o mesmo texto pode proporcionar uma leitura diferente em cada leitor e até de que o mesmo leitor não fará leituras idênticas de um mesmo texto, tem também levantado alguns problemas. Ainda que toda experiência com o texto que remete o leitor de algum modo a um determinado seguimento da realidade seja em principio limitar as possíveis interpretações de um determinado texto. Se alguém interpreta um poema satírico ao pé da letra, não deixa essencialmente de realizar um ato de leitura, de atribuir um significado ao texto, mas deixou de perceber que o que estava sendo refletido pelo texto não era a realidade, mas um reflexo do reflexo da realidade.

A ênfase na construção de sentido a partir do leitor pode exigir portanto que se defina o perfil desse leitor, em termos mais ou menos ideais. Nesse caso, pode executar o ato da leitura, o leitor precisa conhecer o jogo de espelhos que se interpõe entre ele e a realidade. Podemos dizer que o leitor precisa possuir, além da competência sintática, semântica e textual, uma competência específica da realidade histórico-social refletida pelo texto.

 

ü  Uma visão conciliatória

            Ao definirmos a leitura quer como um processo de extração de significado (ênfase no texto) quer como um processo de atribuição de significado (ênfase no leitor) encontramos, em ambos os casos, uma série de problemas mais ou menos intransponíveis. A complexidade do processo da leitura não permite que se fixe em apenas um de seus pólos, com exclusão do outro. Na verdade, não basta nem mesmo somar as contribuições do leitor e do texto. É preciso considerar também um terceiro elemento: o que acontece quando leitor e texto se encontram. Para compreender o ato da leitura temos que considerar então (a) o papel do leitor, (b) o papel do texto e (c) o processo de interação entre o leitor e o texto.

Para melhor explicar esse processo de interação entre leitor e texto, vamos fazer uma analogia entre o processo da leitura e uma reação química. Na leitura, como na química, para termos uma reação é necessário levar em conta não só os elementos envolvidos, mas também as condições necessárias para que a reação ocorra. O simples confronto do leitor com o texto não garante a eclosão de todos os acontecimentos que caracterizam o ato da leitura. A produção de uma nova substancia – no caso a compreensão – só ocorre se houver afinidade entre os elementos leitor e texto e se determinadas condições estiverem presentes.

O leitor precisa possuir, além das competências fundamentais para o ato da leitura, a intenção de ler. Essa intenção pode ser caracterizada como uma necessidade que precisa ser satisfeita, a busca de um equilíbrio interno ou a tentativa de colimação de um determinado objetivo em relação a um determinado texto.

Essa intencionalidade é característica exclusiva do ser humano. Uma maquina pode ser programada para resumir ou parafrasear um texto, detectar anomalias semânticas e até responder perguntas implícitas; seria difícil, no entanto, imaginar uma maquina que, espontaneamente, ficasse horas entretida com a leitura de um grande romance. A máquina não teria a intenção do lazer, como não teria intenção de obter informações da bolsa de valores ou de fazer uma leitura critica de um poema de Mallarmé.

Satisfeita essa condição básica de intencionalidade, inicia-se o processo complexo de interação entre o leito e o texto. A leitura é um processo feito de muitos processos, que ocorrem tanto simultânea como seqüencialmente; esses processos incluem desde habilidades de baixo nível, executadas de modo automático na leitura proficiente, até estratégias de alto nível, executadas de modo consciente.

O processo da leitura fluente pode ser representado por uma pirâmide, em cuja base estão as habilidades elementares, envolvendo subprocessos que ocorrem em grandes feixes, de modo rápido, simultâneo e abaixo do nível da consciência. Como esse processo ocorrem em feixes, fala-se, nesse nível de leitura, de um processamento em paralelo.

A leitura, mecanicamente, dá-se por fixações dos olhos em determinados segmentos do texto, que podem ser uma palavra ou um pequeno grupo de palavras. Ao que parece o leitor não processa a letra que compõem um determinado segmento de modo linear, da esquerda para a direita, mas de modo simultâneo. Também parece que as letras não são processadas integralmente, em todos os detalhes, mas apenas nos traços distintivos. O leito não tem na memória um molde para cada letra do alfabeto. Uma leitura feita pelo cotejo de cada letra com esse molde fixo seria extremamente complicada e ante econômica, já que seria necessário não um molde para cada letra do alfabeto, mas para cada tipo possível de letra (maiúscula, minúscula, negrito, itálico, todos os diferentes tipo usados em diferentes maquinas tipográficas e de escrever, sem falar nas diferentes caligrafias de cada pessoa).

ü  O leitor-aluno

Para realizar uma leitura profunda, atribuindo o máximo de sentido possível ao texto, é necessário possua não a intenção de ler, como outras habilidades, indispensáveis ao processo de relação com o texto. Ler não é apenas decodificar, mas pressupõe uma perfeita decodificação, além de capacidade de inferência, utilizando conhecimentos de mundo e toda sorte de conhecimentos prévios, na contextualização do tema abordado.

A boa formação de um leitor implica no desenvolvimento das habilidades citadas, ligadas incondicionalmente ao hábito da leitura, não apenas como atividade em sala de aula ou em tarefas relacionadas, mas como parte integrante do dia-a-dia do leitor-aluno. Entretanto a escola tem papel preponderante nesse aspecto, devendo contribuir para que esse hábito se desenvolva.

 

Fonte: http://www.unicaieiras.com.br/revista/artigos.html