fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-06-04 00:08:16 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

kk: Enable code formatting enforcement

Browse source 
Reviewed-by: Aitor Camacho <aitor@lunarg.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/41784>
This commit is contained in:
squidbus 2026-05-25 07:29:49 -07:00 • committed by Marge Bot
parent 01faf29bef
commit c07a203ef4
13 changed files with 56 additions and 65 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
.clang-format-include
View file

@ -12,3 +12,4 @@ src/amd/compiler/**/*
src/egl/**/*
src/etnaviv/isa/**/*
src/imagination/**/*
src/kosmickrisp/**/*

3
src/kosmickrisp/bridge/mtl_render_state.h
View file

@ -75,8 +75,7 @@ void mtl_render_pass_descriptor_set_default_raster_sample_count(
void mtl_render_pass_descriptor_set_sample_positions(
mtl_render_pass_descriptor *descriptor,
const struct mtl_sample_position *positions,
uint32_t count);
const struct mtl_sample_position *positions, uint32_t count);
void mtl_render_pass_descriptor_set_visibility_buffer(
mtl_render_pass_descriptor *descriptor, mtl_buffer *visibility_buffer);

3
src/kosmickrisp/bridge/stubs/mtl_render_state.c
View file

@ -117,8 +117,7 @@ mtl_render_pass_descriptor_set_default_raster_sample_count(
void
mtl_render_pass_descriptor_set_sample_positions(
mtl_render_pass_descriptor *descriptor,
const struct mtl_sample_position *positions,
uint32_t count)
const struct mtl_sample_position *positions, uint32_t count)
{
}

6
src/kosmickrisp/compiler/msl_iomap.c
View file

@ -70,10 +70,12 @@ static const struct {
[VARYING_SLOT_CLIP_DIST1] = {"clip_1", .user = true, .scalarized = true},
[VARYING_SLOT_CULL_DIST0] = {"cull_0", .user = true, .scalarized = true},
[VARYING_SLOT_CULL_DIST1] = {"cull_1", .user = true, .scalarized = true},
[VARYING_SLOT_CULL_PRIMITIVE] = {"cull_primitive_0", .user = true, .scalarized = true},
[VARYING_SLOT_CULL_PRIMITIVE] = {"cull_primitive_0", .user = true,
.scalarized = true},
/* Using cull primitive slots to emulate cull distances in fragment shader,
* which may extend to one varying extra (which is otherwise unused) */
[VARYING_SLOT_CULL_PRIMITIVE + 1] = {"cull_primitive_1", .user = true, .scalarized = true},
[VARYING_SLOT_CULL_PRIMITIVE + 1] = {"cull_primitive_1", .user = true,
.scalarized = true},
[VARYING_SLOT_VAR0] = {"vary_00", .user = true},
[VARYING_SLOT_VAR1] = {"vary_01", .user = true},
[VARYING_SLOT_VAR2] = {"vary_02", .user = true},

19
src/kosmickrisp/compiler/msl_nir_lower_common.c
View file

@ -258,8 +258,9 @@ msl_ensure_vertex_point_size_output(nir_shader *nir)
.num_slots = 1u,
};
nir_store_output(&b, nir_imm_float(&b, 1.0f), nir_imm_int(&b, 0u),
.base = 0u, .range = 1u, .write_mask = 0x1, .component = 0u,
.src_type = nir_type_float32, .io_semantics = io_semantics);
.base = 0u, .range = 1u, .write_mask = 0x1,
.component = 0u, .src_type = nir_type_float32,
.io_semantics = io_semantics);
nir->info.outputs_written |= BITFIELD64_BIT(VARYING_SLOT_PSIZ);
return nir_progress(true, entrypoint, nir_metadata_control_flow);
}
@ -457,9 +458,8 @@ lower_clip_cull_distance_write(nir_builder *b, nir_intrinsic_instr *intr,
if (sem.location == VARYING_SLOT_CLIP_DIST0 ||
sem.location == VARYING_SLOT_CLIP_DIST1) {
/* Clip distance, add write to MSL clip_distance output */
unsigned component =
(location - VARYING_SLOT_CLIP_DIST0) * 4 +
nir_intrinsic_component(intr);
unsigned component = (location - VARYING_SLOT_CLIP_DIST0) * 4 +
nir_intrinsic_component(intr);
b->cursor = nir_after_instr(&intr->instr);
nir_store_clip_distance_kk(b, intr->src[0].ssa, .base = component);
@ -469,9 +469,8 @@ lower_clip_cull_distance_write(nir_builder *b, nir_intrinsic_instr *intr,
if (sem.location == VARYING_SLOT_CULL_DIST0 ||
sem.location == VARYING_SLOT_CULL_DIST1) {
/* Cull distance, add write to cull primitive output */
unsigned component =
(location - VARYING_SLOT_CULL_DIST0) * 4 +
nir_intrinsic_component(intr);
unsigned component = (location - VARYING_SLOT_CULL_DIST0) * 4 +
nir_intrinsic_component(intr);
b->cursor = nir_before_instr(&intr->instr);
nir_def *offs = nir_imm_int(b, component / 4);
@ -525,8 +524,7 @@ msl_nir_lower_cull_distance_fs(nir_shader *s, unsigned nr_distances)
nir_def *baryc = nir_load_barycentric_pixel(
b, 32, .interp_mode = INTERP_MODE_NOPERSPECTIVE);
nir_def *cull = nir_load_interpolated_input(
b, 1, 32, baryc, nir_imm_int(b, 0),
.component = i & 3,
b, 1, 32, baryc, nir_imm_int(b, 0), .component = i & 3,
.io_semantics.location = VARYING_SLOT_CULL_PRIMITIVE + (i / 4),
.io_semantics.num_slots = nr_distances / 4);
@ -537,7 +535,6 @@ msl_nir_lower_cull_distance_fs(nir_shader *s, unsigned nr_distances)
* Note that, since the value is interpolated at the pixel center, we
* don't have to worry about corner values. */
culled = nir_ior(b, culled, nir_ball(b, nir_feq_imm(b, cull, 0)));
}
/* Emulate primitive culling by discarding fragments */

10
src/kosmickrisp/vulkan/kk_image_layout.c
View file

@ -15,8 +15,7 @@
#include "util/format/u_format.h"
static enum mtl_texture_type
vk_image_to_mtl_texture_type(
const struct vk_image *image)
vk_image_to_mtl_texture_type(const struct vk_image *image)
{
uint32_t array_layers = image->array_layers;
uint32_t samples = image->samples;
@ -106,8 +105,7 @@ kk_image_layout_can_optimize(VkImageUsageFlags usage, VkImageTiling tiling,
}
void
kk_image_layout_init(const struct kk_device *dev,
const struct vk_image *image,
kk_image_layout_init(const struct kk_device *dev, const struct vk_image *image,
enum pipe_format format, const uint8_t width_scale,
const uint8_t height_scale, struct kk_image_layout *layout)
{
@ -119,8 +117,8 @@ kk_image_layout_init(const struct kk_device *dev,
layout->layers = image->array_layers;
layout->levels = image->mip_levels;
layout->linear = image->tiling != VK_IMAGE_TILING_OPTIMAL;
layout->optimized_layout = kk_image_layout_can_optimize(
image->usage, image->tiling, format);
layout->optimized_layout =
kk_image_layout_can_optimize(image->usage, image->tiling, format);
layout->usage = vk_image_usage_flags_to_mtl_texture_usage(
image->usage, image->create_flags, supported_format->atomic);
layout->format.pipe = format;

5
src/kosmickrisp/vulkan/kk_image_layout.h
View file

@ -141,9 +141,8 @@ bool kk_image_layout_can_optimize(VkImageUsageFlags usage, VkImageTiling tiling,
enum pipe_format format);
void kk_image_layout_init(const struct kk_device *dev,
const struct vk_image *image,
enum pipe_format format, const uint8_t width_scale,
const uint8_t height_scale,
const struct vk_image *image, enum pipe_format format,
const uint8_t width_scale, const uint8_t height_scale,
struct kk_image_layout *layout);
#endif /* KK_IMAGE_LAYOUT_H */

12
src/kosmickrisp/vulkan/kk_nir_lower_descriptors.c
View file

@ -106,8 +106,7 @@ lower_load_constant(nir_builder *b, nir_intrinsic_instr *load,
offsetof(struct kk_root_descriptor_table, member)
/* helper macro for computing per-draw data byte offsets */
#define kk_per_draw_offset(member) \
offsetof(struct kk_per_draw_data, member)
#define kk_per_draw_offset(member) offsetof(struct kk_per_draw_data, member)
static nir_def *
load_descriptor_set_addr(nir_builder *b, uint32_t set,
@ -130,7 +129,8 @@ load_dynamic_buffer_start(nir_builder *b, uint32_t set,
break;
}
dynamic_buffer_start_imm += ctx->set_layouts[s]->vk.dynamic_descriptor_count;
dynamic_buffer_start_imm +=
ctx->set_layouts[s]->vk.dynamic_descriptor_count;
}
if (dynamic_buffer_start_imm >= 0) {
@ -296,9 +296,9 @@ _lower_sysval_to_per_draw(nir_builder *b, nir_intrinsic_instr *intrin,
b->cursor = nir_instr_remove(&intrin->instr);
assert((per_draw_offset & 3) == 0 && "aligned");
nir_def *val = load_per_draw(b, intrin->def.num_components,
intrin->def.bit_size,
nir_imm_int(b, per_draw_offset), 4);
nir_def *val =
load_per_draw(b, intrin->def.num_components, intrin->def.bit_size,
nir_imm_int(b, per_draw_offset), 4);
nir_def_rewrite_uses(&intrin->def, val);

14
src/kosmickrisp/vulkan/kk_nir_lower_null_images.c
View file

@ -11,8 +11,8 @@
#include "compiler/nir/nir.h"
#include "compiler/nir/nir_builder.h"
static nir_def*
tex_handle_to_resource_id(nir_builder *b, nir_def* handle)
static nir_def *
tex_handle_to_resource_id(nir_builder *b, nir_def *handle)
{
/* Work backwards from the handle to the descriptor address it was loaded
* from, and load the plain resource ID */
@ -21,7 +21,7 @@ tex_handle_to_resource_id(nir_builder *b, nir_def* handle)
return nir_load_global_constant(b, 1, 64, intr->src[0].ssa);
}
static nir_def*
static nir_def *
get_is_null(nir_builder *b, nir_instr *instr, nir_def **def)
{
*def = NULL;
@ -57,7 +57,7 @@ get_is_null(nir_builder *b, nir_instr *instr, nir_def **def)
if (!handle)
return NULL;
nir_def* resource_id = tex_handle_to_resource_id(b, handle);
nir_def *resource_id = tex_handle_to_resource_id(b, handle);
return nir_ieq_imm(b, resource_id, 0);
}
@ -100,8 +100,8 @@ lower(nir_builder *b, nir_instr *instr, UNUSED void *data)
return true;
}
bool kk_nir_lower_null_images(nir_shader *shader)
bool
kk_nir_lower_null_images(nir_shader *shader)
{
return nir_shader_instructions_pass(shader, lower,
nir_metadata_none, NULL);
return nir_shader_instructions_pass(shader, lower, nir_metadata_none, NULL);
}

4
src/kosmickrisp/vulkan/kk_nir_lower_vbo.c
View file

@ -203,8 +203,8 @@ pass(struct nir_builder *b, nir_intrinsic_instr *intr, void *data)
.format = interchange_format, .base = 0u);
if (ctx->requires_robustness2) {
uint64_t attrib_clamp_offset = offsetof(
struct kk_root_descriptor_table, draw.attrib_clamps[index]);
uint64_t attrib_clamp_offset =
offsetof(struct kk_root_descriptor_table, draw.attrib_clamps[index]);
nir_def *bounds = nir_load_global_constant(
b, 1, 32, nir_iadd_imm(b, argbuf, attrib_clamp_offset));
nir_def *oob = nir_ult(b, bounds, el);

12
src/kosmickrisp/vulkan/kk_physical_device.c
View file

@ -410,9 +410,8 @@ kk_get_device_properties(const struct kk_physical_device *pdev,
{
VkSampleCountFlagBits sample_counts = VK_SAMPLE_COUNT_1_BIT;
for (uint32_t sample_count = VK_SAMPLE_COUNT_2_BIT;
sample_count <= VK_SAMPLE_COUNT_8_BIT; sample_count <<= 1) {
if (mtl_device_supports_sample_count(pdev->mtl_dev_handle,
sample_count))
sample_count <= VK_SAMPLE_COUNT_8_BIT; sample_count <<= 1) {
if (mtl_device_supports_sample_count(pdev->mtl_dev_handle, sample_count))
sample_counts |= sample_count;
}
@ -909,8 +908,8 @@ kk_get_sysmem_heap_budget(struct kk_physical_device *pdev)
uint64_t sysmem_used_B = sysmem_size_B - sysmem_available_B;
uint64_t sysmem_budget_B =
mtl_device_recommended_max_working_set_size(pdev->mtl_dev_handle);
uint64_t remaining_budget_B = sysmem_budget_B > sysmem_used_B ?
sysmem_budget_B - sysmem_used_B : 0u;
uint64_t remaining_budget_B =
sysmem_budget_B > sysmem_used_B ? sysmem_budget_B - sysmem_used_B : 0u;
return remaining_budget_B +
mtl_device_current_allocated_size(pdev->mtl_dev_handle);
}
@ -1169,8 +1168,7 @@ kk_GetPhysicalDeviceQueueFamilyProperties2(
p->queueFamilyProperties.minImageTransferGranularity =
(VkExtent3D){1, 1, 1};
vk_foreach_struct(ext, p->pNext)
{
vk_foreach_struct(ext, p->pNext) {
switch (ext->sType) {
case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES: {
VkQueueFamilyGlobalPriorityProperties *pSub = (void *)ext;

4
src/kosmickrisp/vulkan/kk_queue.c
View file

@ -95,8 +95,8 @@ kk_queue_init(struct kk_device *dev, struct kk_queue *queue,
vk_find_struct_const(pCreateInfo->pNext,
DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO);
const VkQueueGlobalPriority global_priority =
priority_info ? priority_info->globalPriority :
VK_QUEUE_GLOBAL_PRIORITY_MEDIUM;
priority_info ? priority_info->globalPriority
: VK_QUEUE_GLOBAL_PRIORITY_MEDIUM;
/* From the Vulkan 1.3.295 spec:
*

28
src/kosmickrisp/vulkan/kk_shader.c
View file

@ -318,7 +318,8 @@ kk_lower_vs_vbo(nir_shader *nir, const struct vk_graphics_pipeline_state *state,
attributes[slot].instanced =
binding->input_rate == VK_VERTEX_INPUT_RATE_INSTANCE;
}
bool robustness2 = rs->vertex_inputs ==
bool robustness2 =
rs->vertex_inputs ==
VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2;
NIR_PASS(_, nir, kk_nir_lower_vbo, attributes, robustness2);
}
@ -407,8 +408,8 @@ static void
kk_lower_fs(struct kk_device *dev, nir_shader *nir,
const struct vk_graphics_pipeline_state *state)
{
nir->info.fs.uses_sample_shading |= state->ms &&
state->ms->sample_shading_enable;
nir->info.fs.uses_sample_shading |=
state->ms && state->ms->sample_shading_enable;
/* msl_nir_lower_sample_shading needs to go before blending since
* nir_lower_blend will always set uses_sample_shading to true if there's any
@ -453,8 +454,8 @@ kk_lower_fs(struct kk_device *dev, nir_shader *nir,
nir_def *sample_id = nir_load_sample_id(&b);
nir_def *sample_bit = nir_ishl(&b, nir_imm_int(&b, 1), sample_id);
nir_def *sample_mask_bit = nir_iand(&b, nir_load_sample_mask_in(&b),
sample_bit);
nir_def *sample_mask_bit =
nir_iand(&b, nir_load_sample_mask_in(&b), sample_bit);
nir_discard_if(&b, nir_ieq_imm(&b, sample_mask_bit, 0u));
}
}
@ -1168,11 +1169,10 @@ kk_compile_shaders(struct vk_device *device, uint32_t shader_count,
nir_opts, NULL);
for (uint32_t i = 0; i < shader_count; i++) {
struct kk_shader *prev_stage = i > 0 ?
container_of(shaders_out[i - 1], struct kk_shader, vk) : NULL;
result =
kk_compile_shader(dev, &infos[i], prev_stage, state, pAllocator,
&shaders_out[i]);
struct kk_shader *prev_stage =
i > 0 ? container_of(shaders_out[i - 1], struct kk_shader, vk) : NULL;
result = kk_compile_shader(dev, &infos[i], prev_stage, state, pAllocator,
&shaders_out[i]);
if (result != VK_SUCCESS) {
/* Clean up all the shaders before this point */
for (uint32_t j = 0; j < i; j++)
@ -1211,9 +1211,8 @@ kk_compile_shaders(struct vk_device *device, uint32_t shader_count,
.robustness = &rs_none,
};
struct vk_shader *frag_shader;
result =
kk_compile_shader(dev, &info, fs, state, &dev->vk.alloc,
&frag_shader);
result = kk_compile_shader(dev, &info, fs, state, &dev->vk.alloc,
&frag_shader);
if (result != VK_SUCCESS) {
for (uint32_t i = 0; i < shader_count; i++)
@ -1227,8 +1226,7 @@ kk_compile_shaders(struct vk_device *device, uint32_t shader_count,
fs = container_of(frag_shader, struct kk_shader, vk);
}
gather_graphics_pipeline_create_info(
state, &vs->info, fs);
gather_graphics_pipeline_create_info(state, &vs->info, fs);
result = kk_compile_graphics_pipeline(
dev, vs->msl_code, vs->entrypoint_name, fs->msl_code,
fs->entrypoint_name, &vs->info, &vs->pipeline);