move lots of source files around to match their actual placement in the original treemain

1 files changed, 0 insertions, 1040 deletions

diff --git a/compiler_and_linker/unsorted/Operands.c b/compiler_and_linker/unsorted/Operands.c
deleted file mode 100644
index c5da285..0000000
--- a/compiler_and_linker/unsorted/Operands.c
+++ /dev/null
@@ -1,1040 +0,0 @@
-#include "compiler/Operands.h"
-#include "compiler/CError.h"
-#include "compiler/CMachine.h"
-#include "compiler/CParser.h"
-#include "compiler/CodeGen.h"
-#include "compiler/CompilerTools.h"
-#include "compiler/PCode.h"
-#include "compiler/PCodeInfo.h"
-#include "compiler/PCodeUtilities.h"
-#include "compiler/RegisterInfo.h"
-#include "compiler/Registers.h"
-#include "compiler/StackFrame.h"
-#include "compiler/TOC.h"
-#include "compiler/enode.h"
-#include "compiler/objects.h"
-
-unsigned long long uns_to_float_cc = 0x4330000000000000;
-unsigned long long int_to_float_cc = 0x4330000080000000;
-Float one_point_zero = {1.0};
-
-void load_immediate(short reg, SInt32 value) {
-    short tmpreg = reg;
-    short tmpreg2;
-
-    if (!FITS_IN_SHORT(value)) {
-        if (copts.optimizationlevel > 1 && LOW_PART_BUGGY(value))
-            tmpreg = used_virtual_registers[RegClass_GPR]++;
-        emitpcode(PC_LIS, tmpreg2 = tmpreg, 0, (short) HIGH_PART(value));
-        if (LOW_PART_BUGGY(value))
-            emitpcode(PC_ADDI, reg, tmpreg2, 0, LOW_PART(value));
-    } else {
-        emitpcode(PC_LI, reg, value);
-    }
-}
-
-static void set_op_flags(Operand *op, ENode *expr) {
-    CError_ASSERT(118, op);
-
-    if (expr) {
-        if (expr->type == EINTCONST) {
-            op->flags = 0;
-            if (expr->flags & ENODE_FLAG_VOLATILE)
-                op->flags |= OpndFlags_Volatile;
-            if (expr->flags & ENODE_FLAG_CONST)
-                op->flags |= OpndFlags_Const;
-        } else {
-            op->flags = CParserIsVolatileExpr(expr) ? OpndFlags_Volatile : 0;
-            op->flags |= CParserIsConstExpr(expr) ? OpndFlags_Const : 0;
-        }
-    } else {
-        op->flags = 0;
-    }
-}
-
-void symbol_operand(Operand *op, Object *obj) {
-    memclrw(op, sizeof(Operand));
-    op->optype = OpndType_Symbol;
-    op->object = obj;
-}
-
-void indirect(Operand *op, ENode *expr) {
-    switch (op->optype) {
-        case OpndType_GPRPair:
-            CError_FATAL(163);
-        case OpndType_CRField:
-        case OpndType_IndirectGPR_ImmOffset:
-        case OpndType_IndirectGPR_Indexed:
-        case OpndType_IndirectSymbol:
-            if (op->optype)
-                Coerce_to_register(op, TYPE(&void_ptr), 0);
-        case OpndType_GPR:
-            op->immOffset = 0;
-            op->object = NULL;
-        case OpndType_GPR_ImmOffset:
-            op->optype = OpndType_IndirectGPR_ImmOffset;
-            set_op_flags(op, expr);
-            break;
-        case OpndType_GPR_Indexed:
-            op->optype = OpndType_IndirectGPR_Indexed;
-            set_op_flags(op, expr);
-            break;
-        case OpndType_Absolute:
-            if (FITS_IN_SHORT(op->immediate)) {
-                op->reg = 0;
-                op->immOffset = op->immediate;
-            } else {
-                emitpcode(PC_LIS, op->reg = used_virtual_registers[RegClass_GPR]++, 0, (short) HIGH_PART(op->immediate));
-                op->immOffset = LOW_PART(op->immediate);
-            }
-            op->object = NULL;
-            op->optype = OpndType_IndirectGPR_ImmOffset;
-            set_op_flags(op, expr);
-            break;
-        case OpndType_Symbol:
-            op->optype = OpndType_IndirectSymbol;
-            set_op_flags(op, expr);
-            break;
-        default:
-            CError_FATAL(215);
-    }
-}
-
-#define COMBO_OP(a, b) (b + (a * 11))
-
-void combine(Operand *opA, Operand *opB, short output_reg, Operand *opOut) {
-    Operand *tmp_op;
-    int tmp;
-
-    if (opA->optype == OpndType_Symbol || opA->optype == OpndType_IndirectSymbol)
-        coerce_to_addressable(opA);
-    if (opB->optype == OpndType_Symbol || opB->optype == OpndType_IndirectSymbol)
-        coerce_to_addressable(opB);
-
-    switch (COMBO_OP(opA->optype, opB->optype)) {
-        case COMBO_OP(OpndType_GPR, OpndType_GPR):
-            opOut->optype = OpndType_GPR_Indexed;
-            opOut->reg = opA->reg;
-            opOut->regOffset = opB->reg;
-            break;
-        case COMBO_OP(OpndType_GPR_ImmOffset, OpndType_GPR_ImmOffset):
-            if (FITS_IN_SHORT(opA->immOffset + opB->immOffset) && (!opA->object || !opB->object)) {
-                opB->immOffset += opA->immOffset;
-                if (!opB->object)
-                    opB->object = opA->object;
-            } else {
-                tmp = (output_reg && (output_reg != opB->reg)) ? output_reg : used_virtual_registers[RegClass_GPR]++;
-                add_immediate(tmp, opA->reg, opA->object, opA->immOffset);
-                opA->reg = tmp;
-            }
-        case COMBO_OP(OpndType_GPR, OpndType_GPR_ImmOffset):
-            tmp_op = opA;
-            opA = opB;
-            opB = tmp_op;
-        case COMBO_OP(OpndType_GPR_ImmOffset, OpndType_GPR):
-            if (opA->reg == _FP_ || opA->reg == _CALLER_SP_) {
-                opOut->optype = OpndType_GPR_Indexed;
-                opOut->reg = (output_reg && (output_reg != opB->reg)) ? output_reg : used_virtual_registers[RegClass_GPR]++;
-                opOut->regOffset = opB->reg;
-                add_immediate(opOut->reg, opA->reg, opA->object, LOW_PART(opA->immOffset));
-            } else if (opB->reg == _FP_ || opB->reg == _CALLER_SP_) {
-                opOut->optype = OpndType_GPR_Indexed;
-                opOut->reg = (output_reg && (output_reg != opA->reg)) ? output_reg : used_virtual_registers[RegClass_GPR]++;
-                opOut->regOffset = opA->reg;
-                add_immediate(opOut->reg, opB->reg, opA->object, LOW_PART(opA->immOffset));
-            } else if (opA->object) {
-                opOut->optype = OpndType_GPR_Indexed;
-                opOut->reg = (output_reg && (output_reg != opB->reg)) ? output_reg : used_virtual_registers[RegClass_GPR]++;
-                opOut->regOffset = opB->reg;
-                add_immediate(opOut->reg, opA->reg, opA->object, LOW_PART(opA->immOffset));
-            } else {
-                opOut->optype = OpndType_GPR_ImmOffset;
-                opOut->reg = output_reg ? output_reg : used_virtual_registers[RegClass_GPR]++;
-                opOut->immOffset = opA->immOffset;
-                opOut->object = opA->object;
-                emitpcode(PC_ADD, opOut->reg, opA->reg, opB->reg);
-            }
-            break;
-        case COMBO_OP(OpndType_GPR, OpndType_GPR_Indexed):
-            tmp_op = opA;
-            opA = opB;
-            opB = tmp_op;
-        case COMBO_OP(OpndType_GPR_Indexed, OpndType_GPR):
-            opOut->optype = OpndType_GPR_Indexed;
-            opOut->reg = opA->reg;
-            opOut->regOffset = (output_reg && (output_reg != opA->reg)) ? output_reg : used_virtual_registers[RegClass_GPR]++;
-            emitpcode(PC_ADD, opOut->regOffset, opA->regOffset, opB->reg);
-            break;
-        case COMBO_OP(OpndType_GPR_ImmOffset, OpndType_GPR_Indexed):
-            tmp_op = opA;
-            opA = opB;
-            opB = tmp_op;
-        case COMBO_OP(OpndType_GPR_Indexed, OpndType_GPR_ImmOffset):
-            if (opB->object) {
-                opOut->optype = OpndType_GPR_Indexed;
-                opOut->reg = (output_reg && (output_reg != opB->reg)) ? output_reg
-                                                                      : used_virtual_registers[RegClass_GPR]++;
-                opOut->regOffset = used_virtual_registers[RegClass_GPR]++;
-                emitpcode(PC_ADD, opOut->reg, opA->reg, opA->regOffset);
-                add_immediate(opOut->regOffset, opB->reg, opB->object, opB->immOffset);
-            } else {
-                opOut->optype = OpndType_GPR_ImmOffset;
-                opOut->immOffset = opB->immOffset;
-                opOut->object = opB->object;
-                opOut->reg = (output_reg && (output_reg != opB->reg)) ? output_reg
-                                                                      : used_virtual_registers[RegClass_GPR]++;
-                emitpcode(PC_ADD, opOut->reg, opA->reg, opA->regOffset);
-                emitpcode(PC_ADD, opOut->reg, opOut->reg, opB->reg);
-            }
-            break;
-        case COMBO_OP(OpndType_GPR_Indexed, OpndType_GPR_Indexed):
-            opOut->optype = OpndType_GPR_Indexed;
-            opOut->reg = opA->reg;
-            opOut->regOffset = (output_reg && (output_reg != opA->regOffset)) ? output_reg
-                                                                              : used_virtual_registers[RegClass_GPR]++;
-            emitpcode(PC_ADD, opOut->regOffset, opB->reg, opB->regOffset);
-            emitpcode(PC_ADD, opOut->regOffset, opOut->regOffset, opA->regOffset);
-            break;
-        case COMBO_OP(OpndType_GPR_ImmOffset, OpndType_Absolute):
-            tmp_op = opA;
-            opA = opB;
-            opB = tmp_op;
-        case COMBO_OP(OpndType_Absolute, OpndType_GPR_ImmOffset):
-            if (!opB->object) {
-                opOut->optype = OpndType_GPR_ImmOffset;
-                opOut->reg = opB->reg;
-                opOut->immOffset = opB->immOffset;
-                opOut->object = opB->object;
-                if (FITS_IN_SHORT(opOut->immOffset + opA->immediate)) {
-                    opOut->immOffset += opA->immediate;
-                } else {
-                    opOut->reg = output_reg ? output_reg : used_virtual_registers[RegClass_GPR]++;
-                    if (!HIGH_PART(opA->immediate)) {
-                        emitpcode(PC_ADDI, opOut->reg, opB->reg, 0, LOW_PART(opA->immediate));
-                    } else {
-                        emitpcode(PC_ADDIS, opOut->reg, opB->reg, 0, (short) HIGH_PART(opA->immediate));
-                        if (FITS_IN_SHORT(opOut->immOffset + LOW_PART(opA->immediate))) {
-                            opOut->immOffset += LOW_PART(opA->immediate);
-                        } else {
-                            emitpcode(PC_ADDI, opOut->reg, opOut->reg, 0, LOW_PART(opA->immediate));
-                        }
-                    }
-                }
-                break;
-            } else if (opB->object->datatype == DLOCAL && can_add_displ_to_local(opB->object, opB->immOffset + opA->immediate)) {
-                opOut->optype = OpndType_GPR_ImmOffset;
-                opOut->object = opB->object;
-                opOut->reg = opB->reg;
-                opOut->immOffset = LOW_PART(opB->immOffset + opA->immediate);
-                break;
-            } else {
-                opOut->reg = output_reg ? output_reg : used_virtual_registers[RegClass_GPR]++;
-                add_immediate(opOut->reg, opB->reg, opB->object, opB->immOffset);
-                opB->optype = OpndType_GPR;
-                opB->reg = opOut->reg;
-                tmp_op = opA;
-                opA = opB;
-                opB = tmp_op;
-            }
-        case COMBO_OP(OpndType_GPR, OpndType_Absolute):
-            tmp_op = opA;
-            opA = opB;
-            opB = tmp_op;
-        case COMBO_OP(OpndType_Absolute, OpndType_GPR):
-            opOut->optype = (opA->immediate != 0) ? OpndType_GPR_ImmOffset : OpndType_GPR;
-            opOut->immOffset = LOW_PART(opA->immediate);
-            opOut->object = NULL;
-            if (FITS_IN_SHORT(opA->immediate)) {
-                opOut->reg = opB->reg;
-            } else {
-                opOut->reg = output_reg ? output_reg : used_virtual_registers[RegClass_GPR]++;
-                emitpcode(PC_ADDIS, opOut->reg, opB->reg, 0, (short) HIGH_PART(opA->immediate));
-            }
-            break;
-        case COMBO_OP(OpndType_GPR_Indexed, OpndType_Absolute):
-            tmp_op = opA;
-            opA = opB;
-            opB = tmp_op;
-        case COMBO_OP(OpndType_Absolute, OpndType_GPR_Indexed):
-            opOut->optype = OpndType_GPR_Indexed;
-            opOut->reg = opB->reg;
-            opOut->regOffset = (output_reg && (output_reg != opB->reg)) ? output_reg : used_virtual_registers[RegClass_GPR]++;
-            if (!HIGH_PART(opA->immediate)) {
-                emitpcode(PC_ADDI, opOut->regOffset, opB->regOffset, 0, LOW_PART(opA->immediate));
-            } else {
-                emitpcode(PC_ADDIS, opOut->regOffset, opB->regOffset, 0, (short) HIGH_PART(opA->immediate));
-                if (LOW_PART_BUGGY(opA->immediate))
-                    emitpcode(PC_ADDI, opOut->regOffset, opOut->regOffset, 0, LOW_PART(opA->immediate));
-            }
-            break;
-        case COMBO_OP(OpndType_Absolute, OpndType_Absolute):
-            opOut->optype = OpndType_Absolute;
-            opOut->immediate = opA->immediate + opB->immediate;
-            break;
-        default:
-            CError_FATAL(415);
-    }
-}
-
-void coerce_to_addressable(Operand *op) {
-    UInt32 offset;
-    short reg;
-    short flag;
-    short tmp;
-    Object *obj;
-
-    flag = 0;
-    obj = op->object;
-    tmp = 0;
-
-    switch (op->optype) {
-        case OpndType_GPR:
-        case OpndType_GPR_ImmOffset:
-        case OpndType_GPR_Indexed:
-        case OpndType_GPRPair:
-        case OpndType_Absolute:
-        case OpndType_VR:
-        case OpndType_CRField:
-        case OpndType_IndirectGPR_ImmOffset:
-        case OpndType_IndirectGPR_Indexed:
-            break;
-        case OpndType_IndirectSymbol:
-            flag = 1;
-        case OpndType_Symbol:
-            if (obj->datatype == DLOCAL) {
-                if (!local_is_16bit_offset(obj)) {
-                    reg = used_virtual_registers[RegClass_GPR]++;
-                    op_absolute_ha(reg, local_base_register(obj), obj, 0, 1);
-                    op->optype = OpndType_GPR_ImmOffset;
-                    op->reg = reg;
-                    op->object = obj;
-                } else {
-                    op->optype = OpndType_GPR_ImmOffset;
-                    op->reg = local_base_register(obj);
-                    op->object = obj;
-                }
-            } else if (obj->datatype == DABSOLUTE) {
-                offset = obj->u.address;
-                if (FITS_IN_SHORT(offset)) {
-                    op->reg = 0;
-                    op->immOffset = obj->u.address;
-                } else {
-                    emitpcode(PC_LIS, op->reg = used_virtual_registers[RegClass_GPR]++, 0, (short) HIGH_PART(offset));
-                    op->immOffset = LOW_PART(obj->u.address);
-                }
-                op->object = obj;
-                op->optype = OpndType_GPR_ImmOffset;
-            } else {
-                if (copts.codegen_pic)
-                    tmp = pic_base_reg;
-                reg = used_virtual_registers[RegClass_GPR]++;
-                op_absolute_ha(reg, tmp, obj, 0, 1);
-                op->optype = OpndType_GPR_ImmOffset;
-                op->reg = reg;
-            }
-            if (flag) {
-                if (op->optype == OpndType_GPR_ImmOffset) {
-                    op->optype = OpndType_IndirectGPR_ImmOffset;
-                } else {
-                    CError_FATAL(563);
-                }
-            }
-            break;
-        default:
-            CError_FATAL(581);
-    }
-}
-
-void Coerce_to_register(Operand *op, Type *type, short output_reg) {
-    SInt32 offset;
-    Opcode opcode;
-    short reg;
-    short tmp;
-    short cond_neg;
-    short cond;
-    short bit_offset;
-    short bit_size;
-
-    if (TYPE_IS_8BYTES(type)) {
-        coerce_to_register_pair(op, type, output_reg, 0);
-        return;
-    }
-
-    coerce_to_addressable(op);
-    switch (op->optype) {
-        case OpndType_GPRPair:
-            return;
-        case OpndType_GPR:
-            return;
-        case OpndType_GPR_ImmOffset:
-            reg = output_reg ? output_reg : used_virtual_registers[RegClass_GPR]++;
-            add_immediate(reg, op->reg, op->object, op->immOffset);
-            break;
-        case OpndType_GPR_Indexed:
-            reg = output_reg ? output_reg : used_virtual_registers[RegClass_GPR]++;
-            emitpcode(PC_ADD, reg, op->reg, op->regOffset);
-            break;
-        case OpndType_Absolute:
-            reg = output_reg ? output_reg : used_virtual_registers[RegClass_GPR]++;
-            offset = op->immediate;
-            if (FITS_IN_SHORT(offset)) {
-                emitpcode(PC_LI, reg, offset);
-            } else {
-                tmp = reg;
-                if (copts.optimizationlevel > 1 && LOW_PART_BUGGY(offset))
-                    tmp = used_virtual_registers[RegClass_GPR]++;
-                emitpcode(PC_LIS, tmp, 0, (short) HIGH_PART(offset));
-                if (LOW_PART_BUGGY(offset))
-                    emitpcode(PC_ADDI, reg, tmp, 0, LOW_PART(offset));
-            }
-            break;
-        case OpndType_IndirectGPR_ImmOffset:
-            reg = output_reg ? output_reg : used_virtual_registers[RegClass_GPR]++;
-            opcode = PC_LWZ;
-            if (IS_TYPE_INT(type) || IS_TYPE_ENUM(type)) {
-                switch (type->size) {
-                    case 1:
-                        opcode = PC_LBZ;
-                        break;
-                    case 2:
-                        if (is_unsigned(type))
-                            opcode = PC_LHZ;
-                        else
-                            opcode = PC_LHA;
-                        break;
-                }
-            } else {
-                CError_ASSERT(680, IS_TYPE_POINTER(type) || IS_TYPE_4BYTES_MEMBERPOINTER(type));
-            }
-            load_store_register(opcode, reg, op->reg, op->object, op->immOffset);
-            setpcodeflags(op->flags);
-            break;
-        case OpndType_IndirectGPR_Indexed:
-            reg = output_reg ? output_reg : used_virtual_registers[RegClass_GPR]++;
-            opcode = PC_LWZX;
-            if (IS_TYPE_INT(type) || IS_TYPE_ENUM(type)) {
-                switch (type->size) {
-                    case 1:
-                        opcode = PC_LBZX;
-                        break;
-                    case 2:
-                        if (is_unsigned(type))
-                            opcode = PC_LHZX;
-                        else
-                            opcode = PC_LHAX;
-                        break;
-                }
-            } else {
-                CError_ASSERT(724, IS_TYPE_POINTER(type) || IS_TYPE_4BYTES_MEMBERPOINTER(type));
-            }
-            emitpcode(opcode, reg, op->reg, op->regOffset);
-            setpcodeflags(op->flags);
-            break;
-        case OpndType_CRField:
-            cond_neg = 0;
-            cond = 0;
-            reg = output_reg ? output_reg : used_virtual_registers[RegClass_GPR]++;
-            emitpcode(PC_MFCR, tmp = reg);
-            switch (op->regOffset) {
-                case ENOTEQU:
-                    cond_neg = 1;
-                case EEQU:
-                    cond = 2;
-                    break;
-                case EGREATEREQU:
-                    cond_neg = 1;
-                case ELESS:
-                    cond = 0;
-                    break;
-                case ELESSEQU:
-                    cond_neg = 1;
-                case EGREATER:
-                    cond = 1;
-                    break;
-                default:
-                    CError_FATAL(758);
-            }
-            bit_offset = cond + (op->reg << 2);
-            bit_size = 1;
-            emitpcode(PC_RLWINM, tmp, tmp, (bit_size + bit_offset) & 31, 32 - bit_size, 31);
-            if (cond_neg)
-                emitpcode(PC_XORI, tmp, tmp, 1);
-            break;
-        default:
-            CError_FATAL(769);
-    }
-
-    op->optype = OpndType_GPR;
-    op->reg = reg;
-}
-
-void coerce_to_register_pair(Operand *op, Type *type, short output_reg, short output_regHi) {
-    SInt32 offset;
-    short reg;
-    short regHi;
-    short tmp1;
-    short tmp2;
-
-    regHi = -1;
-
-    CError_ASSERT(794, TYPE_IS_8BYTES(type) || (IS_TYPE_STRUCT(type) && type->size == 8));
-
-    coerce_to_addressable(op);
-    switch (op->optype) {
-        case OpndType_GPRPair:
-            if (output_reg && !output_regHi)
-                output_regHi = used_virtual_registers[RegClass_GPR]++;
-            if (output_regHi && !output_reg)
-                output_reg = used_virtual_registers[RegClass_GPR]++;
-            if (op->reg != output_reg || op->regHi != output_regHi) {
-                tmp1 = output_reg ? output_reg : op->reg;
-                tmp2 = output_regHi ? output_regHi : op->regHi;
-                if (tmp1 != op->reg) {
-                    if (tmp1 == op->regHi) {
-                        CError_ASSERT(818, tmp1 != tmp2);
-                        emitpcode(PC_MR, tmp2, op->regHi);
-                        emitpcode(PC_MR, tmp1, op->reg);
-                    } else {
-                        emitpcode(PC_MR, tmp1, op->reg);
-                        if (op->regHi != tmp2)
-                            emitpcode(PC_MR, tmp2, op->regHi);
-                    }
-                } else if (tmp2 != op->regHi) {
-                    if (tmp2 == op->reg) {
-                        CError_ASSERT(832, tmp1 != tmp2);
-                        emitpcode(PC_MR, tmp1, op->reg);
-                        emitpcode(PC_MR, tmp2, op->regHi);
-                    } else {
-                        emitpcode(PC_MR, tmp2, op->regHi);
-                        if (op->reg != tmp1)
-                            emitpcode(PC_MR, tmp1, op->reg);
-                    }
-                }
-            }
-            reg = op->reg;
-            regHi = op->regHi;
-            break;
-        case OpndType_GPR:
-            CError_FATAL(849);
-            break;
-        case OpndType_GPR_ImmOffset:
-            CError_FATAL(852);
-            break;
-        case OpndType_GPR_Indexed:
-            CError_FATAL(855);
-            break;
-        case OpndType_Absolute:
-            reg = output_reg ? output_reg : used_virtual_registers[RegClass_GPR]++;
-            offset = op->immediate;
-            if (FITS_IN_SHORT(offset)) {
-                emitpcode(PC_LI, reg, offset);
-            } else {
-                tmp1 = reg;
-                if (copts.optimizationlevel > 1 && LOW_PART_BUGGY(offset))
-                    tmp1 = used_virtual_registers[RegClass_GPR]++;
-                emitpcode(PC_LIS, tmp1, 0, (short) HIGH_PART(offset));
-                if (LOW_PART_BUGGY(offset))
-                    emitpcode(PC_ADDI, reg, tmp1, 0, LOW_PART(offset));
-            }
-            regHi = output_regHi ? output_regHi : used_virtual_registers[RegClass_GPR]++;
-            if (is_unsigned(type) || offset >= 0)
-                load_immediate(regHi, 0);
-            else
-                load_immediate(regHi, -1);
-            break;
-        case OpndType_IndirectGPR_ImmOffset:
-            reg = output_reg ? output_reg : used_virtual_registers[RegClass_GPR]++;
-            regHi = output_regHi ? output_regHi : used_virtual_registers[RegClass_GPR]++;
-            if (op->reg == regHi) {
-                if (op->reg == reg) {
-                    CError_FATAL(887);
-                } else {
-                    load_store_register(PC_LWZ, reg, op->reg, op->object, op->immOffset + low_offset);
-                    setpcodeflags(op->flags);
-                    load_store_register(PC_LWZ, regHi, op->reg, op->object, op->immOffset + high_offset);
-                    setpcodeflags(op->flags);
-                }
-            } else {
-                load_store_register(PC_LWZ, regHi, op->reg, op->object, op->immOffset + high_offset);
-                setpcodeflags(op->flags);
-                load_store_register(PC_LWZ, reg, op->reg, op->object, op->immOffset + low_offset);
-                setpcodeflags(op->flags);
-            }
-            break;
-        case OpndType_IndirectGPR_Indexed:
-            reg = output_reg ? output_reg : used_virtual_registers[RegClass_GPR]++;
-            regHi = output_regHi ? output_regHi : used_virtual_registers[RegClass_GPR]++;
-            emitpcode(PC_ADD, reg, op->reg, op->regOffset);
-            load_store_register(PC_LWZ, regHi, reg, NULL, high_offset);
-            setpcodeflags(op->flags);
-            load_store_register(PC_LWZ, reg, reg, NULL, low_offset);
-            setpcodeflags(op->flags);
-            break;
-        default:
-            CError_FATAL(912);
-    }
-
-    if (regHi == -1) {
-        CError_FATAL(916);
-    } else {
-        op->optype = OpndType_GPRPair;
-        op->reg = reg;
-        op->regHi = regHi;
-    }
-}
-
-void Coerce_to_fp_register(Operand *op, Type *type, short output_reg) {
-    short reg;
-
-    coerce_to_addressable(op);
-
-    switch (op->optype) {
-        case OpndType_FPR:
-            reg = op->reg;
-            break;
-        case OpndType_IndirectGPR_ImmOffset:
-            reg = output_reg ? output_reg : used_virtual_registers[RegClass_FPR]++;
-            load_store_register((type->size == 4) ? PC_LFS : PC_LFD, reg, op->reg, op->object, op->immOffset);
-            setpcodeflags(op->flags);
-            break;
-        case OpndType_IndirectGPR_Indexed:
-            reg = output_reg ? output_reg : used_virtual_registers[RegClass_FPR]++;
-            emitpcode((type->size == 4) ? PC_LFSX : PC_LFDX, reg, op->reg, op->regOffset, 0, 0x390);
-            setpcodeflags(op->flags);
-            break;
-        default:
-            CError_FATAL(986);
-    }
-
-    op->optype = OpndType_FPR;
-    op->reg = reg;
-}
-
-void Coerce_to_v_register(Operand *op, Type *type, short output_reg) {
-    short reg;
-
-    coerce_to_addressable(op);
-
-    switch (op->optype) {
-        case OpndType_VR:
-            reg = op->reg;
-            break;
-        case OpndType_IndirectGPR_ImmOffset:
-            reg = output_reg ? output_reg : used_virtual_registers[RegClass_VR]++;
-            load_store_register(PC_LVX, reg, op->reg, op->object, op->immOffset);
-            setpcodeflags(op->flags);
-            break;
-        case OpndType_IndirectGPR_Indexed:
-            reg = output_reg ? output_reg : used_virtual_registers[RegClass_VR]++;
-            emitpcode(PC_LVX, reg, op->reg, op->regOffset);
-            setpcodeflags(op->flags);
-            break;
-        case OpndType_Absolute:
-            reg = output_reg ? output_reg : used_virtual_registers[RegClass_VR]++;
-            switch (TYPE_STRUCT(type)->stype) {
-                case STRUCT_VECTOR_UCHAR:
-                case STRUCT_VECTOR_SCHAR:
-                case STRUCT_VECTOR_BCHAR:
-                    emitpcode(PC_VSPLTISB, reg, op->immediate);
-                    break;
-                case STRUCT_VECTOR_USHORT:
-                case STRUCT_VECTOR_SSHORT:
-                case STRUCT_VECTOR_BSHORT:
-                case STRUCT_VECTOR_PIXEL:
-                    emitpcode(PC_VSPLTISH, reg, op->immediate);
-                    break;
-                case STRUCT_VECTOR_UINT:
-                case STRUCT_VECTOR_SINT:
-                case STRUCT_VECTOR_BINT:
-                case STRUCT_VECTOR_FLOAT:
-                    emitpcode(PC_VSPLTISW, reg, op->immediate);
-                    break;
-                default:
-                    CError_FATAL(1049);
-            }
-            op->optype = OpndType_VR;
-            op->reg = reg;
-            setpcodeflags(op->flags);
-            break;
-        default:
-            CError_FATAL(1059);
-    }
-
-    op->optype = OpndType_VR;
-    op->reg = reg;
-}
-
-void store(short reg, Operand *op, Type *type) {
-    Opcode opcode;
-
-    coerce_to_addressable(op);
-    switch (op->optype) {
-        case OpndType_IndirectGPR_ImmOffset:
-            opcode = PC_STW;
-            if (IS_TYPE_INT(type) || IS_TYPE_ENUM(type)) {
-                switch (type->size) {
-                    case 1:
-                        opcode = PC_STB;
-                        break;
-                    case 2:
-                        opcode = PC_STH;
-                        break;
-                }
-            } else {
-                CError_ASSERT(1171, IS_TYPE_POINTER(type) || IS_TYPE_4BYTES_MEMBERPOINTER(type));
-            }
-            load_store_register(opcode, reg, op->reg, op->object, op->immOffset);
-            setpcodeflags(op->flags);
-            break;
-        case OpndType_IndirectGPR_Indexed:
-            opcode = PC_STWX;
-            if (IS_TYPE_INT(type) || IS_TYPE_ENUM(type)) {
-                switch (type->size) {
-                    case 1:
-                        opcode = PC_STBX;
-                        break;
-                    case 2:
-                        opcode = PC_STHX;
-                        break;
-                }
-            } else {
-                CError_ASSERT(1188, IS_TYPE_POINTER(type) || IS_TYPE_4BYTES_MEMBERPOINTER(type));
-            }
-            emitpcode(opcode, reg, op->reg, op->regOffset);
-            setpcodeflags(op->flags);
-            break;
-        default:
-            CError_FATAL(1193);
-    }
-}
-
-void store_pair(short reg, short regHi, Operand *op, Type *type) {
-    short tmp;
-
-    CError_ASSERT(1208, TYPE_IS_8BYTES(type));
-
-    coerce_to_addressable(op);
-    switch (op->optype) {
-        case OpndType_IndirectGPR_ImmOffset:
-            load_store_register(PC_STW, reg, op->reg, op->object, op->immOffset + low_offset);
-            setpcodeflags(op->flags);
-            load_store_register(PC_STW, regHi, op->reg, op->object, op->immOffset + high_offset);
-            setpcodeflags(op->flags);
-            break;
-        case OpndType_IndirectGPR_Indexed:
-            tmp = used_virtual_registers[RegClass_GPR]++;
-            emitpcode(PC_ADD, tmp, op->reg, op->regOffset);
-            load_store_register(PC_STW, reg, tmp, NULL, low_offset);
-            setpcodeflags(op->flags);
-            load_store_register(PC_STW, regHi, tmp, NULL, high_offset);
-            setpcodeflags(op->flags);
-            break;
-        default:
-            CError_FATAL(1228);
-    }
-}
-
-void store_fp(short reg, Operand *op, Type *type) {
-    coerce_to_addressable(op);
-    switch (op->optype) {
-        case OpndType_IndirectGPR_ImmOffset:
-            load_store_register((type->size == 4) ? PC_STFS : PC_STFD, reg, op->reg, op->object, op->immOffset);
-            setpcodeflags(op->flags);
-            break;
-        case OpndType_IndirectGPR_Indexed:
-            emitpcode((type->size == 4) ? PC_STFSX : PC_STFDX, reg, op->reg, op->regOffset);
-            setpcodeflags(op->flags);
-            break;
-        default:
-            CError_FATAL(1259);
-    }
-}
-
-void store_v(short reg, Operand *op, Type *tstruct) {
-    coerce_to_addressable(op);
-    switch (op->optype) {
-        case OpndType_IndirectGPR_ImmOffset:
-            load_store_register(PC_STVX, reg, op->reg, op->object, op->immOffset);
-            setpcodeflags(op->flags);
-            break;
-        case OpndType_IndirectGPR_Indexed:
-            emitpcode(PC_STVX, reg, op->reg, op->regOffset);
-            setpcodeflags(op->flags);
-            break;
-        default:
-            CError_FATAL(1283);
-    }
-}
-
-static Boolean last_matches_rlwinm_or_exts(Operand *op, short opcode, short b, short c) {
-    PCode *pc;
-
-    if (pclastblock->pcodeCount <= 0)
-        return 0;
-
-    pc = pclastblock->lastPCode;
-    if (pc->args[0].kind != PCOp_REGISTER || pc->args[0].arg != RegClass_GPR || pc->args[0].data.reg.reg != op->reg)
-        return 0;
-
-    if (pc->op != opcode && (opcode != PC_EXTSH || pc->op != PC_EXTSB))
-        return 0;
-
-    if (opcode == PC_RLWINM) {
-        if (pc->args[2].data.imm.value != 0 || pc->args[3].data.imm.value != b || pc->args[4].data.imm.value != c)
-            return 0;
-    }
-
-    return 1;
-}
-
-void extend32(Operand *op, Type *type, short output_reg) {
-    int r28;
-    int reg;
-
-    r28 = op->optype >= OpndType_IndirectGPR_ImmOffset;
-    if (op->optype != OpndType_GPR)
-        Coerce_to_register(op, type, output_reg);
-
-    switch (type->size) {
-        case 1:
-            if (is_unsigned(type)) {
-                if (r28)
-                    return;
-                if (last_matches_rlwinm_or_exts(op, PC_RLWINM, 24, 31))
-                    return;
-                reg = output_reg ? output_reg : used_virtual_registers[RegClass_GPR]++;
-                emitpcode(PC_RLWINM, reg, op->reg, 0, 24, 31);
-            } else {
-                reg = output_reg ? output_reg : used_virtual_registers[RegClass_GPR]++;
-                if (last_matches_rlwinm_or_exts(op, PC_EXTSB, 0, 0))
-                    return;
-                emitpcode(PC_EXTSB, reg, op->reg);
-            }
-            break;
-        case 2:
-            if (r28)
-                return;
-            if (is_unsigned(type)) {
-                if (last_matches_rlwinm_or_exts(op, PC_RLWINM, 16, 31))
-                    return;
-                reg = output_reg ? output_reg : used_virtual_registers[RegClass_GPR]++;
-                emitpcode(PC_RLWINM, reg, op->reg, 0, 16, 31);
-            } else {
-                if (last_matches_rlwinm_or_exts(op, PC_EXTSH, 0, 0))
-                    return;
-                reg = output_reg ? output_reg : used_virtual_registers[RegClass_GPR]++;
-                emitpcode(PC_EXTSH, reg, op->reg);
-            }
-            break;
-        default:
-            CError_FATAL(1389);
-    }
-
-    op->optype = OpndType_GPR;
-    op->reg = reg;
-}
-
-void extend64(Operand *op, Type *type, short output_reg, short output_regHi) {
-    short tmp;
-    short regHi;
-
-    if (op->optype != OpndType_GPR)
-        Coerce_to_register(op, type, output_reg);
-
-    regHi = output_regHi ? output_regHi : used_virtual_registers[RegClass_GPR]++;
-    if (regHi == op->reg) {
-        tmp = output_reg ? output_reg : used_virtual_registers[RegClass_GPR]++;
-        emitpcode(PC_MR, tmp, op->reg);
-        op->reg = tmp;
-    }
-
-    if (is_unsigned(type))
-        load_immediate(regHi, 0);
-    else
-        emitpcode(PC_SRAWI, regHi, op->reg, 31);
-
-    op->optype = OpndType_GPRPair;
-    op->regHi = regHi;
-}
-
-void load_floating_constant(short reg, Type *type, Float *data) {
-    Object *object;
-    Object *indObject;
-    Operand op1;
-    Operand op2;
-    Operand op3;
-    SInt32 offset = 0;
-
-    memclrw(&op1, sizeof(Operand));
-
-    object = CreateFloatConst(type, data, &offset);
-    indObject = createIndirect(object, 0, 1);
-
-    if (indObject) {
-        symbol_operand(&op1, indObject);
-        indirect(&op1, NULL);
-    } else {
-        symbol_operand(&op1, object);
-    }
-
-    if (offset) {
-        op2 = op1;
-        memclrw(&op3, sizeof(Operand));
-        op3.optype = OpndType_Absolute;
-        op3.immediate = offset;
-        if (op2.optype != OpndType_GPR)
-            Coerce_to_register(&op2, TYPE(&void_ptr), 0);
-        combine(&op2, &op3, 0, &op1);
-    }
-
-    indirect(&op1, NULL);
-    if (op1.optype != OpndType_FPR)
-        Coerce_to_fp_register(&op1, type, reg);
-}
-
-void convert_integer_to_floating(Operand *op, Boolean is_single, short output_reg) {
-    Operand temp_op;
-    Float d;
-    int const_reg;
-    int tmp_reg;
-    int work_reg;
-    int result_reg;
-    Opcode opcode;
-
-    symbol_operand(&temp_op, maketemporary(TYPE(&stdouble)));
-    coerce_to_addressable(&temp_op);
-    d.value = *((double *) &int_to_float_cc);
-
-    const_reg = used_virtual_registers[RegClass_FPR]++;
-    load_floating_constant(const_reg, TYPE(&stdouble), &d);
-
-    tmp_reg = used_virtual_registers[RegClass_GPR]++;
-    emitpcode(PC_XORIS, tmp_reg, op->reg, 0x8000);
-    load_store_register(PC_STW, tmp_reg, temp_op.reg, temp_op.object, low_offset);
-
-    emitpcode(PC_LIS, tmp_reg = used_virtual_registers[RegClass_GPR]++, 0, 0x4330);
-    load_store_register(PC_STW, tmp_reg, temp_op.reg, temp_op.object, high_offset);
-
-    load_store_register(PC_LFD, work_reg = used_virtual_registers[RegClass_FPR]++, temp_op.reg, temp_op.object, 0);
-
-    result_reg = output_reg ? output_reg : used_virtual_registers[RegClass_FPR]++;
-    if (is_single != 0)
-        opcode = PC_FSUBS;
-    else
-        opcode = PC_FSUB;
-    emitpcode(opcode, result_reg, work_reg, const_reg);
-
-    op->optype = OpndType_FPR;
-    op->reg = result_reg;
-}
-
-void convert_unsigned_to_floating(Operand *op, Boolean is_single, short output_reg) {
-    Operand temp_op;
-    Float d;
-    int const_reg;
-    int tmp_reg;
-    int work_reg;
-    int result_reg;
-    Opcode opcode;
-
-    symbol_operand(&temp_op, maketemporary(TYPE(&stdouble)));
-    coerce_to_addressable(&temp_op);
-    d.value = *((double *) &uns_to_float_cc);
-
-    const_reg = used_virtual_registers[RegClass_FPR]++;
-    load_floating_constant(const_reg, TYPE(&stdouble), &d);
-
-    load_store_register(PC_STW, op->reg, temp_op.reg, temp_op.object, low_offset);
-
-    emitpcode(PC_LIS, tmp_reg = used_virtual_registers[RegClass_GPR]++, 0, 0x4330);
-    load_store_register(PC_STW, tmp_reg, temp_op.reg, temp_op.object, high_offset);
-
-    load_store_register(PC_LFD, work_reg = used_virtual_registers[RegClass_FPR]++, temp_op.reg, temp_op.object, 0);
-
-    result_reg = output_reg ? output_reg : used_virtual_registers[RegClass_FPR]++;
-    if (is_single != 0)
-        opcode = PC_FSUBS;
-    else
-        opcode = PC_FSUB;
-    emitpcode(opcode, result_reg, work_reg, const_reg);
-
-    op->optype = OpndType_FPR;
-    op->reg = result_reg;
-}
-
-void convert_floating_to_integer(Operand *op, short output_reg) {
-    Operand temp_op;
-    int tmp_reg;
-    int result_reg;
-
-    symbol_operand(&temp_op, maketemporary(TYPE(&stdouble)));
-    coerce_to_addressable(&temp_op);
-
-    tmp_reg = used_virtual_registers[RegClass_FPR]++;
-    emitpcode(PC_FCTIWZ, tmp_reg, op->reg);
-    load_store_register(PC_STFD, tmp_reg, temp_op.reg, temp_op.object, 0);
-
-    result_reg = output_reg ? output_reg : used_virtual_registers[RegClass_GPR]++;
-    load_store_register(PC_LWZ, result_reg, temp_op.reg, temp_op.object, low_offset);
-
-    op->optype = OpndType_GPR;
-    op->reg = result_reg;
-}
-
-void convert_floating_to_unsigned(Operand *op, short output_reg) {
-    static UInt32 used_regs[RegClassMax] = {0, 0, 0, 2, 0};
-
-    if (op->reg != 1)
-        emitpcode(PC_FMR, 1, op->reg);
-
-    branch_subroutine(rt_cvt_fp2unsigned, 0, used_regs);
-
-    op->optype = OpndType_GPR;
-    op->reg = used_virtual_registers[RegClass_GPR]++;
-    emitpcode(PC_MR, op->reg, 3);
-}
-
-void extract_bitfield(Operand *input_op, TypeBitfield *tbitfield, short output_reg, Operand *output_op) {
-    int r27;
-    int offset;
-    int tmp_reg;
-    int output;
-
-    offset = tbitfield->bitlength;
-    output = output_reg ? output_reg : used_virtual_registers[RegClass_GPR]++;
-    r27 = tbitfield->offset + (32 - (tbitfield->bitfieldtype->size * 8));
-    if (is_unsigned(tbitfield->bitfieldtype)) {
-        emitpcode(PC_RLWINM, output, input_op->reg, (r27 + offset) & 31, 32 - offset, 31);
-    } else if (r27 == 0) {
-        emitpcode(PC_SRAWI, output, input_op->reg, 32 - offset);
-    } else {
-        tmp_reg = used_virtual_registers[RegClass_GPR]++;
-        emitpcode(PC_RLWINM, tmp_reg, input_op->reg, r27 & 31, 0, offset);
-        emitpcode(PC_SRAWI, output, tmp_reg, 32 - offset);
-    }
-
-    output_op->optype = OpndType_GPR;
-    output_op->reg = output;
-}
-
-void insert_bitfield(short reg, Operand *op, TypeBitfield *tbitfield) {
-    int offset = tbitfield->bitlength;
-    int r7 = tbitfield->offset + (32 - (tbitfield->bitfieldtype->size * 8));
-    emitpcode(PC_RLWIMI, op->reg, reg, 32 - (r7 + offset), r7, r7 + offset - 1);
-}
-
-void load_address(short dest_reg, Operand *op) {
-    coerce_to_addressable(op);
-    if (op->optype == OpndType_IndirectGPR_ImmOffset) {
-        if (!op->immOffset && !op->object) {
-            if (op->reg != dest_reg)
-                emitpcode(PC_MR, dest_reg, op->reg);
-        } else {
-            add_immediate(dest_reg, op->reg, op->object, (SInt16) op->immOffset);
-        }
-    } else if (op->optype == OpndType_IndirectGPR_Indexed) {
-        emitpcode(PC_ADD, dest_reg, op->reg, op->regOffset);
-    } else {
-        CError_FATAL(1849);
-    }
-}