PTO-TILE-MODEL-LEGALITY-LAYOUT-REARRANGEMENT

1// PTO-UNIT: {"id":"PTO-TILE-MODEL-LEGALITY-LAYOUT-REARRANGEMENT","surface":"tile","classification":["model","legality","layout-rearrangement"],"depends_on":["PTO-TILE-MODEL-LEGALITY-DTYPE-LAYOUT"]}2
3readonly func TileOperandsLegal_TEXTRACT(4    destination: TileIndex,5    source: TileIndex,6    row_offset: integer {0..65535},7    column_offset: integer {0..65535}) => boolean8begin9    if !TileDescriptorLegal(destination) ||10       !TileSourceContentsDefined(source) then11        return FALSE;12    end;13    let destination_tile = _Tiles[[destination]];14    let source_tile = _Tiles[[source]];15    if !TileCarrierOnlyDataTypeSupported(source_tile.data_type) &&16       !TileSourceEncodingsValid(source) then17        return FALSE;18    end;19    return destination_tile.storage_kind == TileStorage_Numeric &&20           source_tile.storage_kind == TileStorage_Numeric &&21           TileCarrierOrMove24BaselineDataTypeSupported(22               destination_tile.data_type) &&23           destination_tile.data_type == source_tile.data_type &&24           TileLayoutShapeLegal(destination_tile) &&25           TileLayoutShapeLegal(source_tile) &&26           row_offset + destination_tile.valid_rows <=27               source_tile.valid_rows &&28           column_offset + destination_tile.valid_columns <=29               source_tile.valid_columns;30end;31
32readonly func TileOperandsLegal_TINSERT(33    destination: TileIndex,34    old_destination: TileIndex,35    source: TileIndex,36    row_offset: integer {0..65535},37    column_offset: integer {0..65535}) => boolean38begin39    if !TileDescriptorLegal(destination) ||40       !TileSourceContentsDefined(old_destination) ||41       !TileSourceContentsDefined(source) then42        return FALSE;43    end;44    let destination_tile = _Tiles[[destination]];45    let old_tile = _Tiles[[old_destination]];46    let source_tile = _Tiles[[source]];47    if (!TileCarrierOnlyDataTypeSupported(old_tile.data_type) &&48        !TileSourceEncodingsValid(old_destination)) ||49       (!TileCarrierOnlyDataTypeSupported(source_tile.data_type) &&50        !TileSourceEncodingsValid(source)) then51        return FALSE;52    end;53    return destination_tile.storage_kind == TileStorage_Numeric &&54           old_tile.storage_kind == TileStorage_Numeric &&55           source_tile.storage_kind == TileStorage_Numeric &&56           TileCarrierOrMove24BaselineDataTypeSupported(57               destination_tile.data_type) &&58           TileShapeAndTypeMatch(destination, old_destination) &&59           destination_tile.data_type == source_tile.data_type &&60           TileLayoutShapeLegal(destination_tile) &&61           TileLayoutShapeLegal(old_tile) &&62           TileLayoutShapeLegal(source_tile) &&63           row_offset + source_tile.valid_rows <=64               destination_tile.valid_rows &&65           column_offset + source_tile.valid_columns <=66               destination_tile.valid_columns;67end;68
69readonly func TileOperandsLegal_TCONCAT(70    destination: TileIndex,71    source_left: TileIndex,72    source_right: TileIndex) => boolean73begin74    if !TileDescriptorLegal(destination) ||75       !TileSourceContentsDefined(source_left) ||76       !TileSourceContentsDefined(source_right) ||77       _Tiles[[destination]].data_type != _Tiles[[source_left]].data_type ||78       _Tiles[[destination]].data_type != _Tiles[[source_right]].data_type then79        return FALSE;80    end;81    let destination_tile = _Tiles[[destination]];82    let left_tile = _Tiles[[source_left]];83    let right_tile = _Tiles[[source_right]];84    if !TileCarrierOnlyDataTypeSupported(left_tile.data_type) &&85       (!TileSourceEncodingsValid(source_left) ||86        !TileSourceEncodingsValid(source_right)) then87        return FALSE;88    end;89    return destination_tile.storage_kind == TileStorage_Numeric &&90           left_tile.storage_kind == TileStorage_Numeric &&91           right_tile.storage_kind == TileStorage_Numeric &&92           TileCarrierOrMove24BaselineDataTypeSupported(93               destination_tile.data_type) &&94           left_tile.valid_rows > 0 &&95           left_tile.valid_rows == right_tile.valid_rows &&96           destination_tile.valid_rows == left_tile.valid_rows &&97           destination_tile.valid_columns ==98               left_tile.valid_columns + right_tile.valid_columns &&99           TileLayoutShapeLegal(destination_tile) &&100           TileLayoutShapeLegal(left_tile) &&101           TileLayoutShapeLegal(right_tile);102end;103
104pure func TileCellRearrangementLayoutLegal(layout: TileLayout) => boolean105begin106    return layout == TileLayout_CUBE_M16 ||107           layout == TileLayout_CUBE_M32;108end;109
110readonly func TileCellRearrangementDescriptorLegal(index: TileIndex)111    => boolean112begin113    return TileCubeDescriptorLegal(_Tiles[[index]]) &&114           TileCellRearrangementLayoutLegal(_Tiles[[index]].layout);115end;116
117pure func TileCellRearrangementRowBytes(layout: TileLayout) => integer {4,8}118begin119    return if layout == TileLayout_CUBE_M32 then 4 else 8;120end;121
122pure func TileRearrangementControlWordLegal(control: Word) => boolean123begin124    return control[63:32] == Zeros{32};125end;126
127readonly func TileCellRearrangementValidBytes(tile: TileInfo)128    => integer {0..262144}129begin130    return ((tile.valid_columns * TileElementBits(tile.data_type) + 7) DIVRM 8)131        as integer {0..262144};132end;133
134readonly func TileCellRearrangementWordsPerRow(tile: TileInfo)135    => integer {0..65536}136begin137    return ((TileCellRearrangementValidBytes(tile) + 3) DIVRM 4)138        as integer {0..65536};139end;140
141readonly func TileCellRearrangementByteDefined(142    tile: TileInfo, row: integer {0..65535},143    byte_index: integer {0..262143}) => boolean144begin145    let element_bits = TileElementBits(tile.data_type);146    if element_bits == 4 then147        assert byte_index <= 32767;148        let first_byte_index = byte_index as integer {0..32767};149        let first_nibble = (first_byte_index * 2) as integer {0..65535};150        if first_nibble >= tile.valid_columns then return FALSE; end;151        let first_element = TileLogicalLinearIndex(tile, row,152            first_nibble as integer {0..65535});153        if !TileLogicalElementDefined(tile, first_element) then154            return FALSE;155        end;156        if first_nibble + 1 < tile.valid_columns then157            let second_element = TileLogicalLinearIndex(tile, row,158                (first_nibble + 1) as integer {0..65535});159            return TileLogicalElementDefined(tile, second_element);160        end;161        return TRUE;162    end;163    let element_bytes = TileElementBytes(tile.data_type);164    let element_column = (byte_index DIVRM element_bytes)165        as integer {0..65535};166    if element_column >= tile.valid_columns then return FALSE; end;167    let element = TileLogicalLinearIndex(tile, row,168        element_column as integer {0..65535});169    return TileLogicalElementDefined(tile, element);170end;171
172readonly func TileReadCellByte(tile: TileInfo,173                               row: integer {0..65535},174                               byte_index: integer {0..262143}) => Byte175begin176    let element_bits = TileElementBits(tile.data_type);177    if element_bits == 4 then178        assert byte_index <= 32767;179        let first_byte_index = byte_index as integer {0..32767};180        let first_nibble = (first_byte_index * 2) as integer {0..65535};181        let first_element = TileLogicalLinearIndex(tile, row,182            first_nibble as integer {0..65535});183        var result = Zeros{8};184        result[3:0] = TileReadLogicalElement(tile, first_element)[3:0];185        if first_nibble + 1 < tile.valid_columns then186            let second_element = TileLogicalLinearIndex(tile, row,187                (first_nibble + 1) as integer {0..65535});188            result[7:4] = TileReadLogicalElement(tile,189                second_element)[3:0];190        end;191        return result;192    end;193    let element_bytes = TileElementBytes(tile.data_type);194    let element_column = (byte_index DIVRM element_bytes)195        as integer {0..65535};196    let byte_in_element = (byte_index MOD element_bytes) as integer {0..7};197    let element = TileLogicalLinearIndex(tile, row,198        element_column as integer {0..65535});199    return TileReadLogicalElement(tile, element)[(byte_in_element * 8) +: 8];200end;201
202readonly func TileCellRearrangementValidRegionDefined(tile: TileInfo)203    => boolean204begin205    let valid_bytes = TileCellRearrangementValidBytes(tile);206    for row = 0 to tile.valid_rows - 1 looplimit 65536 do207        for byte_index = 0 to valid_bytes - 1 looplimit 262144 do208            if !TileCellRearrangementByteDefined(tile,209                row as integer {0..65535}, byte_index) then210                return FALSE;211            end;212        end;213    end;214    return TRUE;215end;216
217readonly func TileOperandsLegal_TPERMUTE(218    destination: TileIndex, source0: TileIndex,219    source1: TileIndex, indices: TileIndex) => boolean220begin221    if !TileCellRearrangementDescriptorLegal(destination) ||222       !TileCellRearrangementDescriptorLegal(source0) ||223       !TileCellRearrangementDescriptorLegal(source1) ||224       !TileCellRearrangementDescriptorLegal(indices) || destination == source0 ||225       destination == source1 || indices == source0 || indices == source1 then226        return FALSE;227    end;228    let destination_tile = _Tiles[[destination]];229    let left = _Tiles[[source0]];230    let right = _Tiles[[source1]];231    let index_tile = _Tiles[[indices]];232    if destination_tile.storage_kind != TileStorage_Numeric ||233       left.storage_kind != TileStorage_Numeric ||234       right.storage_kind != TileStorage_Numeric ||235       index_tile.storage_kind != TileStorage_Numeric ||236       !TileCellRearrangementLayoutLegal(destination_tile.layout) ||237       destination_tile.layout != left.layout ||238       destination_tile.layout != right.layout ||239       destination_tile.data_type != left.data_type ||240       destination_tile.data_type != right.data_type ||241       !TileCubeDataTypeSupported(destination_tile.data_type) ||242       TileElementBits(destination_tile.data_type) == 64 ||243       index_tile.data_type != TileDataType_U8 ||244       index_tile.layout != destination_tile.layout ||245       destination_tile.valid_rows != left.valid_rows ||246       destination_tile.valid_rows != right.valid_rows ||247       destination_tile.valid_columns != left.valid_columns ||248       destination_tile.valid_columns != right.valid_columns ||249       index_tile.valid_rows != destination_tile.valid_rows ||250       index_tile.valid_columns !=251           TileCellRearrangementValidBytes(destination_tile) ||252       index_tile.cube_cell_count != destination_tile.cube_cell_count then253        return FALSE;254    end;255    let row_bytes = TileCellRearrangementRowBytes(destination_tile.layout);256    let valid_bytes = TileCellRearrangementValidBytes(destination_tile);257    if valid_bytes > row_bytes * destination_tile.cube_cell_count then258        return FALSE;259    end;260    for row = 0 to destination_tile.valid_rows - 1 looplimit 65536 do261        for byte_index = 0 to valid_bytes - 1 looplimit 262144 do262            if !TileCellRearrangementByteDefined(index_tile,263                row as integer {0..65535}, byte_index) then264                return FALSE;265            end;266            let index_element = TileLogicalLinearIndex(index_tile,267                row as integer {0..65535}, byte_index as integer {0..65535});268            let index_value = UInt(TileReadLogicalElement(269                index_tile, index_element));270            if index_value >= row_bytes * 2 then return FALSE; end;271            let cell_base = (byte_index DIVRM row_bytes) * row_bytes;272            let selected_byte = if index_value < row_bytes then273                index_value else index_value - row_bytes;274            let source_byte = cell_base + selected_byte;275            let selected_source = if index_value < row_bytes then276                left else right;277            if !TileCellRearrangementByteDefined(selected_source,278                row as integer {0..65535},279                source_byte as integer {0..262143}) then280                return FALSE;281            end;282        end;283    end;284    return TRUE;285end;286
287readonly func TileOperandsLegal_TSHUF(288    destination: TileIndex, source: TileIndex,289    controls: TileIndex, control: Word) => boolean290begin291    if !TileCellRearrangementDescriptorLegal(destination) ||292       !TileCellRearrangementDescriptorLegal(source) ||293       !TileCellRearrangementDescriptorLegal(controls) || destination == source ||294       destination == controls then return FALSE; end;295    let destination_tile = _Tiles[[destination]];296    let source_tile = _Tiles[[source]];297    let control_tile = _Tiles[[controls]];298    let mode = UInt(control[7:0]);299    let segment_code = UInt(control[15:8]);300    let boundary = UInt(control[23:16]);301    if destination_tile.storage_kind != TileStorage_Numeric ||302       source_tile.storage_kind != TileStorage_Numeric ||303       control_tile.storage_kind != TileStorage_Numeric ||304       !TileCellRearrangementLayoutLegal(destination_tile.layout) ||305       destination_tile.layout != source_tile.layout ||306       destination_tile.layout != control_tile.layout ||307       destination_tile.data_type != source_tile.data_type ||308       control_tile.data_type != TileDataType_U32 ||309       destination_tile.valid_rows != source_tile.valid_rows ||310       destination_tile.valid_columns != source_tile.valid_columns ||311       control_tile.valid_rows != source_tile.valid_rows ||312       control_tile.valid_columns !=313           TileCellRearrangementWordsPerRow(source_tile) ||314       control_tile.cube_cell_count != source_tile.cube_cell_count ||315       mode > 3 || boundary > 1 || segment_code > 4 ||316       (segment_code == 4 &&317        destination_tile.layout != TileLayout_CUBE_M32) ||318       (destination_tile.layout == TileLayout_CUBE_M16 &&319        segment_code == 4) || !TileRearrangementControlWordLegal(control) ||320       !TileCubeDataTypeSupported(destination_tile.data_type) ||321       TileElementBits(destination_tile.data_type) == 64 ||322       !TileCellRearrangementValidRegionDefined(source_tile) ||323       !TileCellRearrangementValidRegionDefined(control_tile) then324        return FALSE;325    end;326    return TRUE;327end;328
329readonly func TileOperandsLegal_TPACK(330    destination: TileIndex, source0: TileIndex,331    source1: TileIndex, control: Word) => boolean332begin333    if !TileCellRearrangementDescriptorLegal(destination) ||334       !TileCellRearrangementDescriptorLegal(source0) ||335       !TileCellRearrangementDescriptorLegal(source1) || destination == source0 ||336       destination == source1 then return FALSE; end;337    let destination_tile = _Tiles[[destination]];338    let left = _Tiles[[source0]];339    let right = _Tiles[[source1]];340    let left_bytes = UInt(control[7:0]);341    let right_bytes = UInt(control[15:8]);342    return destination_tile.storage_kind == TileStorage_Numeric &&343           left.storage_kind == TileStorage_Numeric &&344           right.storage_kind == TileStorage_Numeric &&345           TileCellRearrangementLayoutLegal(destination_tile.layout) &&346           destination_tile.layout == left.layout &&347           destination_tile.layout == right.layout &&348           destination_tile.data_type == TileDataType_U32 &&349           left.data_type == TileDataType_U32 &&350           right.data_type == TileDataType_U32 &&351           destination_tile.valid_rows == left.valid_rows &&352           destination_tile.valid_rows == right.valid_rows &&353           destination_tile.valid_columns == left.valid_columns &&354           destination_tile.valid_columns == right.valid_columns &&355           left_bytes >= 1 && left_bytes <= 3 &&356           right_bytes >= 1 && right_bytes <= 3 &&357           left_bytes + right_bytes <= 4 &&358           TileRearrangementControlWordLegal(control) &&359           TileCellRearrangementValidRegionDefined(left) &&360           TileCellRearrangementValidRegionDefined(right);361end;362
363readonly func TileOperandsLegal_TUNPACK(364    destination: TileIndex, source: TileIndex, control: Word) => boolean365begin366    if !TileCellRearrangementDescriptorLegal(destination) ||367       !TileCellRearrangementDescriptorLegal(source) || destination == source then368        return FALSE;369    end;370    let destination_tile = _Tiles[[destination]];371    let source_tile = _Tiles[[source]];372    let offset = UInt(control[7:0]);373    let count = UInt(control[15:8]);374    return destination_tile.storage_kind == TileStorage_Numeric &&375           source_tile.storage_kind == TileStorage_Numeric &&376           TileCellRearrangementLayoutLegal(destination_tile.layout) &&377           destination_tile.layout == source_tile.layout &&378           destination_tile.data_type == TileDataType_U32 &&379           source_tile.data_type == TileDataType_U32 &&380           destination_tile.valid_rows == source_tile.valid_rows &&381           destination_tile.valid_columns == source_tile.valid_columns &&382           offset <= 3 && count >= 1 && count <= 4 && offset + count <= 4 &&383           TileRearrangementControlWordLegal(control) &&384           TileCellRearrangementValidRegionDefined(source_tile);385end;386