From bdf60ebbeb433a80e6cfcbde9d83d89564e79e20 Mon Sep 17 00:00:00 2001
From: Joe Slater <jslater@windriver.com>
Date: Mon, 26 Aug 2013 23:38:45 +0000
Subject: [PATCH] dpkg: fix configuration issue for mips64

configure cannot determine the proper cpu, os, or
architecture for mips64, and possibly other arch's
because of faulty code added to Arch.pm in the latest
release from upstream.  We remove that code.

Upstream-Status: Pending

Signed-off-by: Joe Slater <jslater@windriver.com>
---
 scripts/Dpkg/Arch.pm | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/scripts/Dpkg/Arch.pm b/scripts/Dpkg/Arch.pm
index 0d352eeb9..4ef5fa307 100644
--- a/scripts/Dpkg/Arch.pm
+++ b/scripts/Dpkg/Arch.pm
@@ -326,9 +326,6 @@ sub _load_tupletable()
 		    (my $dt = $debtuple) =~ s/<cpu>/$_cpu/;
 		    (my $da = $debarch) =~ s/<cpu>/$_cpu/;
 
-		    next if exists $debarch_to_debtuple{$da}
-		         or exists $debtuple_to_debarch{$dt};
-
 		    $debarch_to_debtuple{$da} = $dt;
 		    $debtuple_to_debarch{$dt} = $da;
 		}
