~pmdj/ubuntu/trusty/qemu/2.9+applesmc+fadtv3

andi (\ra), (\ra), (((0xffffffffffffffff >> 0) & (0xffffffffffffffff << (63 - (\me)))) | ((0xffffffffffffffff >> (\mb)) & (0xffffffffffffffff << (63 - 63))))

973

.endif

974

975

.endif

976

977

.endm

978

979

// RLDINM Extended Mnemonics

980

981

// Defined as if they were equivalent to PowerPC 32-bit extended

982

// mnemonics

983

984

.macro extldi, ra:req, rs:req, n:req, b:req

985

.if ((\n) < 0)

986

.error "EXTLDI requires N > 0"

987

.endif

988

rldinm (\ra), (\rs), (\b), 0, ((\n) - 1)

989

.endm

990

991

.macro extrdi, ra:req, rs:req, n:req, b:req

992

.if ((\n) < 0)

993

.error "EXTRDI requires N > 0"

994

.endif

995

rldinm (\ra), (\rs), (((\b) + (\n)) % 64), (64 - (\n)), 63

996

.endm

997

998

.macro rotldi, ra:req, rs:req, n:req

999

rldinm (\ra), (\rs), (\n), 0, 63

1000

.endm

1001

1002

1003

.macro rotrdi, ra:req, rs:req, n:req

1004

rldinm (\ra), (\rs), (64 - (\n)), 0, 63

1005

.endm

1006

1007

1008

.macro sldi, ra:req, rs:req, n:req

1009

rldinm (\ra), (\rs), (\n), 0, (63 - (\n))

1010

.endm

1011

1012

1013

.macro srdi, ra:req, rs:req, n:req

1014

rldinm (\ra), (\rs), (64 - (\n)), (\n), 63

1015

.endm

1016

1017

1018

// RLDIMI RA, RS, SH, MB, ME

1019

1020

// Defined as if there were an equivalent PowerPC instruction. The

1021

// 'word' forms of the PowerPC instructions and extended mnemonics are

1022

// undefined in order to catch programming typos.

1023

1024

// Note that unlike the PowerPC instructions, here RLDIMI must destroy

1025

// RS by masking and shifting it, and RA and RS may not be the same

1026

// register.

1027

1028

.undefppc rlwimi, inslwi, insrwi

1029

1030

.macro rldimi, ra:req, rs:req, sh:req, mb:req, me:req

1031

1032

..dxdy (\ra), (\rs)

1033

1034

// SH error checks are done by rldinm

1035

1036

.if (((\mb) == 0) && ((\me) == 63) || ((\me) == ((\mb) - 1)))

1037

1038

// The mask is effectively 0..63, i.e., no mask. This is a

1039

// simple rotate of RS into RA

1040

1041

rotldi (\ra), (\rs), (\sh)

1042

1043

.else

1044

1045

// Rotate RS and AND with mask

1046

1047

rldinm (\rs), (\rs), (\sh), (\mb), (\me)

1048

1049

// Mask out the significant bits of RS, clear that section of

1050

// RA, and logical OR RS into RA

1051

1052

.if ((\mb) <= (\me))

1053

1054

// This is a straightforward masking operation with a

1055

// single mask.

1056

1057

andi (\ra), (\ra), \

1058

(~((0xffffffffffffffff >> (\mb)) & (0xffffffffffffffff << (63 - (\me)))))

1059

.else

1060

1061

// This is a wrapped mask.

1062

// It is created as 2 masks OR-ed together - 0-ME and MB-63

1063

1064

andi (\ra), (\ra), \

1065

(~(((0xffffffffffffffff >> 0) & (0xffffffffffffffff << (63 - (\me)))) | \

1066

((0xffffffffffffffff >> (\mb)) & (0xffffffffffffffff << (63 - 63)))))

1067

.endif

1068

1069

or (\ra), D0, D1

1070

1071

.endif

1072

1073

.endm

1074

1075

// RLDIMI Extended Mnemonics

1076

1077

// Defined as if they were equivalent to PowerPC 32-bit extended

1078

// mnemonics

1079

1080

.macro insldi, ra:req, rs:req, n:req, b:req

1081

.if ((\n) < 0)

1082

.error "INSLDI requires N > 0"

1083

.endif

1084

rldimi (\ra), (\rs), (64 - (\b)), (\b), ((\b) + (\n) - 1)

1085

.endm

1086

1087

.macro insrdi, ra:req, rs:req, n:req, b:req

1088

.if ((\n) < 0)

1089

.error "INSRDI requires N > 0"

1090

.endif

1091

rldimi (\ra), (\rs), (64 - (\b) - (\n)), (\b), ((\b) + (\n) - 1)

1092

.endm

1093

1094

1095

//////////////////////////////////////////////////////////////////////

1096

// .HOOK

1097

//////////////////////////////////////////////////////////////////////

1098

1099

// The PoreVe (PORE Virtual Environment) is a PORE simulation

1100

// environment that allows the programmer to embed C/C++ code into the

1101

// PORE assembler source code, and arranges for the C/C++ code to be

1102

// executed in-line with the PORE assembly code. Instances of the

1103

// .hook macro are inserted into the assembler input by the

1104

// hook_extractor script, to mark the locations where hooks are

1105

// present. The hook reference is a string that combines the source

1106

// file name with an index number to uniquely identify the hook.

1107

1108

// .hook <file name>_<sequence number>

1109

1110

// The .hook macro marks the location of each hook in the relocatable

1111

// binaries with special symbols. The symbol name includes the hook

1112

// reference, which is used to locate the hook in the HookManager

1113

// symbol table. Because hooks can be defined in macros, a hook that

1114

// appears once in a source file may appear multiple times in the

1115

// final binary. For this reason each hook must also be tagged with a

1116

// unique index number to avoid symbol name collisions. The

1117

// complexity of the .hook macro is due to the necessity to decode a

1118

// dynamic symbol value (_PGAS_HOOK_INDEX) into its binary string form

1119

// to create the unique symbol name. The final hook symbol has the

1120

// form:

1121

1122

// __hook__<unique>_<reference>

1123

1124

// where <unique> is a binary string. It is then straightforward to

1125

// locate these symbols in the 'nm' output of the final link and

1126

// create a map of final addresses to the hook routine to call (the

1127

// <reference>) before executing the instruction at that address.

1128

1129

// Note: The maximum nesting depth of the recursive ..hook_helper

1130

// macro is log2(index), and the assembler supports nesting of at

1131

// least 32 which is much more than sufficient.

1132

1133

.set _PGAS_HOOK_INDEX, 0

1134

1135

.macro .hook, reference:req

1136

.set _PGAS_HOOK_INDEX, (_PGAS_HOOK_INDEX + 1)

1137

..hook_helper _PGAS_HOOK_INDEX, "", \reference

1138

.endm

1139

1140

.macro ..hook_helper, index, unique, reference

1141

.ifeq \index

1142

__hook__\unique\()_\reference\():

1143

.elseif (\index % 2)

1144

..hook_helper (\index / 2), 1\unique, \reference

1145

.else

1146

..hook_helper (\index / 2), 0\unique, \reference

1147

.endif

1148

.endm

1149

1150

1151

////////////////////////////////////////////////////////////////////////////

1152

// Help for Conversion from Old to New PGAS syntax

1153

////////////////////////////////////////////////////////////////////////////

1154

1155

.macro loadp, arg:vararg

1156

.error "PGAS now implements 'lpcs' rather then 'loadp'"

1157

.endm

1158

1159

.macro loadx, arg:vararg

1160

.error "PGAS now implements 'la' rather than 'loadx'"

1161

.endm

1162

1163

#endif // __ASSEMBLER__

1164

1165

#ifdef PGAS_PPC

1166

#include "pgas_ppc.h"

1167

#endif

1168

1169

#endif // __PGAS_H__

Older »