X-Git-Url: https://git.xonotic.org/?p=xonotic%2Fxonotic.git;a=blobdiff_plain;f=misc%2Ftools%2Fprogs-analyzer.pl;h=73863c682c8b2da27ba03a1d6aab739061f10b6f;hp=7037c8a03a76387d0b28a1dd19de93d70376caee;hb=ef3dce861aa876b7c2949528c45181731bbc72b8;hpb=a7012bfde8762a50913d41c4b656adc07004cb65

diff --git a/misc/tools/progs-analyzer.pl b/misc/tools/progs-analyzer.pl
old mode 100644
new mode 100755
index 7037c8a0..73863c68
--- a/misc/tools/progs-analyzer.pl
+++ b/misc/tools/progs-analyzer.pl
@@ -1,3 +1,5 @@
+#!/usr/bin/perl
+
 use strict;
 use warnings;
 use Digest::SHA;
@@ -125,6 +127,10 @@ sub checkop($)
 	{
 		return { a => 'inglobal', b => 'inglobalfunc' };
 	}
+	if($op =~ /^INVALID#/)
+	{
+		return { isinvalid => 1 };
+	}
 	return { a => 'inglobal', b => 'inglobal', c => 'outglobal' };
 }
 
@@ -185,6 +191,19 @@ use constant DFUNCTION_T => [
 	[uchar8 => 'parm_size'],
 ];
 
+use constant LNOHEADER_T => [
+	[int => 'lnotype'],
+	[int => 'version'],
+	[int => 'numglobaldefs'],
+	[int => 'numglobals'],
+	[int => 'numfielddefs'],
+	[int => 'numstatements'],
+];
+
+use constant LNO_T => [
+	[int => 'v'],
+];
+
 sub get_section($$$)
 {
 	my ($fh, $start, $len) = @_;
@@ -279,7 +298,7 @@ sub run_nfa($$$$$$)
 				my $func = $s->{a};
 				my $funcid = $progs->{globals}[$func]{v}{int};
 				last
-					if $progs->{error_func}{$funcid};
+					if $progs->{builtins}{error}{$funcid};
 				$ip += 1;
 			}
 			elsif($c->{isjump})
@@ -317,28 +336,32 @@ sub run_nfa($$$$$$)
 	$nfa->($ip, $copy_handler->($state));
 }
 
-sub get_constant($$)
+sub get_constant($$$)
 {
-	my ($progs, $g) = @_;
-	if($g->{int} == 0)
-	{
-		return 0;
-	}
-	elsif($g->{int} > 0 && $g->{int} < 8388608)
-	{
-		if($g->{int} < length $progs->{strings} && $g->{int} > 0)
-		{
-			return str($progs->{getstring}->($g->{int}));
-		}
-		else
-		{
-			return $g->{int} . "i";
-		}
-	}
-	else
-	{
-		return $g->{float};
+	my ($progs, $g, $type) = @_;
+
+	if (!defined $type) {
+		$type = 'float';
+		$type = 'int'
+			if $g->{int} > 0 && $g->{int} < 8388608;
+		$type = 'string'
+			if $g->{int} > 0 && $g->{int} < length $progs->{strings};
 	}
+
+	return str($progs->{getstring}->($g->{int}))
+		if $type eq 'string';
+	return $g->{float}
+		if $type eq 'float';
+	return "'$g->{float} _ _'"
+		if $type eq 'vector';
+	return "entity $g->{int}"
+		if $type eq 'entity';
+	return ".$progs->{entityfieldnames}[$g->{int}]"
+		if $type eq 'field' and defined $progs->{entityfieldnames}[$g->{int}];
+	return "$g->{int}i"
+		if $type eq 'int';
+
+	return "$type($g->{int})";
 }
 
 use constant PRE_MARK_STATEMENT => "";
@@ -358,6 +381,20 @@ sub str($)
 	return "\"$str\"";
 }
 
+sub debugpos($$$) {
+	my ($progs, $func, $ip) = @_;
+	my $s = $func->{debugname};
+	if ($progs->{cno}) {
+		my $column = $progs->{cno}[$ip]{v};
+		$s =~ s/:/:$column:/;
+	}
+	if ($progs->{lno}) {
+		my $line = $progs->{lno}[$ip]{v};
+		$s =~ s/:/:$line:/;
+	}
+	return $s;
+}
+
 sub disassemble_function($$;$)
 {
 	my ($progs, $func, $highlight) = @_;
@@ -375,7 +412,8 @@ sub disassemble_function($$;$)
 	my $initializer = sub
 	{
 		my ($ofs) = @_;
-		my $g = get_constant($progs, $progs->{globals}[$ofs]{v});
+		# TODO: Can we know its type?
+		my $g = get_constant($progs, $progs->{globals}[$ofs]{v}, undef);
 		print " = $g"
 			if defined $g;
 	};
@@ -505,7 +543,8 @@ sub disassemble_function($$;$)
 				{
 					print PRE_MARK_STATEMENT;
 					printf INSTRUCTION_FORMAT, '', '<!>', '.WARN';
-					printf OPERAND_FORMAT, "$_ (in $func->{debugname})";
+					my $pos = debugpos $progs, $func, $ip;
+					printf OPERAND_FORMAT, "$_ (in $pos)";
 					print INSTRUCTION_SEPARATOR;
 				}
 			}
@@ -673,6 +712,10 @@ sub find_uninitialized_locals($$)
 				}
 			}
 
+			if($c->{isinvalid})
+			{
+				++$warned{$ip}{''}{"Invalid opcode"};
+			}
 			for(qw(a b c))
 			{
 				my $type = $c->{$_};
@@ -898,7 +941,7 @@ sub detect_constants($)
 	use constant GLOBALFLAG_U => 64; # unused
 	use constant GLOBALFLAG_P => 128; # possibly parameter passing
 	use constant GLOBALFLAG_D => 256; # has a def
-	my @globalflags = (GLOBALFLAG_Q | GLOBALFLAG_U) x @{$progs->{globals}};
+	my @globalflags = (GLOBALFLAG_Q | GLOBALFLAG_U) x (@{$progs->{globals}} + 2);
 
 	for(@{$progs->{functions}})
 	{
@@ -977,7 +1020,7 @@ sub detect_constants($)
 		my $type = $_->{type};
 		my $name = $progs->{getstring}->($_->{s_name});
 		$name = ''
-			if $name eq 'IMMEDIATE' or $name =~ /^\./;
+			if $name eq 'IMMEDIATE'; # for fteqcc I had: or $name =~ /^\./;
 		$_->{debugname} = $name
 			if $name ne '';
 		$globalflags[$_->{ofs}] |= GLOBALFLAG_D;
@@ -1000,7 +1043,7 @@ sub detect_constants($)
 			# add missing def
 			if(!($globalflags[$_->{ofs}+$i] & GLOBALFLAG_D))
 			{
-				print "Missing globaldef for $_->{debugname}[$i] at $_->{ofs}\n";
+				print "Missing globaldef for a component@{[defined $_->{debugname} ? ' of ' . $_->{debugname} : '']} at $_->{ofs}+$i\n";
 				push @extradefs, {
 					type => {
 						saved => 0,
@@ -1127,7 +1170,7 @@ sub detect_constants($)
 		}
 		elsif($_->{globaltype} eq 'const')
 		{
-			$_->{debugname} = get_constant($progs, $progs->{globals}[$_->{ofs}]{v});
+			$_->{debugname} = get_constant($progs, $progs->{globals}[$_->{ofs}]{v}, $_->{type}{type});
 		}
 		else
 		{
@@ -1150,15 +1193,40 @@ sub detect_constants($)
 	};
 }
 
-sub parse_progs($)
+sub parse_progs($$)
 {
-	my ($fh) = @_;
+	my ($fh, $lnofh) = @_;
 
 	my %p = ();
 
 	print STDERR "Parsing header...\n";
 	$p{header} = parse_section $fh, DPROGRAMS_T, 0, undef, 1;
 	
+	if (defined $lnofh) {
+		print STDERR "Parsing LNO...\n";
+		my $lnoheader = parse_section $lnofh, LNOHEADER_T, 0, undef, 1;
+		eval {
+			die "Not a LNOF"
+				if $lnoheader->{lnotype} != unpack 'V', 'LNOF';
+			die "Not version 1"
+				if $lnoheader->{version} != 1;
+			die "Not same count of globaldefs"
+				if $lnoheader->{numglobaldefs} != $p{header}{numglobaldefs};
+			die "Not same count of globals"
+				if $lnoheader->{numglobals} != $p{header}{numglobals};
+			die "Not same count of fielddefs"
+				if $lnoheader->{numfielddefs} != $p{header}{numfielddefs};
+			die "Not same count of statements"
+				if $lnoheader->{numstatements} != $p{header}{numstatements};
+			$p{lno} = [parse_section $lnofh, LNO_T, 24, undef, $lnoheader->{numstatements}];
+			eval {
+				$p{lno} = [parse_section $lnofh, LNO_T, 24, undef, $lnoheader->{numstatements} * 2];
+				$p{cno} = [splice $p{lno}, $lnoheader->{numstatements}];
+				print STDERR "Cool, this LNO even has column number info!\n";
+			};
+		} or warn "Skipping LNO: $@";
+	}
+
 	print STDERR "Parsing strings...\n";
 	$p{strings} = get_section $fh, $p{header}{ofs_strings}, $p{header}{numstrings};
 	$p{getstring} = sub
@@ -1181,7 +1249,7 @@ sub parse_progs($)
 		die "Out of range name in globaldef $_"
 			if $g->{s_name} < 0 || $g->{s_name} >= length $p{strings};
 		my $name = $p{getstring}->($g->{s_name});
-		die "Out of range ofs in globaldef $_ (name: \"$name\")"
+		die "Out of range ofs $g->{ofs} in globaldef $_ (name: \"$name\")"
 			if $g->{ofs} >= $p{globals};
 	}
 
@@ -1195,8 +1263,11 @@ sub parse_progs($)
 		die "Out of range name in fielddef $_"
 			if $g->{s_name} < 0 || $g->{s_name} >= length $p{strings};
 		my $name = $p{getstring}->($g->{s_name});
-		die "Out of range ofs in globaldef $_ (name: \"$name\")"
+		die "Out of range ofs $g->{ofs} in fielddef $_ (name: \"$name\")"
 			if $g->{ofs} >= $p{header}{entityfields};
+		#warn "Duplicate fielddef for ofs $g->{ofs} in fielddef $_ (name: \"$name\")"
+		#	if exists $p{entityfieldnames}[$g->{ofs}];
+		$p{entityfieldnames}[$g->{ofs}] = $name;
 	}
 
 	print STDERR "Parsing statements...\n";
@@ -1217,12 +1288,12 @@ sub parse_progs($)
 		my $file = $p{getstring}->($f->{s_file});
 		die "Out of range first_statement in function $_ (name: \"$name\", file: \"$file\", first statement: $f->{first_statement})"
 			if $f->{first_statement} >= @{$p{statements}};
-		die "Out of range parm_start in function $_ (name: \"$name\", file: \"$file\", first statement: $f->{first_statement})"
-			if $f->{parm_start} < 0 || $f->{parm_start} >= @{$p{globals}};
-		die "Out of range locals in function $_ (name: \"$name\", file: \"$file\", first statement: $f->{first_statement})"
-			if $f->{locals} < 0 || $f->{parm_start} + $f->{locals} >= @{$p{globals}};
 		if($f->{first_statement} >= 0)
 		{
+			die "Out of range parm_start in function $_ (name: \"$name\", file: \"$file\", first statement: $f->{first_statement})"
+				if $f->{parm_start} < 0 || $f->{parm_start} >= @{$p{globals}};
+			die "Out of range locals in function $_ (name: \"$name\", file: \"$file\", first statement: $f->{first_statement})"
+				if $f->{locals} < 0 || $f->{parm_start} + $f->{locals} > @{$p{globals}};
 			die "Out of range numparms $f->{numparms} in function $_ (name: \"$name\", file: \"$file\", first statement: $f->{first_statement})"
 				if $f->{numparms} < 0 || $f->{numparms} > 8;
 			my $totalparms = 0;
@@ -1233,7 +1304,9 @@ sub parse_progs($)
 				$totalparms += $f->{parm_size}[$_];
 			}
 			die "Out of range parms in function $_ (name: \"$name\", file: \"$file\", first statement: $f->{first_statement})"
-				if $f->{locals} < 0 || $f->{parm_start} + $totalparms >= @{$p{globals}};
+				if $f->{parm_start} + $totalparms > @{$p{globals}};
+			die "More parms than locals in function $_ (name: \"$name\", file: \"$file\", first statement: $f->{first_statement})"
+				if $totalparms > $f->{locals};
 		}
 	}
 
@@ -1258,8 +1331,18 @@ sub parse_progs($)
 			elsif($type eq 'inglobalvec')
 			{
 				$s->{$_} &= 0xFFFF;
-				die "Out of range global offset in statement $ip - cannot continue"
-					if $s->{$_} >= @{$p{globals}}-2;
+				if($c->{isreturn})
+				{
+					die "Out of range global offset in statement $ip - cannot continue"
+						if $s->{$_} >= @{$p{globals}};
+					print "Potentially out of range global offset in statement $ip - may crash engines"
+						if $s->{$_} >= @{$p{globals}}-2;
+				}
+				else
+				{
+					die "Out of range global offset in statement $ip - cannot continue"
+						if $s->{$_} >= @{$p{globals}}-2;
+				}
 			}
 			elsif($type eq 'outglobal')
 			{
@@ -1281,20 +1364,21 @@ sub parse_progs($)
 		}
 	}
 
-	print STDERR "Looking for error()...\n";
-	$p{error_func} = {};
+	print STDERR "Looking for error(), setmodel(), setsize()...\n";
+	$p{builtins} = { error => {}, setmodel => {}, setsize => {} };
 	for(@{$p{globaldefs}})
 	{
+		my $name = $p{getstring}($_->{s_name});
 		next
-			if $p{getstring}($_->{s_name}) ne 'error';
+			if not exists $p{builtins}{$name};
 		my $v = $p{globals}[$_->{ofs}]{v}{int};
 		next
 			if $v <= 0 || $v >= @{$p{functions}};
 		my $first = $p{functions}[$v]{first_statement};
 		next
 			if $first >= 0;
-		print STDERR "Detected error() at offset $_->{ofs} (builtin #@{[-$first]})\n";
-		$p{error_func}{$_->{ofs}} = 1;
+		print STDERR "Detected $name() at offset $_->{ofs} (builtin #@{[-$first]})\n";
+		$p{builtins}{$name}{$_->{ofs}} = 1;
 	}
 
 	print STDERR "Scanning functions...\n";
@@ -1408,5 +1492,15 @@ sub parse_progs($)
 	}
 }
 
-open my $fh, '<', $ARGV[0];
-parse_progs $fh;
+for my $progs (@ARGV) {
+	my $lno = "$progs.lno";
+	$lno =~ s/\.dat\.lno$/.lno/;
+
+	open my $fh, '<', $progs
+		or die "$progs: $!";
+
+	open my $lnofh, '<', $lno
+		or warn "$lno: $!";
+
+	parse_progs $fh, $lnofh;
+}