ShuriZma
/
xenia-canary
mirror of https://github.com/xenia-canary/xenia-canary.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Moving some util types into poly.

This commit is contained in:
Ben Vanik 2015-03-22 22:12:37 -07:00
parent b392afbfae
commit 59395318f3
54 changed files with 280 additions and 242 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/alloy/backend/x64/x64_assembler.cc
View File

@ -9,13 +9,13 @@
#include "alloy/backend/x64/x64_assembler.h"
#include "alloy/reset_scope.h"
#include "alloy/backend/x64/x64_backend.h"
#include "alloy/backend/x64/x64_emitter.h"
#include "alloy/backend/x64/x64_function.h"
#include "alloy/hir/hir_builder.h"
#include "alloy/hir/label.h"
#include "alloy/runtime/runtime.h"
#include "poly/reset_scope.h"
#include "xenia/profiling.h"
namespace BE {
@ -67,7 +67,7 @@ int X64Assembler::Assemble(FunctionInfo* symbol_info, HIRBuilder* builder,
SCOPE_profile_cpu_f("alloy");
// Reset when we leave.
make_reset_scope(this);
poly::make_reset_scope(this);
// Lower HIR -> x64.
void* machine_code = 0;
@ -97,7 +97,7 @@ int X64Assembler::Assemble(FunctionInfo* symbol_info, HIRBuilder* builder,
}
void X64Assembler::DumpMachineCode(DebugInfo* debug_info, void* machine_code,
size_t code_size, StringBuffer* str) {
size_t code_size, poly::StringBuffer* str) {
BE::DISASM disasm = {0};
disasm.Archi = 64;
disasm.Options = BE::Tabulation + BE::MasmSyntax + BE::PrefixedNumeral;

6
src/alloy/backend/x64/x64_assembler.h
View File

@ -13,7 +13,7 @@
#include <memory>
#include "alloy/backend/assembler.h"
#include "alloy/string_buffer.h"
#include "poly/string_buffer.h"
namespace alloy {
namespace backend {
@ -39,14 +39,14 @@ class X64Assembler : public Assembler {
private:
void DumpMachineCode(runtime::DebugInfo* debug_info, void* machine_code,
size_t code_size, StringBuffer* str);
size_t code_size, poly::StringBuffer* str);
private:
X64Backend* x64_backend_;
std::unique_ptr<X64Emitter> emitter_;
std::unique_ptr<XbyakAllocator> allocator_;
StringBuffer string_buffer_;
poly::StringBuffer string_buffer_;
};
} // namespace x64

5
src/alloy/backend/x64/x64_emitter.cc
View File

@ -20,6 +20,7 @@
#include "alloy/runtime/runtime.h"
#include "alloy/runtime/symbol_info.h"
#include "alloy/runtime/thread_state.h"
#include "poly/vec128.h"
#include "xdb/protocol.h"
#include "xenia/profiling.h"
@ -31,6 +32,10 @@ namespace x64 {
using namespace alloy::hir;
using namespace alloy::runtime;
using poly::vec128b;
using poly::vec128f;
using poly::vec128i;
using namespace Xbyak;
using alloy::hir::HIRBuilder;
using alloy::hir::Instr;

5
src/alloy/backend/x64/x64_emitter.h
View File

@ -11,6 +11,7 @@
#define ALLOY_BACKEND_X64_X64_EMITTER_H_
#include "alloy/hir/value.h"
#include "poly/arena.h"
#include "third_party/xbyak/xbyak/xbyak.h"
namespace alloy {
@ -30,6 +31,8 @@ namespace alloy {
namespace backend {
namespace x64 {
using vec128_t = poly::vec128_t;
class X64Backend;
class X64CodeCache;
@ -193,7 +196,7 @@ class X64Emitter : public Xbyak::CodeGenerator {
hir::Instr* current_instr_;
size_t source_map_count_;
Arena source_map_arena_;
poly::Arena source_map_arena_;
size_t stack_size_;

2
src/alloy/backend/x64/x64_sequences.cc
View File

@ -39,6 +39,8 @@ using namespace Xbyak;
using namespace alloy::hir;
using namespace alloy::runtime;
using poly::vec128b;
typedef bool (*SequenceSelectFn)(X64Emitter&, const Instr*, const Instr**);
std::unordered_multimap<uint32_t, SequenceSelectFn> sequence_table;

5
src/alloy/compiler/compiler.h
View File

@ -14,6 +14,7 @@
#include <vector>
#include "alloy/hir/hir_builder.h"
#include "poly/arena.h"
namespace alloy {
namespace runtime {
@ -32,7 +33,7 @@ class Compiler {
~Compiler();
runtime::Runtime* runtime() const { return runtime_; }
Arena* scratch_arena() { return &scratch_arena_; }
poly::Arena* scratch_arena() { return &scratch_arena_; }
void AddPass(std::unique_ptr<CompilerPass> pass);
@ -42,7 +43,7 @@ class Compiler {
private:
runtime::Runtime* runtime_;
Arena scratch_arena_;
poly::Arena scratch_arena_;
std::vector<std::unique_ptr<CompilerPass>> passes_;
};

2
src/alloy/compiler/compiler_pass.cc
View File

@ -24,7 +24,7 @@ int CompilerPass::Initialize(Compiler* compiler) {
return 0;
}
Arena* CompilerPass::scratch_arena() const {
poly::Arena* CompilerPass::scratch_arena() const {
return compiler_->scratch_arena();
}

3
src/alloy/compiler/compiler_pass.h
View File

@ -11,6 +11,7 @@
#define ALLOY_COMPILER_COMPILER_PASS_H_
#include "alloy/hir/hir_builder.h"
#include "poly/arena.h"
namespace alloy {
namespace runtime {
@ -33,7 +34,7 @@ class CompilerPass {
virtual int Run(hir::HIRBuilder* builder) = 0;
protected:
Arena* scratch_arena() const;
poly::Arena* scratch_arena() const;
protected:
runtime::Runtime* runtime_;

4
src/alloy/frontend/ppc/ppc_context.h
View File

@ -10,8 +10,8 @@
#ifndef ALLOY_FRONTEND_PPC_PPC_CONTEXT_H_
#define ALLOY_FRONTEND_PPC_PPC_CONTEXT_H_
#include "alloy/vec128.h"
#include "poly/poly.h"
#include "poly/vec128.h"
namespace alloy { namespace runtime {
class Runtime;
@ -22,7 +22,7 @@ namespace alloy {
namespace frontend {
namespace ppc {
using vec128_t = alloy::vec128_t;
using vec128_t = poly::vec128_t;
// Map:
// 0-31: GPR

134
src/alloy/frontend/ppc/ppc_disasm.cc
View File

@ -10,61 +10,61 @@
#include "alloy/frontend/ppc/ppc_disasm.h"
#include "poly/poly.h"
#include "alloy/string_buffer.h"
#include "poly/string_buffer.h"
namespace alloy {
namespace frontend {
namespace ppc {
void Disasm_0(InstrData& i, StringBuffer* str) {
void Disasm_0(InstrData& i, poly::StringBuffer* str) {
str->Append("%-8s ???", i.type->name);
}
void Disasm__(InstrData& i, StringBuffer* str) {
void Disasm__(InstrData& i, poly::StringBuffer* str) {
str->Append("%-8s", i.type->name);
}
void Disasm_X_FRT_FRB(InstrData& i, StringBuffer* str) {
void Disasm_X_FRT_FRB(InstrData& i, poly::StringBuffer* str) {
str->Append("%*s%s f%d, f%d", i.X.Rc ? -7 : -8, i.type->name,
i.X.Rc ? "." : "", i.X.RT, i.X.RB);
}
void Disasm_A_FRT_FRB(InstrData& i, StringBuffer* str) {
void Disasm_A_FRT_FRB(InstrData& i, poly::StringBuffer* str) {
str->Append("%*s%s f%d, f%d", i.A.Rc ? -7 : -8, i.type->name,
i.A.Rc ? "." : "", i.A.FRT, i.A.FRB);
}
void Disasm_A_FRT_FRA_FRB(InstrData& i, StringBuffer* str) {
void Disasm_A_FRT_FRA_FRB(InstrData& i, poly::StringBuffer* str) {
str->Append("%*s%s f%d, f%d, f%d", i.A.Rc ? -7 : -8, i.type->name,
i.A.Rc ? "." : "", i.A.FRT, i.A.FRA, i.A.FRB);
}
void Disasm_A_FRT_FRA_FRB_FRC(InstrData& i, StringBuffer* str) {
void Disasm_A_FRT_FRA_FRB_FRC(InstrData& i, poly::StringBuffer* str) {
str->Append("%*s%s f%d, f%d, f%d, f%d", i.A.Rc ? -7 : -8, i.type->name,
i.A.Rc ? "." : "", i.A.FRT, i.A.FRA, i.A.FRB, i.A.FRC);
}
void Disasm_X_RT_RA_RB(InstrData& i, StringBuffer* str) {
void Disasm_X_RT_RA_RB(InstrData& i, poly::StringBuffer* str) {
str->Append("%-8s r%d, r%d, r%d", i.type->name, i.X.RT, i.X.RA, i.X.RB);
}
void Disasm_X_RT_RA0_RB(InstrData& i, StringBuffer* str) {
void Disasm_X_RT_RA0_RB(InstrData& i, poly::StringBuffer* str) {
if (i.X.RA) {
str->Append("%-8s r%d, r%d, r%d", i.type->name, i.X.RT, i.X.RA, i.X.RB);
} else {
str->Append("%-8s r%d, 0, r%d", i.type->name, i.X.RT, i.X.RB);
}
}
void Disasm_X_FRT_RA_RB(InstrData& i, StringBuffer* str) {
void Disasm_X_FRT_RA_RB(InstrData& i, poly::StringBuffer* str) {
str->Append("%-8s f%d, r%d, r%d", i.type->name, i.X.RT, i.X.RA, i.X.RB);
}
void Disasm_X_FRT_RA0_RB(InstrData& i, StringBuffer* str) {
void Disasm_X_FRT_RA0_RB(InstrData& i, poly::StringBuffer* str) {
if (i.X.RA) {
str->Append("%-8s f%d, r%d, r%d", i.type->name, i.X.RT, i.X.RA, i.X.RB);
} else {
str->Append("%-8s f%d, 0, r%d", i.type->name, i.X.RT, i.X.RB);
}
}
void Disasm_D_RT_RA_I(InstrData& i, StringBuffer* str) {
void Disasm_D_RT_RA_I(InstrData& i, poly::StringBuffer* str) {
str->Append("%-8s r%d, r%d, %d", i.type->name, i.D.RT, i.D.RA,
(int32_t)(int16_t)XEEXTS16(i.D.DS));
}
void Disasm_D_RT_RA0_I(InstrData& i, StringBuffer* str) {
void Disasm_D_RT_RA0_I(InstrData& i, poly::StringBuffer* str) {
if (i.D.RA) {
str->Append("%-8s r%d, r%d, %d", i.type->name, i.D.RT, i.D.RA,
(int32_t)(int16_t)XEEXTS16(i.D.DS));
@ -73,11 +73,11 @@ void Disasm_D_RT_RA0_I(InstrData& i, StringBuffer* str) {
(int32_t)(int16_t)XEEXTS16(i.D.DS));
}
}
void Disasm_D_FRT_RA_I(InstrData& i, StringBuffer* str) {
void Disasm_D_FRT_RA_I(InstrData& i, poly::StringBuffer* str) {
str->Append("%-8s f%d, r%d, %d", i.type->name, i.D.RT, i.D.RA,
(int32_t)(int16_t)XEEXTS16(i.D.DS));
}
void Disasm_D_FRT_RA0_I(InstrData& i, StringBuffer* str) {
void Disasm_D_FRT_RA0_I(InstrData& i, poly::StringBuffer* str) {
if (i.D.RA) {
str->Append("%-8s f%d, r%d, %d", i.type->name, i.D.RT, i.D.RA,
(int32_t)(int16_t)XEEXTS16(i.D.DS));
@ -86,11 +86,11 @@ void Disasm_D_FRT_RA0_I(InstrData& i, StringBuffer* str) {
(int32_t)(int16_t)XEEXTS16(i.D.DS));
}
}
void Disasm_DS_RT_RA_I(InstrData& i, StringBuffer* str) {
void Disasm_DS_RT_RA_I(InstrData& i, poly::StringBuffer* str) {
str->Append("%-8s r%d, r%d, %d", i.type->name, i.DS.RT, i.DS.RA,
(int32_t)(int16_t)XEEXTS16(i.DS.DS << 2));
}
void Disasm_DS_RT_RA0_I(InstrData& i, StringBuffer* str) {
void Disasm_DS_RT_RA0_I(InstrData& i, poly::StringBuffer* str) {
if (i.DS.RA) {
str->Append("%-8s r%d, r%d, %d", i.type->name, i.DS.RT, i.DS.RA,
(int32_t)(int16_t)XEEXTS16(i.DS.DS << 2));
@ -99,29 +99,29 @@ void Disasm_DS_RT_RA0_I(InstrData& i, StringBuffer* str) {
(int32_t)(int16_t)XEEXTS16(i.DS.DS << 2));
}
}
void Disasm_D_RA(InstrData& i, StringBuffer* str) {
void Disasm_D_RA(InstrData& i, poly::StringBuffer* str) {
str->Append("%-8s r%d", i.type->name, i.D.RA);
}
void Disasm_X_RA_RB(InstrData& i, StringBuffer* str) {
void Disasm_X_RA_RB(InstrData& i, poly::StringBuffer* str) {
str->Append("%-8s r%d, r%d", i.type->name, i.X.RA, i.X.RB);
}
void Disasm_XO_RT_RA_RB(InstrData& i, StringBuffer* str) {
void Disasm_XO_RT_RA_RB(InstrData& i, poly::StringBuffer* str) {
str->Append("%*s%s%s r%d, r%d, r%d", i.XO.Rc ? -7 : -8, i.type->name,
i.XO.OE ? "o" : "", i.XO.Rc ? "." : "", i.XO.RT, i.XO.RA,
i.XO.RB);
}
void Disasm_XO_RT_RA(InstrData& i, StringBuffer* str) {
void Disasm_XO_RT_RA(InstrData& i, poly::StringBuffer* str) {
str->Append("%*s%s%s r%d, r%d", i.XO.Rc ? -7 : -8, i.type->name,
i.XO.OE ? "o" : "", i.XO.Rc ? "." : "", i.XO.RT, i.XO.RA);
}
void Disasm_X_RA_RT_RB(InstrData& i, StringBuffer* str) {
void Disasm_X_RA_RT_RB(InstrData& i, poly::StringBuffer* str) {
str->Append("%*s%s r%d, r%d, r%d", i.X.Rc ? -7 : -8, i.type->name,
i.X.Rc ? "." : "", i.X.RA, i.X.RT, i.X.RB);
}
void Disasm_D_RA_RT_I(InstrData& i, StringBuffer* str) {
void Disasm_D_RA_RT_I(InstrData& i, poly::StringBuffer* str) {
str->Append("%-7s. r%d, r%d, %.4Xh", i.type->name, i.D.RA, i.D.RT, i.D.DS);
}
void Disasm_X_RA_RT(InstrData& i, StringBuffer* str) {
void Disasm_X_RA_RT(InstrData& i, poly::StringBuffer* str) {
str->Append("%*s%s r%d, r%d", i.X.Rc ? -7 : -8, i.type->name,
i.X.Rc ? "." : "", i.X.RA, i.X.RT);
}
@ -160,14 +160,14 @@ void Disasm_X_RA_RT(InstrData& i, StringBuffer* str) {
(i.VX128_R.VA128l | (i.VX128_R.VA128h << 5) | (i.VX128_R.VA128H << 6))
#define VX128_R_VB128 (i.VX128_R.VB128l | (i.VX128_R.VB128h << 5))
void Disasm_X_VX_RA0_RB(InstrData& i, StringBuffer* str) {
void Disasm_X_VX_RA0_RB(InstrData& i, poly::StringBuffer* str) {
if (i.X.RA) {
str->Append("%-8s v%d, r%d, r%d", i.type->name, i.X.RT, i.X.RA, i.X.RB);
} else {
str->Append("%-8s v%d, 0, r%d", i.type->name, i.X.RT, i.X.RB);
}
}
void Disasm_VX1281_VD_RA0_RB(InstrData& i, StringBuffer* str) {
void Disasm_VX1281_VD_RA0_RB(InstrData& i, poly::StringBuffer* str) {
const uint32_t vd = VX128_1_VD128;
if (i.VX128_1.RA) {
str->Append("%-8s v%d, r%d, r%d", i.type->name, vd, i.VX128_1.RA,
@ -176,45 +176,45 @@ void Disasm_VX1281_VD_RA0_RB(InstrData& i, StringBuffer* str) {
str->Append("%-8s v%d, 0, r%d", i.type->name, vd, i.VX128_1.RB);
}
}
void Disasm_VX1283_VD_VB(InstrData& i, StringBuffer* str) {
void Disasm_VX1283_VD_VB(InstrData& i, poly::StringBuffer* str) {
const uint32_t vd = VX128_3_VD128;
const uint32_t vb = VX128_3_VB128;
str->Append("%-8s v%d, v%d", i.type->name, vd, vb);
}
void Disasm_VX1283_VD_VB_I(InstrData& i, StringBuffer* str) {
void Disasm_VX1283_VD_VB_I(InstrData& i, poly::StringBuffer* str) {
const uint32_t vd = VX128_VD128;
const uint32_t va = VX128_VA128;
const uint32_t uimm = i.VX128_3.IMM;
str->Append("%-8s v%d, v%d, %.2Xh", i.type->name, vd, va, uimm);
}
void Disasm_VX_VD_VA_VB(InstrData& i, StringBuffer* str) {
void Disasm_VX_VD_VA_VB(InstrData& i, poly::StringBuffer* str) {
str->Append("%-8s v%d, v%d, v%d", i.type->name, i.VX.VD, i.VX.VA, i.VX.VB);
}
void Disasm_VX128_VD_VA_VB(InstrData& i, StringBuffer* str) {
void Disasm_VX128_VD_VA_VB(InstrData& i, poly::StringBuffer* str) {
const uint32_t vd = VX128_VD128;
const uint32_t va = VX128_VA128;
const uint32_t vb = VX128_VB128;
str->Append("%-8s v%d, v%d, v%d", i.type->name, vd, va, vb);
}
void Disasm_VX128_VD_VA_VD_VB(InstrData& i, StringBuffer* str) {
void Disasm_VX128_VD_VA_VD_VB(InstrData& i, poly::StringBuffer* str) {
const uint32_t vd = VX128_VD128;
const uint32_t va = VX128_VA128;
const uint32_t vb = VX128_VB128;
str->Append("%-8s v%d, v%d, v%d, v%d", i.type->name, vd, va, vd, vb);
}
void Disasm_VX1282_VD_VA_VB_VC(InstrData& i, StringBuffer* str) {
void Disasm_VX1282_VD_VA_VB_VC(InstrData& i, poly::StringBuffer* str) {
const uint32_t vd = VX128_2_VD128;
const uint32_t va = VX128_2_VA128;
const uint32_t vb = VX128_2_VB128;
const uint32_t vc = i.VX128_2.VC;
str->Append("%-8s v%d, v%d, v%d, v%d", i.type->name, vd, va, vb, vc);
}
void Disasm_VXA_VD_VA_VB_VC(InstrData& i, StringBuffer* str) {
void Disasm_VXA_VD_VA_VB_VC(InstrData& i, poly::StringBuffer* str) {
str->Append("%-8s v%d, v%d, v%d, v%d", i.type->name, i.VXA.VD, i.VXA.VA,
i.VXA.VB, i.VXA.VC);
}
void Disasm_sync(InstrData& i, StringBuffer* str) {
void Disasm_sync(InstrData& i, poly::StringBuffer* str) {
const char* name;
int L = i.X.RT & 3;
switch (L) {
@ -233,7 +233,7 @@ void Disasm_sync(InstrData& i, StringBuffer* str) {
str->Append("%-8s %.2X", name, L);
}
void Disasm_dcbf(InstrData& i, StringBuffer* str) {
void Disasm_dcbf(InstrData& i, poly::StringBuffer* str) {
const char* name;
switch (i.X.RT & 3) {
case 0:
@ -255,7 +255,7 @@ void Disasm_dcbf(InstrData& i, StringBuffer* str) {
str->Append("%-8s r%d, r%d", name, i.X.RA, i.X.RB);
}
void Disasm_dcbz(InstrData& i, StringBuffer* str) {
void Disasm_dcbz(InstrData& i, poly::StringBuffer* str) {
// or dcbz128 0x7C2007EC
if (i.X.RA) {
str->Append("%-8s r%d, r%d", i.type->name, i.X.RA, i.X.RB);
@ -264,16 +264,16 @@ void Disasm_dcbz(InstrData& i, StringBuffer* str) {
}
}
void Disasm_fcmp(InstrData& i, StringBuffer* str) {
void Disasm_fcmp(InstrData& i, poly::StringBuffer* str) {
str->Append("%-8s cr%d, f%d, f%d", i.type->name, i.X.RT >> 2, i.X.RA, i.X.RB);
}
void Disasm_mffsx(InstrData& i, StringBuffer* str) {
void Disasm_mffsx(InstrData& i, poly::StringBuffer* str) {
str->Append("%*s%s f%d, FPSCR", i.X.Rc ? -7 : -8, i.type->name,
i.X.Rc ? "." : "", i.X.RT);
}
void Disasm_bx(InstrData& i, StringBuffer* str) {
void Disasm_bx(InstrData& i, poly::StringBuffer* str) {
const char* name = i.I.LK ? "bl" : "b";
uint32_t nia;
if (i.I.AA) {
@ -284,7 +284,7 @@ void Disasm_bx(InstrData& i, StringBuffer* str) {
str->Append("%-8s %.8X", name, nia);
// TODO(benvanik): resolve target name?
}
void Disasm_bcx(InstrData& i, StringBuffer* str) {
void Disasm_bcx(InstrData& i, poly::StringBuffer* str) {
const char* s0 = i.B.LK ? "lr, " : "";
const char* s1;
if (!select_bits(i.B.BO, 2, 2)) {
@ -305,7 +305,7 @@ void Disasm_bcx(InstrData& i, StringBuffer* str) {
str->Append("%-8s %s%s%s%.8X", i.type->name, s0, s1, s2, nia);
// TODO(benvanik): resolve target name?
}
void Disasm_bcctrx(InstrData& i, StringBuffer* str) {
void Disasm_bcctrx(InstrData& i, poly::StringBuffer* str) {
// TODO(benvanik): mnemonics
const char* s0 = i.XL.LK ? "lr, " : "";
char s2[8] = {0};
@ -315,7 +315,7 @@ void Disasm_bcctrx(InstrData& i, StringBuffer* str) {
str->Append("%-8s %s%sctr", i.type->name, s0, s2);
// TODO(benvanik): resolve target name?
}
void Disasm_bclrx(InstrData& i, StringBuffer* str) {
void Disasm_bclrx(InstrData& i, poly::StringBuffer* str) {
const char* name = "bclr";
if (i.code == 0x4E800020) {
name = "blr";
@ -333,7 +333,7 @@ void Disasm_bclrx(InstrData& i, StringBuffer* str) {
str->Append("%-8s %s%s", name, s1, s2);
}
void Disasm_mfcr(InstrData& i, StringBuffer* str) {
void Disasm_mfcr(InstrData& i, poly::StringBuffer* str) {
str->Append("%-8s r%d, cr", i.type->name, i.X.RT);
}
const char* Disasm_spr_name(uint32_t n) {
@ -351,40 +351,40 @@ const char* Disasm_spr_name(uint32_t n) {
}
return reg;
}
void Disasm_mfspr(InstrData& i, StringBuffer* str) {
void Disasm_mfspr(InstrData& i, poly::StringBuffer* str) {
const uint32_t n = ((i.XFX.spr & 0x1F) << 5) | ((i.XFX.spr >> 5) & 0x1F);
const char* reg = Disasm_spr_name(n);
str->Append("%-8s r%d, %s", i.type->name, i.XFX.RT, reg);
}
void Disasm_mtspr(InstrData& i, StringBuffer* str) {
void Disasm_mtspr(InstrData& i, poly::StringBuffer* str) {
const uint32_t n = ((i.XFX.spr & 0x1F) << 5) | ((i.XFX.spr >> 5) & 0x1F);
const char* reg = Disasm_spr_name(n);
str->Append("%-8s %s, r%d", i.type->name, reg, i.XFX.RT);
}
void Disasm_mftb(InstrData& i, StringBuffer* str) {
void Disasm_mftb(InstrData& i, poly::StringBuffer* str) {
str->Append("%-8s r%d, tb", i.type->name, i.XFX.RT);
}
void Disasm_mfmsr(InstrData& i, StringBuffer* str) {
void Disasm_mfmsr(InstrData& i, poly::StringBuffer* str) {
str->Append("%-8s r%d", i.type->name, i.X.RT);
}
void Disasm_mtmsr(InstrData& i, StringBuffer* str) {
void Disasm_mtmsr(InstrData& i, poly::StringBuffer* str) {
str->Append("%-8s r%d, %d", i.type->name, i.X.RT, (i.X.RA & 16) ? 1 : 0);
}
void Disasm_cmp(InstrData& i, StringBuffer* str) {
void Disasm_cmp(InstrData& i, poly::StringBuffer* str) {
str->Append("%-8s cr%d, %.2X, r%d, r%d", i.type->name, i.X.RT >> 2,
i.X.RT & 1, i.X.RA, i.X.RB);
}
void Disasm_cmpi(InstrData& i, StringBuffer* str) {
void Disasm_cmpi(InstrData& i, poly::StringBuffer* str) {
str->Append("%-8s cr%d, %.2X, r%d, %d", i.type->name, i.D.RT >> 2, i.D.RT & 1,
i.D.RA, XEEXTS16(i.D.DS));
}
void Disasm_cmpli(InstrData& i, StringBuffer* str) {
void Disasm_cmpli(InstrData& i, poly::StringBuffer* str) {
str->Append("%-8s cr%d, %.2X, r%d, %.2X", i.type->name, i.D.RT >> 2,
i.D.RT & 1, i.D.RA, XEEXTS16(i.D.DS));
}
void Disasm_rld(InstrData& i, StringBuffer* str) {
void Disasm_rld(InstrData& i, poly::StringBuffer* str) {
if (i.MD.idx == 0) {
// XEDISASMR(rldiclx, 0x78000000, MD )
str->Append("%*s%s r%d, r%d, %d, %d", i.MD.Rc ? -7 : -8, "rldicl",
@ -421,75 +421,75 @@ void Disasm_rld(InstrData& i, StringBuffer* str) {
assert_always();
}
}
void Disasm_rlwim(InstrData& i, StringBuffer* str) {
void Disasm_rlwim(InstrData& i, poly::StringBuffer* str) {
str->Append("%*s%s r%d, r%d, %d, %d, %d", i.M.Rc ? -7 : -8, i.type->name,
i.M.Rc ? "." : "", i.M.RA, i.M.RT, i.M.SH, i.M.MB, i.M.ME);
}
void Disasm_rlwnmx(InstrData& i, StringBuffer* str) {
void Disasm_rlwnmx(InstrData& i, poly::StringBuffer* str) {
str->Append("%*s%s r%d, r%d, r%d, %d, %d", i.M.Rc ? -7 : -8, i.type->name,
i.M.Rc ? "." : "", i.M.RA, i.M.RT, i.M.SH, i.M.MB, i.M.ME);
}
void Disasm_srawix(InstrData& i, StringBuffer* str) {
void Disasm_srawix(InstrData& i, poly::StringBuffer* str) {
str->Append("%*s%s r%d, r%d, %d", i.X.Rc ? -7 : -8, i.type->name,
i.X.Rc ? "." : "", i.X.RA, i.X.RT, i.X.RB);
}
void Disasm_sradix(InstrData& i, StringBuffer* str) {
void Disasm_sradix(InstrData& i, poly::StringBuffer* str) {
str->Append("%*s%s r%d, r%d, %d", i.XS.Rc ? -7 : -8, i.type->name,
i.XS.Rc ? "." : "", i.XS.RA, i.XS.RT, (i.XS.SH5 << 5) | i.XS.SH);
}
void Disasm_vpermwi128(InstrData& i, StringBuffer* str) {
void Disasm_vpermwi128(InstrData& i, poly::StringBuffer* str) {
const uint32_t vd = i.VX128_P.VD128l | (i.VX128_P.VD128h << 5);
const uint32_t vb = i.VX128_P.VB128l | (i.VX128_P.VB128h << 5);
str->Append("%-8s v%d, v%d, %.2X", i.type->name, vd, vb,
i.VX128_P.PERMl | (i.VX128_P.PERMh << 5));
}
void Disasm_vrfin128(InstrData& i, StringBuffer* str) {
void Disasm_vrfin128(InstrData& i, poly::StringBuffer* str) {
const uint32_t vd = VX128_3_VD128;
const uint32_t vb = VX128_3_VB128;
str->Append("%-8s v%d, v%d", i.type->name, vd, vb);
}
void Disasm_vrlimi128(InstrData& i, StringBuffer* str) {
void Disasm_vrlimi128(InstrData& i, poly::StringBuffer* str) {
const uint32_t vd = VX128_4_VD128;
const uint32_t vb = VX128_4_VB128;
str->Append("%-8s v%d, v%d, %.2X, %.2X", i.type->name, vd, vb, i.VX128_4.IMM,
i.VX128_4.z);
}
void Disasm_vsldoi128(InstrData& i, StringBuffer* str) {
void Disasm_vsldoi128(InstrData& i, poly::StringBuffer* str) {
const uint32_t vd = VX128_5_VD128;
const uint32_t va = VX128_5_VA128;
const uint32_t vb = VX128_5_VB128;
const uint32_t sh = i.VX128_5.SH;
str->Append("%-8s v%d, v%d, v%d, %.2X", i.type->name, vd, va, vb, sh);
}
void Disasm_vspltb(InstrData& i, StringBuffer* str) {
void Disasm_vspltb(InstrData& i, poly::StringBuffer* str) {
str->Append("%-8s v%d, v%d, %.2X", i.type->name, i.VX.VD, i.VX.VB,
i.VX.VA & 0xF);
}
void Disasm_vsplth(InstrData& i, StringBuffer* str) {
void Disasm_vsplth(InstrData& i, poly::StringBuffer* str) {
str->Append("%-8s v%d, v%d, %.2X", i.type->name, i.VX.VD, i.VX.VB,
i.VX.VA & 0x7);
}
void Disasm_vspltw(InstrData& i, StringBuffer* str) {
void Disasm_vspltw(InstrData& i, poly::StringBuffer* str) {
str->Append("%-8s v%d, v%d, %.2X", i.type->name, i.VX.VD, i.VX.VB, i.VX.VA);
}
void Disasm_vspltisb(InstrData& i, StringBuffer* str) {
void Disasm_vspltisb(InstrData& i, poly::StringBuffer* str) {
// 5bit -> 8bit sign extend
int8_t simm = (i.VX.VA & 0x10) ? (i.VX.VA | 0xF0) : i.VX.VA;
str->Append("%-8s v%d, %.2X", i.type->name, i.VX.VD, simm);
}
void Disasm_vspltish(InstrData& i, StringBuffer* str) {
void Disasm_vspltish(InstrData& i, poly::StringBuffer* str) {
// 5bit -> 16bit sign extend
int16_t simm = (i.VX.VA & 0x10) ? (i.VX.VA | 0xFFF0) : i.VX.VA;
str->Append("%-8s v%d, %.4X", i.type->name, i.VX.VD, simm);
}
void Disasm_vspltisw(InstrData& i, StringBuffer* str) {
void Disasm_vspltisw(InstrData& i, poly::StringBuffer* str) {
// 5bit -> 32bit sign extend
int32_t simm = (i.VX.VA & 0x10) ? (i.VX.VA | 0xFFFFFFF0) : i.VX.VA;
str->Append("%-8s v%d, %.8X", i.type->name, i.VX.VD, simm);
}
int DisasmPPC(InstrData& i, StringBuffer* str) {
int DisasmPPC(InstrData& i, poly::StringBuffer* str) {
if (!i.type) {
str->Append("???");
} else {

3
src/alloy/frontend/ppc/ppc_disasm.h
View File

@ -11,12 +11,13 @@
#define ALLOY_FRONTEND_PPC_PPC_DISASM_H_
#include "alloy/frontend/ppc/ppc_instr.h"
#include "poly/string_buffer.h"
namespace alloy {
namespace frontend {
namespace ppc {
int DisasmPPC(InstrData& i, StringBuffer* str);
int DisasmPPC(InstrData& i, poly::StringBuffer* str);
} // namespace ppc
} // namespace frontend

4
src/alloy/frontend/ppc/ppc_emit_altivec.cc
View File

@ -18,6 +18,10 @@ namespace ppc {
// TODO(benvanik): remove when enums redefined.
using namespace alloy::hir;
using poly::vec128b;
using poly::vec128f;
using poly::vec128i;
using poly::vec128s;
using alloy::hir::Value;

4
src/alloy/frontend/ppc/ppc_frontend.h
View File

@ -13,7 +13,7 @@
#include <mutex>
#include "alloy/frontend/frontend.h"
#include "alloy/type_pool.h"
#include "poly/type_pool.h"
namespace alloy {
namespace frontend {
@ -43,7 +43,7 @@ class PPCFrontend : public Frontend {
runtime::Function** out_function) override;
private:
TypePool<PPCTranslator, PPCFrontend*> translator_pool_;
poly::TypePool<PPCTranslator, PPCFrontend*> translator_pool_;
PPCBuiltins builtins_;
};

4
src/alloy/frontend/ppc/ppc_hir_builder.h
View File

@ -13,7 +13,7 @@
#include "alloy/hir/hir_builder.h"
#include "alloy/runtime/function.h"
#include "alloy/runtime/symbol_info.h"
#include "alloy/string_buffer.h"
#include "poly/string_buffer.h"
namespace alloy {
namespace frontend {
@ -91,7 +91,7 @@ class PPCHIRBuilder : public hir::HIRBuilder {
PPCFrontend* frontend_;
// Reset whenever needed:
StringBuffer comment_buffer_;
poly::StringBuffer comment_buffer_;
// Reset each Emit:
bool with_debug_info_;

4
src/alloy/frontend/ppc/ppc_instr.cc
View File

@ -13,8 +13,8 @@
#include <vector>
#include "alloy/frontend/ppc/ppc_instr_tables.h"
#include "alloy/string_buffer.h"
#include "poly/poly.h"
#include "poly/string_buffer.h"
namespace alloy {
namespace frontend {
@ -23,7 +23,7 @@ namespace ppc {
std::vector<InstrType*> all_instrs_;
void DumpAllInstrCounts() {
StringBuffer sb;
poly::StringBuffer sb;
sb.Append("Instruction translation counts:\n");
for (auto instr_type : all_instrs_) {
if (instr_type->translation_count) {

6
src/alloy/frontend/ppc/ppc_instr.h
View File

@ -14,9 +14,7 @@
#include <string>
#include <vector>
namespace alloy {
class StringBuffer;
} // namespace alloy
#include "poly/string_buffer.h"
namespace alloy {
namespace frontend {
@ -549,7 +547,7 @@ class InstrDisasm {
void Dump(std::string& out_str, size_t pad = 13);
};
typedef void (*InstrDisasmFn)(InstrData& i, StringBuffer* str);
typedef void (*InstrDisasmFn)(InstrData& i, poly::StringBuffer* str);
typedef void* InstrEmitFn;
class InstrType {

129
src/alloy/frontend/ppc/ppc_instr_tables.h
View File

@ -14,81 +14,82 @@
#include "alloy/frontend/ppc/ppc_instr.h"
#include "poly/poly.h"
#include "poly/string_buffer.h"
namespace alloy {
namespace frontend {
namespace ppc {
void Disasm_0(InstrData& i, StringBuffer* str);
void Disasm__(InstrData& i, StringBuffer* str);
void Disasm_X_FRT_FRB(InstrData& i, StringBuffer* str);
void Disasm_A_FRT_FRB(InstrData& i, StringBuffer* str);
void Disasm_A_FRT_FRA_FRB(InstrData& i, StringBuffer* str);
void Disasm_A_FRT_FRA_FRB_FRC(InstrData& i, StringBuffer* str);
void Disasm_X_RT_RA_RB(InstrData& i, StringBuffer* str);
void Disasm_X_RT_RA0_RB(InstrData& i, StringBuffer* str);
void Disasm_X_FRT_RA_RB(InstrData& i, StringBuffer* str);
void Disasm_X_FRT_RA0_RB(InstrData& i, StringBuffer* str);
void Disasm_D_RT_RA_I(InstrData& i, StringBuffer* str);
void Disasm_D_RT_RA0_I(InstrData& i, StringBuffer* str);
void Disasm_D_FRT_RA_I(InstrData& i, StringBuffer* str);
void Disasm_D_FRT_RA0_I(InstrData& i, StringBuffer* str);
void Disasm_DS_RT_RA_I(InstrData& i, StringBuffer* str);
void Disasm_DS_RT_RA0_I(InstrData& i, StringBuffer* str);
void Disasm_D_RA(InstrData& i, StringBuffer* str);
void Disasm_X_RA_RB(InstrData& i, StringBuffer* str);
void Disasm_XO_RT_RA_RB(InstrData& i, StringBuffer* str);
void Disasm_XO_RT_RA(InstrData& i, StringBuffer* str);
void Disasm_X_RA_RT_RB(InstrData& i, StringBuffer* str);
void Disasm_D_RA_RT_I(InstrData& i, StringBuffer* str);
void Disasm_X_RA_RT(InstrData& i, StringBuffer* str);
void Disasm_X_VX_RA0_RB(InstrData& i, StringBuffer* str);
void Disasm_VX1281_VD_RA0_RB(InstrData& i, StringBuffer* str);
void Disasm_VX1283_VD_VB(InstrData& i, StringBuffer* str);
void Disasm_VX1283_VD_VB_I(InstrData& i, StringBuffer* str);
void Disasm_VX_VD_VA_VB(InstrData& i, StringBuffer* str);
void Disasm_VX128_VD_VA_VB(InstrData& i, StringBuffer* str);
void Disasm_VX128_VD_VA_VD_VB(InstrData& i, StringBuffer* str);
void Disasm_VX1282_VD_VA_VB_VC(InstrData& i, StringBuffer* str);
void Disasm_VXA_VD_VA_VB_VC(InstrData& i, StringBuffer* str);
void Disasm_0(InstrData& i, poly::StringBuffer* str);
void Disasm__(InstrData& i, poly::StringBuffer* str);
void Disasm_X_FRT_FRB(InstrData& i, poly::StringBuffer* str);
void Disasm_A_FRT_FRB(InstrData& i, poly::StringBuffer* str);
void Disasm_A_FRT_FRA_FRB(InstrData& i, poly::StringBuffer* str);
void Disasm_A_FRT_FRA_FRB_FRC(InstrData& i, poly::StringBuffer* str);
void Disasm_X_RT_RA_RB(InstrData& i, poly::StringBuffer* str);
void Disasm_X_RT_RA0_RB(InstrData& i, poly::StringBuffer* str);
void Disasm_X_FRT_RA_RB(InstrData& i, poly::StringBuffer* str);
void Disasm_X_FRT_RA0_RB(InstrData& i, poly::StringBuffer* str);
void Disasm_D_RT_RA_I(InstrData& i, poly::StringBuffer* str);
void Disasm_D_RT_RA0_I(InstrData& i, poly::StringBuffer* str);
void Disasm_D_FRT_RA_I(InstrData& i, poly::StringBuffer* str);
void Disasm_D_FRT_RA0_I(InstrData& i, poly::StringBuffer* str);
void Disasm_DS_RT_RA_I(InstrData& i, poly::StringBuffer* str);
void Disasm_DS_RT_RA0_I(InstrData& i, poly::StringBuffer* str);
void Disasm_D_RA(InstrData& i, poly::StringBuffer* str);
void Disasm_X_RA_RB(InstrData& i, poly::StringBuffer* str);
void Disasm_XO_RT_RA_RB(InstrData& i, poly::StringBuffer* str);
void Disasm_XO_RT_RA(InstrData& i, poly::StringBuffer* str);
void Disasm_X_RA_RT_RB(InstrData& i, poly::StringBuffer* str);
void Disasm_D_RA_RT_I(InstrData& i, poly::StringBuffer* str);
void Disasm_X_RA_RT(InstrData& i, poly::StringBuffer* str);
void Disasm_X_VX_RA0_RB(InstrData& i, poly::StringBuffer* str);
void Disasm_VX1281_VD_RA0_RB(InstrData& i, poly::StringBuffer* str);
void Disasm_VX1283_VD_VB(InstrData& i, poly::StringBuffer* str);
void Disasm_VX1283_VD_VB_I(InstrData& i, poly::StringBuffer* str);
void Disasm_VX_VD_VA_VB(InstrData& i, poly::StringBuffer* str);
void Disasm_VX128_VD_VA_VB(InstrData& i, poly::StringBuffer* str);
void Disasm_VX128_VD_VA_VD_VB(InstrData& i, poly::StringBuffer* str);
void Disasm_VX1282_VD_VA_VB_VC(InstrData& i, poly::StringBuffer* str);
void Disasm_VXA_VD_VA_VB_VC(InstrData& i, poly::StringBuffer* str);
void Disasm_sync(InstrData& i, StringBuffer* str);
void Disasm_dcbf(InstrData& i, StringBuffer* str);
void Disasm_dcbz(InstrData& i, StringBuffer* str);
void Disasm_fcmp(InstrData& i, StringBuffer* str);
void Disasm_sync(InstrData& i, poly::StringBuffer* str);
void Disasm_dcbf(InstrData& i, poly::StringBuffer* str);
void Disasm_dcbz(InstrData& i, poly::StringBuffer* str);
void Disasm_fcmp(InstrData& i, poly::StringBuffer* str);
void Disasm_bx(InstrData& i, StringBuffer* str);
void Disasm_bcx(InstrData& i, StringBuffer* str);
void Disasm_bcctrx(InstrData& i, StringBuffer* str);
void Disasm_bclrx(InstrData& i, StringBuffer* str);
void Disasm_bx(InstrData& i, poly::StringBuffer* str);
void Disasm_bcx(InstrData& i, poly::StringBuffer* str);
void Disasm_bcctrx(InstrData& i, poly::StringBuffer* str);
void Disasm_bclrx(InstrData& i, poly::StringBuffer* str);
void Disasm_mfcr(InstrData& i, StringBuffer* str);
void Disasm_mfspr(InstrData& i, StringBuffer* str);
void Disasm_mtspr(InstrData& i, StringBuffer* str);
void Disasm_mftb(InstrData& i, StringBuffer* str);
void Disasm_mfmsr(InstrData& i, StringBuffer* str);
void Disasm_mtmsr(InstrData& i, StringBuffer* str);
void Disasm_mfcr(InstrData& i, poly::StringBuffer* str);
void Disasm_mfspr(InstrData& i, poly::StringBuffer* str);
void Disasm_mtspr(InstrData& i, poly::StringBuffer* str);
void Disasm_mftb(InstrData& i, poly::StringBuffer* str);
void Disasm_mfmsr(InstrData& i, poly::StringBuffer* str);
void Disasm_mtmsr(InstrData& i, poly::StringBuffer* str);
void Disasm_cmp(InstrData& i, StringBuffer* str);
void Disasm_cmpi(InstrData& i, StringBuffer* str);
void Disasm_cmpli(InstrData& i, StringBuffer* str);
void Disasm_cmp(InstrData& i, poly::StringBuffer* str);
void Disasm_cmpi(InstrData& i, poly::StringBuffer* str);
void Disasm_cmpli(InstrData& i, poly::StringBuffer* str);
void Disasm_rld(InstrData& i, StringBuffer* str);
void Disasm_rlwim(InstrData& i, StringBuffer* str);
void Disasm_rlwnmx(InstrData& i, StringBuffer* str);
void Disasm_srawix(InstrData& i, StringBuffer* str);
void Disasm_sradix(InstrData& i, StringBuffer* str);
void Disasm_rld(InstrData& i, poly::StringBuffer* str);
void Disasm_rlwim(InstrData& i, poly::StringBuffer* str);
void Disasm_rlwnmx(InstrData& i, poly::StringBuffer* str);
void Disasm_srawix(InstrData& i, poly::StringBuffer* str);
void Disasm_sradix(InstrData& i, poly::StringBuffer* str);
void Disasm_vpermwi128(InstrData& i, StringBuffer* str);
void Disasm_vrfin128(InstrData& i, StringBuffer* str);
void Disasm_vrlimi128(InstrData& i, StringBuffer* str);
void Disasm_vsldoi128(InstrData& i, StringBuffer* str);
void Disasm_vspltb(InstrData& i, StringBuffer* str);
void Disasm_vsplth(InstrData& i, StringBuffer* str);
void Disasm_vspltw(InstrData& i, StringBuffer* str);
void Disasm_vspltisb(InstrData& i, StringBuffer* str);
void Disasm_vspltish(InstrData& i, StringBuffer* str);
void Disasm_vspltisw(InstrData& i, StringBuffer* str);
void Disasm_vpermwi128(InstrData& i, poly::StringBuffer* str);
void Disasm_vrfin128(InstrData& i, poly::StringBuffer* str);
void Disasm_vrlimi128(InstrData& i, poly::StringBuffer* str);
void Disasm_vsldoi128(InstrData& i, poly::StringBuffer* str);
void Disasm_vspltb(InstrData& i, poly::StringBuffer* str);
void Disasm_vsplth(InstrData& i, poly::StringBuffer* str);
void Disasm_vspltw(InstrData& i, poly::StringBuffer* str);
void Disasm_vspltisb(InstrData& i, poly::StringBuffer* str);
void Disasm_vspltish(InstrData& i, poly::StringBuffer* str);
void Disasm_vspltisw(InstrData& i, poly::StringBuffer* str);
namespace tables {

12
src/alloy/frontend/ppc/ppc_translator.cc
View File

@ -16,8 +16,8 @@
#include "alloy/frontend/ppc/ppc_hir_builder.h"
#include "alloy/frontend/ppc/ppc_instr.h"
#include "alloy/frontend/ppc/ppc_scanner.h"
#include "alloy/reset_scope.h"
#include "alloy/runtime/runtime.h"
#include "poly/reset_scope.h"
#include "xenia/profiling.h"
namespace alloy {
@ -91,10 +91,10 @@ int PPCTranslator::Translate(FunctionInfo* symbol_info,
SCOPE_profile_cpu_f("alloy");
// Reset() all caching when we leave.
make_reset_scope(builder_);
make_reset_scope(compiler_);
make_reset_scope(assembler_);
make_reset_scope(&string_buffer_);
poly::make_reset_scope(builder_);
poly::make_reset_scope(compiler_);
poly::make_reset_scope(assembler_);
poly::make_reset_scope(&string_buffer_);
// Scan the function to find its extents. We only need to do this if we
// haven't already been provided with them from some other source.
@ -175,7 +175,7 @@ int PPCTranslator::Translate(FunctionInfo* symbol_info,
};
void PPCTranslator::DumpSource(runtime::FunctionInfo* symbol_info,
StringBuffer* string_buffer) {
poly::StringBuffer* string_buffer) {
Memory* memory = frontend_->memory();
const uint8_t* p = memory->membase();

6
src/alloy/frontend/ppc/ppc_translator.h
View File

@ -15,7 +15,7 @@
#include "alloy/backend/assembler.h"
#include "alloy/compiler/compiler.h"
#include "alloy/runtime/symbol_info.h"
#include "alloy/string_buffer.h"
#include "poly/string_buffer.h"
namespace alloy {
namespace frontend {
@ -35,7 +35,7 @@ class PPCTranslator {
private:
void DumpSource(runtime::FunctionInfo* symbol_info,
StringBuffer* string_buffer);
poly::StringBuffer* string_buffer);
private:
PPCFrontend* frontend_;
@ -44,7 +44,7 @@ class PPCTranslator {
std::unique_ptr<compiler::Compiler> compiler_;
std::unique_ptr<backend::Assembler> assembler_;
StringBuffer string_buffer_;
poly::StringBuffer string_buffer_;
};
} // namespace ppc

4
src/alloy/hir/block.h
View File

@ -10,7 +10,7 @@
#ifndef ALLOY_HIR_BLOCK_H_
#define ALLOY_HIR_BLOCK_H_
#include "alloy/arena.h"
#include "poly/arena.h"
namespace llvm {
class BitVector;
@ -45,7 +45,7 @@ class Edge {
class Block {
public:
Arena* arena;
poly::Arena* arena;
Block* next;
Block* prev;

9
src/alloy/hir/hir_builder.cc
View File

@ -13,7 +13,6 @@
#include "alloy/hir/instr.h"
#include "alloy/hir/label.h"
#include "alloy/runtime/symbol_info.h"
#include "alloy/string_buffer.h"
#include "xenia/profiling.h"
namespace alloy {
@ -30,7 +29,7 @@ using alloy::runtime::FunctionInfo;
assert_true((value1->type) == (value2->type))
HIRBuilder::HIRBuilder() {
arena_ = new Arena();
arena_ = new poly::Arena();
Reset();
}
@ -90,7 +89,7 @@ int HIRBuilder::Finalize() {
return 0;
}
void HIRBuilder::DumpValue(StringBuffer* str, Value* value) {
void HIRBuilder::DumpValue(poly::StringBuffer* str, Value* value) {
if (value->IsConstant()) {
switch (value->type) {
case INT8_TYPE:
@ -131,7 +130,7 @@ void HIRBuilder::DumpValue(StringBuffer* str, Value* value) {
}
}
void HIRBuilder::DumpOp(StringBuffer* str, OpcodeSignatureType sig_type,
void HIRBuilder::DumpOp(poly::StringBuffer* str, OpcodeSignatureType sig_type,
Instr::Op* op) {
switch (sig_type) {
case OPCODE_SIG_TYPE_X:
@ -158,7 +157,7 @@ void HIRBuilder::DumpOp(StringBuffer* str, OpcodeSignatureType sig_type,
}
}
void HIRBuilder::Dump(StringBuffer* str) {
void HIRBuilder::Dump(poly::StringBuffer* str) {
SCOPE_profile_cpu_f("alloy");
if (attributes_) {

17
src/alloy/hir/hir_builder.h
View File

@ -17,10 +17,8 @@
#include "alloy/hir/label.h"
#include "alloy/hir/opcodes.h"
#include "alloy/hir/value.h"
namespace alloy {
class StringBuffer;
} // namespace alloy
#include "poly/arena.h"
#include "poly/string_buffer.h"
namespace alloy {
namespace hir {
@ -37,10 +35,10 @@ class HIRBuilder {
virtual void Reset();
virtual int Finalize();
void Dump(StringBuffer* str);
void Dump(poly::StringBuffer* str);
void AssertNoCycles();
Arena* arena() const { return arena_; }
poly::Arena* arena() const { return arena_; }
uint32_t attributes() const { return attributes_; }
void set_attributes(uint32_t value) { attributes_ = value; }
@ -230,8 +228,9 @@ class HIRBuilder {
Value* AtomicSub(Value* address, Value* value);
protected:
void DumpValue(StringBuffer* str, Value* value);
void DumpOp(StringBuffer* str, OpcodeSignatureType sig_type, Instr::Op* op);
void DumpValue(poly::StringBuffer* str, Value* value);
void DumpOp(poly::StringBuffer* str, OpcodeSignatureType sig_type,
Instr::Op* op);
Value* AllocValue(TypeName type = INT64_TYPE);
Value* CloneValue(Value* source);
@ -246,7 +245,7 @@ class HIRBuilder {
TypeName part_type);
protected:
Arena* arena_;
poly::Arena* arena_;
uint32_t attributes_;

2
src/alloy/hir/value.cc
View File

@ -14,7 +14,7 @@
namespace alloy {
namespace hir {
Value::Use* Value::AddUse(Arena* arena, Instr* instr) {
Value::Use* Value::AddUse(poly::Arena* arena, Instr* instr) {
Use* use = arena->Alloc<Use>();
use->instr = instr;
use->prev = NULL;

8
src/alloy/hir/value.h
View File

@ -10,17 +10,19 @@
#ifndef ALLOY_HIR_VALUE_H_
#define ALLOY_HIR_VALUE_H_
#include "alloy/arena.h"
#include "alloy/backend/machine_info.h"
#include "alloy/hir/opcodes.h"
#include "alloy/vec128.h"
#include "poly/arena.h"
#include "poly/poly.h"
#include "poly/vec128.h"
namespace alloy {
namespace hir {
class Instr;
using vec128_t = poly::vec128_t;
enum TypeName {
// Many tables rely on this ordering.
INT8_TYPE = 0,
@ -99,7 +101,7 @@ class Value {
// TODO(benvanik): remove to shrink size.
void* tag;
Use* AddUse(Arena* arena, Instr* instr);
Use* AddUse(poly::Arena* arena, Instr* instr);
void RemoveUse(Use* use);
int8_t get_constant(int8_t) const { return constant.i8; }

1
src/alloy/runtime/function.cc
View File

@ -12,6 +12,7 @@
#include "alloy/runtime/debugger.h"
#include "alloy/runtime/symbol_info.h"
#include "alloy/runtime/thread_state.h"
#include "poly/logging.h"
#include "xdb/protocol.h"
namespace alloy {

6
src/alloy/runtime/test_module.cc
View File

@ -10,9 +10,9 @@
#include "alloy/runtime/test_module.h"
#include "alloy/compiler/compiler_passes.h"
#include "alloy/reset_scope.h"
#include "alloy/runtime/runtime.h"
#include "poly/platform.h"
#include "poly/reset_scope.h"
#include "poly/string.h"
namespace alloy {
@ -79,8 +79,8 @@ SymbolInfo::Status TestModule::DeclareFunction(uint64_t address,
auto symbol_info = *out_symbol_info;
// Reset() all caching when we leave.
make_reset_scope(compiler_);
make_reset_scope(assembler_);
poly::make_reset_scope(compiler_);
poly::make_reset_scope(assembler_);
if (!generate_(*builder_.get())) {
symbol_info->set_status(SymbolInfo::STATUS_FAILED);

7
src/alloy/sources.gypi
View File

@ -4,15 +4,8 @@
'alloy-private.h',
'alloy.cc',
'alloy.h',
'arena.cc',
'arena.h',
'memory.cc',
'memory.h',
'reset_scope.h',
'string_buffer.cc',
'string_buffer.h',
'type_pool.h',
'vec128.h',
],
'conditions': [

1
src/alloy/test/test_byte_swap.cc
View File

@ -14,6 +14,7 @@ using namespace alloy::hir;
using namespace alloy::runtime;
using namespace alloy::test;
using alloy::frontend::ppc::PPCContext;
using namespace poly;
TEST_CASE("BYTE_SWAP_V128", "[instr]") {
TestFunction([](hir::HIRBuilder& b) {

1
src/alloy/test/test_extract.cc
View File

@ -16,6 +16,7 @@ using namespace alloy::hir;
using namespace alloy::runtime;
using namespace alloy::test;
using alloy::frontend::ppc::PPCContext;
using namespace poly;
TEST_CASE("EXTRACT_INT8", "[instr]") {
TestFunction test([](hir::HIRBuilder& b) {

1
src/alloy/test/test_insert.cc
View File

@ -16,6 +16,7 @@ using namespace alloy::hir;
using namespace alloy::runtime;
using namespace alloy::test;
using alloy::frontend::ppc::PPCContext;
using namespace poly;
TEST_CASE("INSERT_INT8", "[instr]") {
for (int i = 0; i < 16; ++i) {

1
src/alloy/test/test_load_vector_shl_shr.cc
View File

@ -14,6 +14,7 @@ using namespace alloy::hir;
using namespace alloy::runtime;
using namespace alloy::test;
using alloy::frontend::ppc::PPCContext;
using namespace poly;
TEST_CASE("LOAD_VECTOR_SHL", "[instr]") {
TestFunction test([](hir::HIRBuilder& b) {

1
src/alloy/test/test_pack.cc
View File

@ -14,6 +14,7 @@ using namespace alloy::hir;
using namespace alloy::runtime;
using namespace alloy::test;
using alloy::frontend::ppc::PPCContext;
using namespace poly;
TEST_CASE("PACK_D3DCOLOR", "[instr]") {
TestFunction test([](hir::HIRBuilder& b) {

1
src/alloy/test/test_permute.cc
View File

@ -14,6 +14,7 @@ using namespace alloy::hir;
using namespace alloy::runtime;
using namespace alloy::test;
using alloy::frontend::ppc::PPCContext;
using namespace poly;
TEST_CASE("PERMUTE_V128_BY_INT32_CONSTANT", "[instr]") {
{

1
src/alloy/test/test_shr.cc
View File

@ -14,6 +14,7 @@ using namespace alloy::hir;
using namespace alloy::runtime;
using namespace alloy::test;
using alloy::frontend::ppc::PPCContext;
using namespace poly;
TEST_CASE("SHR_I8", "[instr]") {
TestFunction test([](hir::HIRBuilder& b) {

1
src/alloy/test/test_swizzle.cc
View File

@ -14,6 +14,7 @@ using namespace alloy::hir;
using namespace alloy::runtime;
using namespace alloy::test;
using alloy::frontend::ppc::PPCContext;
using namespace poly;
TEST_CASE("SWIZZLE_V128", "[instr]") {
TestFunction([](hir::HIRBuilder& b) {

1
src/alloy/test/test_unpack.cc
View File

@ -14,6 +14,7 @@ using namespace alloy::hir;
using namespace alloy::runtime;
using namespace alloy::test;
using alloy::frontend::ppc::PPCContext;
using namespace poly;
TEST_CASE("UNPACK_D3DCOLOR", "[instr]") {
TestFunction test([](hir::HIRBuilder& b) {

1
src/alloy/test/test_vector_add.cc
View File

@ -16,6 +16,7 @@ using namespace alloy::hir;
using namespace alloy::runtime;
using namespace alloy::test;
using alloy::frontend::ppc::PPCContext;
using namespace poly;
TEST_CASE("VECTOR_ADD_I8", "[instr]") {
TestFunction test([](hir::HIRBuilder& b) {

1
src/alloy/test/test_vector_max.cc
View File

@ -16,6 +16,7 @@ using namespace alloy::hir;
using namespace alloy::runtime;
using namespace alloy::test;
using alloy::frontend::ppc::PPCContext;
using namespace poly;
TEST_CASE("VECTOR_MAX_I8_SIGNED", "[instr]") {
TestFunction test([](hir::HIRBuilder& b) {

1
src/alloy/test/test_vector_min.cc
View File

@ -16,6 +16,7 @@ using namespace alloy::hir;
using namespace alloy::runtime;
using namespace alloy::test;
using alloy::frontend::ppc::PPCContext;
using namespace poly;
TEST_CASE("VECTOR_MIN_I8_SIGNED", "[instr]") {
TestFunction test([](hir::HIRBuilder& b) {

1
src/alloy/test/test_vector_rotate_left.cc
View File

@ -15,6 +15,7 @@ using namespace alloy::hir;
using namespace alloy::runtime;
using namespace alloy::test;
using alloy::frontend::ppc::PPCContext;
using namespace poly;
TEST_CASE("VECTOR_ROTATE_LEFT_I8", "[instr]") {
TestFunction test([](hir::HIRBuilder& b) {

1
src/alloy/test/test_vector_sha.cc
View File

@ -14,6 +14,7 @@ using namespace alloy::hir;
using namespace alloy::runtime;
using namespace alloy::test;
using alloy::frontend::ppc::PPCContext;
using namespace poly;
TEST_CASE("VECTOR_SHA_I8", "[instr]") {
TestFunction test([](hir::HIRBuilder& b) {

1
src/alloy/test/test_vector_shl.cc
View File

@ -14,6 +14,7 @@ using namespace alloy::hir;
using namespace alloy::runtime;
using namespace alloy::test;
using alloy::frontend::ppc::PPCContext;
using namespace poly;
TEST_CASE("VECTOR_SHL_I8", "[instr]") {
TestFunction test([](hir::HIRBuilder& b) {

1
src/alloy/test/test_vector_shr.cc
View File

@ -14,6 +14,7 @@ using namespace alloy::hir;
using namespace alloy::runtime;
using namespace alloy::test;
using alloy::frontend::ppc::PPCContext;
using namespace poly;
TEST_CASE("VECTOR_SHR_I8", "[instr]") {
TestFunction test([](hir::HIRBuilder& b) {

14
src/alloy/arena.cc → src/poly/arena.cc
View File

@ -7,11 +7,13 @@
******************************************************************************
*/
#include "alloy/arena.h"
#include "poly/arena.h"
#include "poly/poly.h"
#include <memory>
namespace alloy {
#include "poly/assert.h"
namespace poly {
Arena::Arena(size_t chunk_size)
: chunk_size_(chunk_size), head_chunk_(nullptr), active_chunk_(nullptr) {}
@ -37,7 +39,7 @@ void Arena::Reset() {
void Arena::DebugFill() {
auto chunk = head_chunk_;
while (chunk) {
memset(chunk->buffer, 0xCD, chunk->capacity);
std::memset(chunk->buffer, 0xCD, chunk->capacity);
chunk = chunk->next;
}
}
@ -77,7 +79,7 @@ void* Arena::CloneContents() {
uint8_t* p = (uint8_t*)result;
chunk = head_chunk_;
while (chunk) {
memcpy(p, chunk->buffer, chunk->offset);
std::memcpy(p, chunk->buffer, chunk->offset);
p += chunk->offset;
if (chunk == active_chunk_) {
break;
@ -98,4 +100,4 @@ Arena::Chunk::~Chunk() {
}
}
} // namespace alloy
} // namespace poly

10
src/alloy/arena.h → src/poly/arena.h
View File

@ -7,13 +7,13 @@
******************************************************************************
*/
#ifndef ALLOY_ARENA_H_
#define ALLOY_ARENA_H_
#ifndef POLY_ARENA_H_
#define POLY_ARENA_H_
#include <cstddef>
#include <cstdint>
namespace alloy {
namespace poly {
class Arena {
public:
@ -50,6 +50,6 @@ class Arena {
Chunk* active_chunk_;
};
} // namespace alloy
} // namespace poly
#endif // ALLOY_ARENA_H_
#endif // POLY_ARENA_H_

1
src/poly/poly.h
View File

@ -23,6 +23,7 @@
#include "poly/platform.h"
#include "poly/string.h"
#include "poly/threading.h"
#include "poly/vec128.h"
namespace poly {} // namespace poly

10
src/alloy/reset_scope.h → src/poly/reset_scope.h
View File

@ -7,12 +7,12 @@
******************************************************************************
*/
#ifndef ALLOY_RESET_SCOPE_H_
#define ALLOY_RESET_SCOPE_H_
#ifndef POLY_RESET_SCOPE_H_
#define POLY_RESET_SCOPE_H_
#include <mutex>
namespace alloy {
namespace poly {
template <typename T>
class ResetScope {
@ -38,6 +38,6 @@ inline ResetScope<T> make_reset_scope(const std::unique_ptr<T>& value) {
return ResetScope<T>(value.get());
}
} // namespace alloy
} // namespace poly
#endif // ALLOY_RESET_SCOPE_H_
#endif // POLY_RESET_SCOPE_H_

7
src/poly/sources.gypi
View File

@ -1,6 +1,8 @@
# Copyright 2014 Ben Vanik. All Rights Reserved.
{
'sources': [
'arena.cc',
'arena.h',
'assert.h',
'atomic.h',
'byte_order.h',
@ -20,10 +22,15 @@
'memory.h',
'platform.h',
'poly.h',
'reset_scope.h',
'string.cc',
'string.h',
'string_buffer.cc',
'string_buffer.h',
'threading.cc',
'threading.h',
'type_pool.h',
'vec128.h',
],
'conditions': [

10
src/alloy/string_buffer.cc → src/poly/string_buffer.cc
View File

@ -7,12 +7,12 @@
******************************************************************************
*/
#include "alloy/string_buffer.h"
#include "poly/string_buffer.h"
#include <algorithm>
#include <cstdarg>
namespace alloy {
namespace poly {
StringBuffer::StringBuffer(size_t initial_capacity) {
buffer_.reserve(std::max(initial_capacity, static_cast<size_t>(1024)));
@ -62,8 +62,10 @@ void StringBuffer::AppendBytes(const uint8_t* buffer, size_t length) {
const char* StringBuffer::GetString() const { return buffer_.data(); }
std::string StringBuffer::to_string() { return std::string(buffer_.data(), buffer_.size()); }
std::string StringBuffer::to_string() {
return std::string(buffer_.data(), buffer_.size());
}
char* StringBuffer::ToString() { return strdup(buffer_.data()); }
} // namespace alloy
} // namespace poly

10
src/alloy/string_buffer.h → src/poly/string_buffer.h
View File

@ -7,14 +7,14 @@
******************************************************************************
*/
#ifndef ALLOY_STRING_BUFFER_H_
#define ALLOY_STRING_BUFFER_H_
#ifndef POLY_STRING_BUFFER_H_
#define POLY_STRING_BUFFER_H_
#include <cstdint>
#include <string>
#include <vector>
namespace alloy {
namespace poly {
class StringBuffer {
public:
@ -41,6 +41,6 @@ class StringBuffer {
std::vector<char> buffer_;
};
} // namespace alloy
} // namespace poly
#endif // ALLOY_STRING_BUFFER_H_
#endif // POLY_STRING_BUFFER_H_

10
src/alloy/type_pool.h → src/poly/type_pool.h
View File

@ -7,13 +7,13 @@
******************************************************************************
*/
#ifndef ALLOY_TYPE_POOL_H_
#define ALLOY_TYPE_POOL_H_
#ifndef POLY_TYPE_POOL_H_
#define POLY_TYPE_POOL_H_
#include <mutex>
#include <vector>
namespace alloy {
namespace poly {
template <class T, typename A>
class TypePool {
@ -54,6 +54,6 @@ class TypePool {
std::vector<T*> list_;
};
} // namespace alloy
} // namespace poly
#endif // ALLOY_TYPE_POOL_H_
#endif // POLY_TYPE_POOL_H_

12
src/alloy/vec128.h → src/poly/vec128.h
View File

@ -7,12 +7,12 @@
******************************************************************************
*/
#ifndef ALLOY_VEC128_H_
#define ALLOY_VEC128_H_
#ifndef POLY_VEC128_H_
#define POLY_VEC128_H_
#include "poly/poly.h"
#include <cstddef>
namespace alloy {
namespace poly {
// The first rule of vector programming is to only rely on exact positions
// when absolutely required - prefer dumb loops to exact offsets.
@ -191,6 +191,6 @@ static inline vec128_t vec128b(uint8_t x0, uint8_t x1, uint8_t x2, uint8_t x3,
return v;
}
} // namespace alloy
} // namespace poly
#endif // ALLOY_VEC128_H_
#endif // POLY_VEC128_H_

8
src/xdb/protocol.h
View File

@ -12,13 +12,13 @@
#include <cstdint>
#include <alloy/vec128.h>
#include <poly/atomic.h>
#include "poly/atomic.h"
#include "poly/vec128.h"
namespace xdb {
namespace protocol {
using vec128_t = alloy::vec128_t;
using vec128_t = poly::vec128_t;
#pragma pack(push, 4)
@ -96,7 +96,7 @@ struct Registers {
uint32_t vscr;
uint64_t gpr[32];
double fpr[32];
alloy::vec128_t vr[128];
poly::vec128_t vr[128];
};
struct ThreadCreateEvent : public Event<ThreadCreateEvent> {

4
src/xenia/gpu/gl4/gl4_shader_translator.h
View File

@ -12,7 +12,7 @@
#include <string>
#include "alloy/string_buffer.h"
#include "poly/string_buffer.h"
#include "xenia/common.h"
#include "xenia/gpu/gl4/gl_context.h"
#include "xenia/gpu/gl4/gl4_shader.h"
@ -42,7 +42,7 @@ class GL4ShaderTranslator {
const uint32_t* dwords_;
static const int kOutputCapacity = 64 * 1024;
alloy::StringBuffer output_;
poly::StringBuffer output_;
bool is_vertex_shader() const { return shader_type_ == ShaderType::kVertex; }
bool is_pixel_shader() const { return shader_type_ == ShaderType::kPixel; }