Skip to content
This repository has been archived by the owner on Jan 23, 2023. It is now read-only.

Commit

Permalink
Delete legacy code
Browse files Browse the repository at this point in the history
  • Loading branch information
@mikedn
mikedn committed May 22, 2018
1 parent 051e923 commit cbe6d7e
Show file tree
Hide file tree
Showing 3 changed files with 0 additions and 165 deletions.
6 changes: 0 additions & 6 deletions src/jit/codegen.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -95,12 +95,6 @@ class CodeGen : public CodeGenInterface
}
}

#ifdef LEGACY_BACKEND
enum CompareKind{CK_SIGNED, CK_UNSIGNED, CK_LOGICAL};

static emitJumpKind genJumpKindForOper(genTreeOps cmp, CompareKind compareKind);
#endif // LEGACY_BACKEND

static bool genShouldRoundFP();

GenTreeIndir indirForm(var_types type, GenTree* base);
Expand Down
153 changes: 0 additions & 153 deletions src/jit/codegencommon.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -1745,159 +1745,6 @@ bool CodeGen::genCreateAddrMode(GenTree* addr,
return true;
}

#ifdef LEGACY_BACKEND
/*****************************************************************************
* The condition to use for (the jmp/set for) the given type of operation
*
* In case of amd64, this routine should be used when there is no gentree available
* and one needs to generate jumps based on integer comparisons. When gentree is
* available always use its overloaded version.
*
*/

// static
emitJumpKind CodeGen::genJumpKindForOper(genTreeOps cmp, CompareKind compareKind)
{
const static BYTE genJCCinsSigned[] = {
#if defined(_TARGET_XARCH_)
EJ_je, // GT_EQ
EJ_jne, // GT_NE
EJ_jl, // GT_LT
EJ_jle, // GT_LE
EJ_jge, // GT_GE
EJ_jg, // GT_GT
EJ_je, // GT_TEST_EQ
EJ_jne, // GT_TEST_NE
#elif defined(_TARGET_ARMARCH_)
EJ_eq, // GT_EQ
EJ_ne, // GT_NE
EJ_lt, // GT_LT
EJ_le, // GT_LE
EJ_ge, // GT_GE
EJ_gt, // GT_GT
#if defined(_TARGET_ARM64_)
EJ_eq, // GT_TEST_EQ
EJ_ne, // GT_TEST_NE
#endif
#endif
};

const static BYTE genJCCinsUnsigned[] = /* unsigned comparison */
{
#if defined(_TARGET_XARCH_)
EJ_je, // GT_EQ
EJ_jne, // GT_NE
EJ_jb, // GT_LT
EJ_jbe, // GT_LE
EJ_jae, // GT_GE
EJ_ja, // GT_GT
EJ_je, // GT_TEST_EQ
EJ_jne, // GT_TEST_NE
#elif defined(_TARGET_ARMARCH_)
EJ_eq, // GT_EQ
EJ_ne, // GT_NE
EJ_lo, // GT_LT
EJ_ls, // GT_LE
EJ_hs, // GT_GE
EJ_hi, // GT_GT
#if defined(_TARGET_ARM64_)
EJ_eq, // GT_TEST_EQ
EJ_ne, // GT_TEST_NE
#endif
#endif
};

const static BYTE genJCCinsLogical[] = /* logical operation */
{
#if defined(_TARGET_XARCH_)
EJ_je, // GT_EQ (Z == 1)
EJ_jne, // GT_NE (Z == 0)
EJ_js, // GT_LT (S == 1)
EJ_NONE, // GT_LE
EJ_jns, // GT_GE (S == 0)
EJ_NONE, // GT_GT
EJ_NONE, // GT_TEST_EQ
EJ_NONE, // GT_TEST_NE
#elif defined(_TARGET_ARMARCH_)
EJ_eq, // GT_EQ (Z == 1)
EJ_ne, // GT_NE (Z == 0)
EJ_mi, // GT_LT (N == 1)
EJ_NONE, // GT_LE
EJ_pl, // GT_GE (N == 0)
EJ_NONE, // GT_GT
#if defined(_TARGET_ARM64_)
EJ_eq, // GT_TEST_EQ
EJ_ne, // GT_TEST_NE
#endif
#endif
};

#if defined(_TARGET_XARCH_)
assert(genJCCinsSigned[GT_EQ - GT_EQ] == EJ_je);
assert(genJCCinsSigned[GT_NE - GT_EQ] == EJ_jne);
assert(genJCCinsSigned[GT_LT - GT_EQ] == EJ_jl);
assert(genJCCinsSigned[GT_LE - GT_EQ] == EJ_jle);
assert(genJCCinsSigned[GT_GE - GT_EQ] == EJ_jge);
assert(genJCCinsSigned[GT_GT - GT_EQ] == EJ_jg);
assert(genJCCinsSigned[GT_TEST_EQ - GT_EQ] == EJ_je);
assert(genJCCinsSigned[GT_TEST_NE - GT_EQ] == EJ_jne);

assert(genJCCinsUnsigned[GT_EQ - GT_EQ] == EJ_je);
assert(genJCCinsUnsigned[GT_NE - GT_EQ] == EJ_jne);
assert(genJCCinsUnsigned[GT_LT - GT_EQ] == EJ_jb);
assert(genJCCinsUnsigned[GT_LE - GT_EQ] == EJ_jbe);
assert(genJCCinsUnsigned[GT_GE - GT_EQ] == EJ_jae);
assert(genJCCinsUnsigned[GT_GT - GT_EQ] == EJ_ja);
assert(genJCCinsUnsigned[GT_TEST_EQ - GT_EQ] == EJ_je);
assert(genJCCinsUnsigned[GT_TEST_NE - GT_EQ] == EJ_jne);

assert(genJCCinsLogical[GT_EQ - GT_EQ] == EJ_je);
assert(genJCCinsLogical[GT_NE - GT_EQ] == EJ_jne);
assert(genJCCinsLogical[GT_LT - GT_EQ] == EJ_js);
assert(genJCCinsLogical[GT_GE - GT_EQ] == EJ_jns);
#elif defined(_TARGET_ARMARCH_)
assert(genJCCinsSigned[GT_EQ - GT_EQ] == EJ_eq);
assert(genJCCinsSigned[GT_NE - GT_EQ] == EJ_ne);
assert(genJCCinsSigned[GT_LT - GT_EQ] == EJ_lt);
assert(genJCCinsSigned[GT_LE - GT_EQ] == EJ_le);
assert(genJCCinsSigned[GT_GE - GT_EQ] == EJ_ge);
assert(genJCCinsSigned[GT_GT - GT_EQ] == EJ_gt);

assert(genJCCinsUnsigned[GT_EQ - GT_EQ] == EJ_eq);
assert(genJCCinsUnsigned[GT_NE - GT_EQ] == EJ_ne);
assert(genJCCinsUnsigned[GT_LT - GT_EQ] == EJ_lo);
assert(genJCCinsUnsigned[GT_LE - GT_EQ] == EJ_ls);
assert(genJCCinsUnsigned[GT_GE - GT_EQ] == EJ_hs);
assert(genJCCinsUnsigned[GT_GT - GT_EQ] == EJ_hi);

assert(genJCCinsLogical[GT_EQ - GT_EQ] == EJ_eq);
assert(genJCCinsLogical[GT_NE - GT_EQ] == EJ_ne);
assert(genJCCinsLogical[GT_LT - GT_EQ] == EJ_mi);
assert(genJCCinsLogical[GT_GE - GT_EQ] == EJ_pl);
#else
assert(!"unknown arch");
#endif
assert(GenTree::OperIsCompare(cmp));

emitJumpKind result = EJ_COUNT;

if (compareKind == CK_UNSIGNED)
{
result = (emitJumpKind)genJCCinsUnsigned[cmp - GT_EQ];
}
else if (compareKind == CK_SIGNED)
{
result = (emitJumpKind)genJCCinsSigned[cmp - GT_EQ];
}
else if (compareKind == CK_LOGICAL)
{
result = (emitJumpKind)genJCCinsLogical[cmp - GT_EQ];
}
assert(result != EJ_COUNT);
return result;
}
#endif // LEGACY_BACKEND

#ifdef _TARGET_ARMARCH_
//------------------------------------------------------------------------
// genEmitGSCookieCheck: Generate code to check that the GS cookie
Expand Down
6 changes: 0 additions & 6 deletions src/jit/gentree.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -5726,9 +5726,7 @@ struct GenCondition
static_assert((GT_LE - GT_EQ) == SLE, "bad relop");
static_assert((GT_GE - GT_EQ) == SGE, "bad relop");
static_assert((GT_GT - GT_EQ) == SGT, "bad relop");
#ifndef LEGACY_BACKEND
static_assert((GT_TEST_NE - GT_TEST_EQ) == (NE & ~Unsigned), "bad relop");
#endif

static GenCondition FromRelop(GenTree* relop)
{
Expand Down Expand Up @@ -5778,12 +5776,8 @@ struct GenCondition
{
assert(GenTree::OperIsCompare(oper));

#ifndef LEGACY_BACKEND
// GT_TEST_EQ/NE are special, they need to be mapped as GT_EQ/NE
unsigned code = oper - ((oper >= GT_TEST_EQ) ? GT_TEST_EQ : GT_EQ);
#else
unsigned code = oper - GT_EQ;
#endif

if (isUnsigned || (code <= 1)) // EQ/NE are treated as unsigned
{
Expand Down

0 comments on commit cbe6d7e

Please sign in to comment.