Разбор ассемблерного кода сишной программы Опции

[Neonig]

Здравствуйте.
Дана программа на Си (далее), потом она откомпилирована на ICC без оптимизации и с выдачей ассемблерного кода... кода тоже следует далее... вот задания которые нужно выполнить..прошу псмтреть и помочь...

Для тестовой программы (из первой лабораторной работы) сгенерировать ассемблерные листинги при компиляции с различными уровнями оптимизации. В программе использовать тип данных float. В каждом ассемблерном листинге:

1. Распознать вычислительную функцию, сопоставить команды языка Си с командами ассемблера.

2. Локализовать обращения в память, которые происходят при выполнении вычислительной функции. Определить позиции в исходной программе на Си, в которых происходят обращения в память. Посчитать общее число обращений в память при выполнении вычислительной функции (в зависимости от параметра задачи).

3. Определить, какие переменные и параметры вычислительной функции отображены на регистры, и какие размещены в памяти. Какие регистры используются для реализации вычислений (регистры общего назначения, регистры x87, MMX, XMM).

4. Описать видимые изменения в ассемблерном коде программы при переходе от одного уровня оптимизации к другому. Описать какие оптимизационные преобразования выполнил компилятор.

#include <stdio.h>
#include <stdlib.h>
#define N 1000
int Sort(int n)
{
	int i, j;
	int tmp;
		float* mas;
	mas = (int *)malloc(sizeof(int)*1000000);
	
	for(i = 0; i < n; i++) 
		{ 
			mas[i] = rand();
		}
		for(i = 0; i < n-1; i++) 
		{ 
			for(j = 0; j < n - i -1; j++) 
				{		
					if(mas[j] > mas[j+1]) 
						{		   
							tmp = mas[j];
							mas[j] = mas[j+1];
							mas[j+1] = tmp; 
						}
				}
		}
	i = 0;
	for(i = 0; i < n; i++) 
		printf("%10.2f ", mas[i]);
		
	return 0;
}
int main(void) 
{
	int n = 0;
	 n = 50000;
	Sort(n);
	return 0;
}

# -- Begin  Sort			// начало функции Sort сортировки масива 
# mark_begin;
  align 4, 0x90			// деректива выравнивания, которая показывет, что
				//  следующие команды должны быть вровнены по 4 м байтам
.globl Sort
Sort:
# parameter 1: 8 + %ebx		// параметры передаются через стек, адрес вершины которого находится
				// на регистре общего назначени esp. Для размещения локальных переменных 
				// воспользуемся кадром, на который указывает ebx

..B1.1:				# Preds ..B1.0

	pushl %ebx		#5.1 // сохраняем указатель кадра вызывавшей программы
	movl %esp, %ebx		#5.1 // формируем указатель нашего кадра, т.е. формируем начало кадра локальных переменных
	andl $-8, %esp		#5.1
	pushl %ebp		#5.1
	pushl %ebp		#5.1 // поместить значения с регистра ОН ebp в стек (связываем кадр со стеком)
	movl 4(%ebx), %ebp	#5.1 // выделям место, наверное для одной из меременых типа int,
	movl  %ebp, 4(%esp)	#5.1 // работаем с кадром  находящимся в esp, смещаемся на 4 "единицы" и
				// заносим туда значение с регистра ebp, т.е. начало кадра локальных
				// переменных занесенного  в ebp со смещением на 4 единицы
	movl %esp, %ebp		#5.1 // запоминаем состояние esp в регистре ebp
	subl $48, %esp		#5.1 // выделяем 48 байт в кадре
	movl %esi, -20(%ebp)	#5.1 // выделяется место под локальные переменные - 20 байт, путём смещения
				// указателя  регистра ebp и записи  туда значения регистра общего
				// назначения esi
	pushl %edi		#9.17 // пользуемся ещё одним регистром общего назначения
	movl $4000000, (%esp)	#9.17 // кладем на регистр ebp значение 4 000 000, видимо речь идет
				// о выделении памяти. Действительно, выделяем 1 000 000
				// умноженный на  sizeof(int) равный 4м. Итого 4 000 000
	call malloc		#9.17 // вызов функции malloc, выделения памяти
# LOE eax
..B1.21:				# Preds ..B1.1
	addl $4, %esp		#9.17 // esp = esp + 4
	movl %eax, -48(%ebp)	#9.17
# LOE
..B1.2:				# Preds ..B1.21
	movl -48(%ebp), %eax	#9.2
	movl %eax, -16(%ebp)	#9.2
	movl $0, -12(%ebp)		#11.6
	movl -12(%ebp), %eax	#11.14
	movl 8(%ebx), %edx		#11.18
	cmpl %edx, %eax		#11.2
	jge ..B1.6			# Prob 50%  #11.2
# LOE
..B1.4:				# Preds ..B1.2 ..B1.5
	call rand			#13.13  // вызываем функцию rand генерации случайных чисел
# LOE eax
..B1.22:				# Preds ..B1.4
	movl %eax, -44(%ebp)	#13.13
# LOE
..B1.5:				# Preds ..B1.22
	movl -44(%ebp), %eax	#13.13
	movl %eax, -40(%ebp)	#13.13
	fildl -40(%ebp)		#13.13
	movl -12(%ebp), %eax	#13.8
	movl -16(%ebp), %edx	#13.4
	fstps (%edx,%eax,4)		#13.4
	incl  -12(%ebp)		#11.21
	movl -12(%ebp), %eax	#11.14
	movl 8(%ebx), %edx		#11.18
	cmpl %edx, %eax		#11.2
	jl ..B1.4			# Prob 50% #11.2
# LOE
..B1.6:				# Preds ..B1.5 ..B1.2
	movl $0, -12(%ebp)		#15.13
	movl 8(%ebx), %eax		#15.24
	decl %eax		#15.24
	movl -12(%ebp), %edx	#15.20
	cmpl %eax, %edx		#15.9
	jl ..B1.9			# Prob 50% #15.9
	jmp ..B1.14		# Prob 100% #15.9
# LOE
..B1.7:				# Preds ..B1.10 ..B1.9
	incl -12(%ebp)		#15.30
	movl 8(%ebx), %eax		#15.24
	decl %eax		#15.24
	movl -12(%ebp), %edx	#15.20
	cmpl %eax, %edx		#15.9
	jge ..B1.14		# Prob 50% #15.9
# LOE
..B1.9:				# Preds ..B1.6 ..B1.7
	movl $0, -8(%ebp)		#17.8
	movl -12(%ebp), %eax	#17.24
	negl %eax		#17.24
	movl 8(%ebx), %edx		#17.20
	lea  -1(%edx,%eax), %eax	#17.24
	movl -8(%ebp), %edx	#17.16
	cmpl %eax, %edx		#17.4
	jl ..B1.12			# Prob 50% #17.4
	jmp ..B1.7			# Prob 100% #17.4
# LOE
..B1.10:				# Preds ..B1.13 ..B1.12
	incl -8(%ebp)		#17.31
	movl -12(%ebp), %eax	#17.24
	negl %eax		#17.24
	movl 8(%ebx), %edx		#17.20
	lea  -1(%edx,%eax), %eax	#17.24
	movl -8(%ebp), %edx	#17.16
	cmpl %eax, %edx		#17.4
	jge ..B1.7			# Prob 50% #17.4
# LOE
..B1.12:				# Preds ..B1.9 ..B1.10
	movl -8(%ebp), %eax	#19.13
	movl -16(%ebp), %edx	#19.9
	movl -8(%ebp), %ecx	#19.22
	movl -16(%ebp), %esi	#19.18
	flds (%edx,%eax,4)		#19.9
	flds 4(%esi,%ecx,4)		#19.18
	fcompp			#19.6
	fnstsw %ax		#19.6
	sahf			#19.6
	jp ..B1.10			# Prob 0% #19.6
	jb ..B1.13			# Prob 50% #19.6
	jmp ..B1.10		# Prob 100% #19.6
# LOE
..B1.13:				# Preds ..B1.12
	movl -8(%ebp), %eax	#21.18
	movl -16(%ebp), %edx	#21.14
	flds (%edx,%eax,4)		#21.14
	fnstcw -32(%ebp)		#21.14
	movl %eax, -28(%ebp)	#21.14
	movzwl -32(%ebp), %eax	#21.14
	orl $3072, %eax		#21.14
	movl %eax, -24(%ebp)	#21.14
	movl -28(%ebp), %eax	#21.14
	fldcw -24(%ebp)		#21.14
	fistpl -4(%ebp)		#21.14
	fldcw -32(%ebp)		#21.14
	movl -8(%ebp), %eax	#22.21
	movl -16(%ebp), %edx	#22.17
	movl -8(%ebp), %ecx	#22.12
	movl -16(%ebp), %esi	#22.8
	flds 4(%edx,%eax,4)		#22.17
	fstps (%esi,%ecx,4)		#22.8
	movl -4(%ebp), %eax	#23.19
	movl %eax, -40(%ebp)	#23.19
	fildl -40(%ebp)		#23.19
	movl -8(%ebp), %eax	#23.12
	movl -16(%ebp), %edx	#23.8
	fstps 4(%edx,%eax,4)	#23.8
	jmp ..B1.10		# Prob 100% #23.8
# LOE
..B1.14:				# Preds ..B1.7 ..B1.6
	xorl %eax, %eax		#27.2
	movl %eax, -12(%ebp)	#27.2
	movl %eax, -12(%ebp)	#28.6
	movl -12(%ebp), %eax	#28.13
	movl 8(%ebx), %edx		#28.17
	cmpl %edx, %eax		#28.2
	jge ..B1.18		# Prob 50% #28.2
# LOE
..B1.16				# Preds ..B1.14 ..B1.17
	addl $-12, %esp		#29.21
	movl $__STRING.0, (%esp)	#29.21
	movl -12(%ebp), %eax	#29.25
	movl -16(%ebp), %edx	#29.21
	flds (%edx,%eax,4)		#29.21
	fstpl 4(%esp)		#29.21
	call printf			#29.21
# LOE
..B1.23:				# Preds ..B1.16
	addl $12, %esp		#29.21
# LOE
..B1.17:				# Preds ..B1.23
	incl -12(%ebp)		#28.20
	movl -12(%ebp), %eax	#28.13
	movl 8(%ebx), %edx		#28.17
	cmpl %edx, %eax		#28.2
	jl ..B1.16	   # Prob 50%	#28.2
# LOE
..B1.18:				# Preds ..B1.17 ..B1.14
	xorl %eax, %eax		#31.2
	movl -20(%ebp), %esi	#31.2
	leave			#31.2
	movl %ebx, %esp		#31.2
	popl %ebx		#31.2
	ret			#31.2
	.align 4,0x90
# LOE
# mark_end;
	.type Sort,@function
	.size Sort,.-Sort
	.data
# -- End  Sort